自己动手用c语言写一个基于服务器和客户端（TCP)

admin

如果想要自己写一个服务器和客户端，我们需要掌握一定的网络编程技术，个人认为，网络编程中最关键的就是这个东西——socket（套接字）。
6 X. h% P5 m1 q' ?: \* }
" J; Z' m/ u; S" a! Y
. }% h, U* o! G$ v3 Msocket（套接字）：简单来讲，socket就是用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。


* o8 b, j% ]% q+ d& KTCP协议
TCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。

5 R! z5 ]% ]7 W6 J$ y1 S" q) Z2 o
1 [: [6 g6 H- j5 o; C( K) d关键词：三次握手，可靠，基于字节流。

, M$ x7 J. ]# z+ s
可能有朋友会问，TCP就这么简单一句话吗？当然不是，TCP作为非常重要的传输协议，细节知识是很多的，细讲起来这一篇文章怕是不够。不过在本篇内容中，我们只需了解他的几个关键词特性，就能很好的理解下面的内容。
7 Z! F$ H" r* c& S$ ~9 G
, K0 x$ W0 L" F" t9 ?0 f% {5 Z- m7 uTCP服务器端和客户端的运行流程

! ?* m3 g2 a" M6 \5 {1 {
如图，这是一个完整的TCP服务器——客户端的运行流程图，其实我个人认为程序啊，不管哪个语言都是一样，核心就在于算法的设计和函数的调用。那么图中的函数都是什么意思呢？
8 M; b) Z' e+ y3 o" W1 z

1.创建socket
socket是一个结构体，被创建在内核中
4 \$ ^0 |& Y3 |8 H sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议
: M! U+ F/ t, V
1 s1 c; W* c" p/ j$ ?# a8 k: a  V, q
3 E) k! x' F* V0 l/ @7 f% J2.调用bind函数
将socket和地址（包括ip、port）绑定。
3 B+ ~! i. s+ M" R9 z 需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
9 ~, i; T; |2 `* ^ struct sockaddr_in myaddr; //地址结构体
bind函数
$ M2 q2 `9 B4 f8 o: P bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))

$ Q9 }  d8 {- `6 I& D
3.listen监听，将接收到的客户端连接放入队列
! j3 g: u5 q" ?2 f' q! U4 U listen(sockfd,8) //第二个参数是队列长度

9 Z, j' F3 F4 m5 k/ T5 y- S
4.调用accept函数，从队列获取请求，返回socket描 述符
/ ]0 m% q) ?% Y6 M$ u  如果无请求，将会阻塞，直到获得连接
  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数


5.调用read/write进行双向通信
0 x' }. @3 ~& o5 W$ _3 M+ L
7 k: E8 M0 F4 d& \& e$ c. q
& C" I7 m4 K! d9 Y& O; |# D: r6.关闭accept返回的socket
( [8 s" B5 o4 ^2 U  close(scokfd);


+ Y" S& w% V' F- }
* h7 I' [2 l& `/ l$ X" G8 j, G
0 R" I2 B$ v  l- z下面放出完整代码

6 ?! J, N9 P7 |8 b2 Y4 M

1. /*服务器*/
   ! u4 Q3 u& w4 W) ]# H& N0 {5 z" e8 e1 N
2. #include <stdio.h>
   
3. #include <string.h>
   % a9 g9 m3 K+ a8 Y
4. #include <stdlib.h>
   
5. #include <strings.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. #include <arpa/inet.h>
   " q8 Q9 u0 U8 I9 V* z. @
9. #include <netinet/in.h>
   ' ^, q/ \/ L; V% q0 n
10. int main()
    9 Y9 q5 Y- A0 u) X! g9 [
11. {
    8 x2 k& C% p1 m4 v
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    
13.         if (sockfd < 0)
    ( A) I0 O, ^+ A/ g- B2 Q
14.         {
    
15.                 perror("socket");
    : ^2 `- R; ?6 u* o# Z
16.                 return -1;
    + Q: m5 V9 m" Y0 U0 v
17.         } //创建失败的错误处理
    " _' \- Z! g, J' T% n9 Z
18.          printf("socket..............
    ' ?8 e% A2 H( I0 L- b
19. "); //成功则打印“socket。。。。”
    
20.          
    
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    ' D5 K' S/ g- ~: G
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    . S$ q* U4 B$ N6 L& L
23.          myaddr.sin_family                 = AF_INET; //选择IPV4地址类型
    
24.          myaddr.sin_port                 = htons(8888); //选择端口号
    9 J$ B4 M, n( M  J0 b  ^6 E7 ]
25.          myaddr.sin_addr.s_addr         = inet_addr("192.168.3.169"); //选择IP地址
    
26. 
    
27. if (0 > bind(sockfd, (struct sockaddr*)&myaddr, sizeof(myaddr)))//绑定套接字
    
28.          {
    # f( p& Q! Q3 ^- X3 [7 ^* V
29.                  perror("bind");
    
30.                  return -1;
    
31.          }
    
32.          printf("bind..........
    
33. ");
    ( _2 o2 \) W- x( {2 c$ p
34. 
    
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    
36.          {
    , f! c/ t4 ]( {) k1 d% a/ n
37.                  perror("listen");
    
38.                  return -1;
    5 b7 f% F# @' A, N
39.          }
    ( n: M: B) X5 J! t* F
40.          printf("listen............
    
41. ");
    
42.          
    
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
    - c. j: @6 r2 g! s( W
44.         if (connfd < 0)
    
45.         {
    5 ~; J4 W2 j1 F; f/ b) Y- }
46.                 perror("accept");
    " Z& E0 d* x1 i( H4 o
47.                 return -1;
    
48.         }
    
49.         printf("accept..............
    1 K  o% A- J9 e+ ^2 W! B, `1 m& c
50. ");
    0 n  a; s( D: {' Q# O& ~
51.         char buf[100];//定义一个数组用来存储接收到的数据
    
52.         int ret;
    $ b! z/ Y' X) [& _
53.         while (1)
    
54.         {
    
55.                 memset(buf, 0, sizeof(buf));
    
56.                 ret = read(connfd, buf, sizeof(buf));
    
57.                 if (0 > ret)
    
58.                 {
    4 Y% ^- y4 J9 G; |. Y4 \! y
59.                         perror("read");
    
60.                         break;
    $ u! C0 n+ w" ?$ |/ D1 k/ x$ b8 G
61.                 }//执行while循环读取数据，当
    . \( n" t# q4 [5 }' q
62.                 else if (0 == ret)
    
63.                 {
    ( C% `- Y! B3 q. y( i9 E" c# X2 L
64.                         printf("write close!
    
65. ");
    
66.                         break;
    2 P; q$ z% O& \% d
67.                 }
    % Y# d7 L- {% C2 n3 f; r; g
68.                 printf("recv: ");
    
69.                 fputs(buf, stdout);//打印接收到的数据
    
70.         }
    & z7 Q8 s5 D0 ]* e7 f
71.         close(sockfd);//关闭套接字
    1 V2 p8 U" [  E" K/ m8 S: x2 q
72.         close(connfd);//断开连接
    6 [% T* s- j/ h( S3 }& B
73.         return 0;
    
74. }

复制代码

( l( E2 ?& P! i3 x4 H" H$ Z' @* z

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   
2. #include <stdio.h>
   
3. #include <string.h>
   
4. #include <stdlib.h>
   
5. #include <strings.h>
   # k  b# b9 G  L. r) f/ L6 {) T
6. #include <sys/types.h>
   5 E7 Y$ h7 a, C1 u
7. #include <sys/socket.h>
   ' r& n* `0 X0 Z
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   
10. int main()
    
11. {
    , [; Z( ?) _& y$ q8 `# j* A
12. int sockfd;
    8 D, |4 w- h8 `* N& M
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    7 O2 M2 w5 ]( }" ?$ W
14.         {
    
15.                 perror("socket");
    1 n0 L" q: e2 ]# g5 R$ _$ M7 @
16.                 return -1;
    
17.         }
    
18.         printf("socket...........
    
19. ");
    
20.         
    
21.         struct sockaddr_in srv_addr;
    ! v' ?& p: h9 h! S1 ?
22.         memset(&srv_addr, 0, sizeof(srv_addr));
    , L* G/ N' }" U# U9 v+ \
23.         srv_addr.sin_family                 = AF_INET;
    1 B  I9 c  D: w* ?' @5 E- L8 {
24.         srv_addr.sin_port                         = htons(8888);
    
25.         srv_addr.sin_addr.s_addr         = inet_addr("192.168.3.169");
      c. w" u# O* r! k
26.         if (0 > connect(sockfd, (struct sockaddr*)&srv_addr, sizeof(srv_addr)))
    8 [2 ~* q3 G- Y9 h( y
27.         {
    
28.                 perror("connect");
    9 }0 L" r! }+ B! ^+ O
29.                 return -1; //exit //pthread_exit
    
30.         }
    4 f; E0 W) T: I5 I9 b
31.         printf("connect..............
    
32. ");
    2 v, s& i- W3 }
33.         char buf[100];
    
34.         int ret;
    
35.         while (1)
    
36.         {
    ; ~4 w+ \# X9 n7 E( c- D
37.                 printf("send: ");
    # g  F8 O! H* y. ]; t' Z
38.                 fgets(buf, sizeof(buf), stdin);
    5 k: y5 _1 N* f: t' I
39.                 ret = write(sockfd, buf, sizeof(buf));
    / n9 v" w$ K  @8 _* u0 H
40.                 if (ret < 0)
    
41.                 {
    9 `2 D+ s6 a, u0 Y( m
42.                         perror("write");
    4 ?( Q7 r  T, `
43.                         break;
    ! b7 w$ C2 |9 o; C6 M
44.                 }
    % r; `* ^' f; R+ e9 s7 _  _4 W
45.                 if (strncmp(buf, "quit", 4) == 0)
    
46.                         break;
    
47.         }
    
48.         close(sockfd);
    
49.         return 0;
    
50. }

复制代码