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

admin

如果想要自己写一个服务器和客户端，我们需要掌握一定的网络编程技术，个人认为，网络编程中最关键的就是这个东西——socket（套接字）。
8 j* g1 N! }! N' {. P# K
" M6 {  i3 H! G4 P1 z
0 x  @* k: P8 L$ B' n1 N/ Fsocket（套接字）：简单来讲，socket就是用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。
) W+ H2 i! Q1 S9 ^- ~4 e8 b4 v

7 c! n9 v" K" D& c/ R$ c$ |TCP协议
. i% O  d- R* j; ?( c- NTCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。


6 t4 z2 k0 _9 M5 s- G' t7 s3 c关键词：三次握手，可靠，基于字节流。

2 C+ i( f. u0 Z) u  m% W4 T- a
可能有朋友会问，TCP就这么简单一句话吗？当然不是，TCP作为非常重要的传输协议，细节知识是很多的，细讲起来这一篇文章怕是不够。不过在本篇内容中，我们只需了解他的几个关键词特性，就能很好的理解下面的内容。
" Z4 Y+ y/ Y% B7 f5 H+ h( q
TCP服务器端和客户端的运行流程
, M1 W( {+ E+ ], V

如图，这是一个完整的TCP服务器——客户端的运行流程图，其实我个人认为程序啊，不管哪个语言都是一样，核心就在于算法的设计和函数的调用。那么图中的函数都是什么意思呢？


1.创建socket
2 I. `# u% g+ _( m socket是一个结构体，被创建在内核中
sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议

! S1 s% i0 @8 T7 w7 ^. c
9 [" o( p+ I: ~) H% w2.调用bind函数
将socket和地址（包括ip、port）绑定。
8 j6 g6 M5 g' l! C* n% B 需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
4 L1 K7 @, D+ Z5 |: P6 { struct sockaddr_in myaddr; //地址结构体
5 _' ~: |0 b3 l& B/ L# a bind函数
/ a  R8 c" Z, \: S, m5 Q bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))


3.listen监听，将接收到的客户端连接放入队列
listen(sockfd,8) //第二个参数是队列长度

# e3 h- W5 }, p" N+ I8 o8 H
4.调用accept函数，从队列获取请求，返回socket描 述符
0 M' C3 z3 g+ k/ Z6 F. @% r  如果无请求，将会阻塞，直到获得连接
  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数
* Y; E/ \1 m0 b
# g) ?+ J; u9 y
5.调用read/write进行双向通信


6 h, [7 k; o1 D# u" q# K6 ?# o: @2 e6.关闭accept返回的socket
  close(scokfd);



( z: }0 Y; U4 s
下面放出完整代码

1. /*服务器*/
   
2. #include <stdio.h>
   ( m2 O, ]6 u( x. ]0 X& h" t
3. #include <string.h>
   2 A' p0 t2 \7 f( O7 \  T: g
4. #include <stdlib.h>
   
5. #include <strings.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   - z8 r- V2 Y7 `. M3 |) g
8. #include <arpa/inet.h>
   
9. #include <netinet/in.h>
   , j6 Z" r/ x3 w- S
10. int main()
    
11. {
    " {9 k8 }; n! L, e, L2 g
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    8 [- M$ M, z+ M& H$ |( i& E8 r
13.         if (sockfd < 0)
    9 |, ~4 W" Y# j+ y: y' E6 @/ D
14.         {
    9 C  J! N4 Z0 S9 i9 H- T
15.                 perror("socket");
    1 _3 _# q+ [+ D. m: f$ w
16.                 return -1;
    9 S3 i  V0 s4 b* t
17.         } //创建失败的错误处理
    " H: l% G' H2 R! @$ k
18.          printf("socket..............
    
19. "); //成功则打印“socket。。。。”
    
20.          
    
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    6 |. m# Q$ y. B( @! [
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    1 _8 G; p) }$ d% P) n
23.          myaddr.sin_family                 = AF_INET; //选择IPV4地址类型
    
24.          myaddr.sin_port                 = htons(8888); //选择端口号
    
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.          {
    0 K9 O0 \3 {$ o7 A# p8 S" b
29.                  perror("bind");
    
30.                  return -1;
    
31.          }
    & i  t$ Z9 }4 ]* Z" q
32.          printf("bind..........
    
33. ");
    1 T, J! g0 }) r9 n: q9 ]
34. 
    
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    : l0 u/ d. V6 N% l" W2 V
36.          {
    " z1 E8 M" |6 l+ ~2 P' v
37.                  perror("listen");
    . u$ {9 [1 _3 m! c9 p8 _9 ?' O: q! _
38.                  return -1;
      ?' T5 N% o' x1 W: k% k
39.          }
    * p- q' [6 Y: ]9 V
40.          printf("listen............
    % t: D; x+ G3 ?3 ?
41. ");
    
42.          
    
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
    1 Z; v6 k! B0 Z0 ?
44.         if (connfd < 0)
    / \' C7 B  P; j: }9 u
45.         {
    
46.                 perror("accept");
    
47.                 return -1;
    5 P* D- X* I/ n% a& @
48.         }
    / j! a0 x0 k# o$ l
49.         printf("accept..............
    
50. ");
    
51.         char buf[100];//定义一个数组用来存储接收到的数据
    # e  X: i9 f  {2 t; ]8 h$ Y* u
52.         int ret;
    0 }+ B0 \# z0 l# ~$ ]! O& S$ ^
53.         while (1)
    ) m( @% ~  Q; f6 a0 J
54.         {
    6 L4 O+ |: |% Y2 D
55.                 memset(buf, 0, sizeof(buf));
    5 L! X* G; C! |/ ~( v
56.                 ret = read(connfd, buf, sizeof(buf));
    
57.                 if (0 > ret)
    
58.                 {
    
59.                         perror("read");
    
60.                         break;
    : g2 l- O) A1 r5 e
61.                 }//执行while循环读取数据，当
    9 p( ?+ G+ O6 o& }( R
62.                 else if (0 == ret)
    1 B5 {. S7 {/ y( J
63.                 {
    
64.                         printf("write close!
    9 w. z- w! I9 a9 Z
65. ");
    : c& D& T7 J9 |! a- [8 x2 T" u
66.                         break;
    $ c! ~0 c) l/ S2 X* v  T
67.                 }
    4 N) v/ z; |9 j% T5 n& w# w
68.                 printf("recv: ");
    # ^& C3 M2 ?( b, e* J
69.                 fputs(buf, stdout);//打印接收到的数据
    
70.         }
    
71.         close(sockfd);//关闭套接字
    
72.         close(connfd);//断开连接
    
73.         return 0;
    
74. }

复制代码

& _5 S0 {- a- r4 q/ v

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   
2. #include <stdio.h>
   
3. #include <string.h>
   
4. #include <stdlib.h>
   
5. #include <strings.h>
   
6. #include <sys/types.h>
     f5 l- p. F2 F
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   * [, U) W6 i' n6 ~6 K2 [3 M
10. int main()
    * F& [$ o  d  m9 o- v
11. {
    , Q  {* \, O( c& C7 I" p
12. int sockfd;
    
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    
14.         {
    
15.                 perror("socket");
    
16.                 return -1;
      ^; ~6 ?! ]( I9 ]2 M
17.         }
    4 L# J4 l; \6 z6 g+ E% C0 T7 |; u
18.         printf("socket...........
    ; a* L, f8 W; z) ?  ~- r
19. ");
    5 J4 c2 E9 t, L5 \+ o4 D
20.         
    
21.         struct sockaddr_in srv_addr;
    1 E1 E! o+ ?# N# o# T
22.         memset(&srv_addr, 0, sizeof(srv_addr));
      Z: K# V" z6 D/ ?5 e' o% b
23.         srv_addr.sin_family                 = AF_INET;
    ; |0 Z5 \/ m2 e! o3 y
24.         srv_addr.sin_port                         = htons(8888);
    ! X$ ]& h: l  l: Y
25.         srv_addr.sin_addr.s_addr         = inet_addr("192.168.3.169");
    7 ?& E8 ]2 m- I! o' C5 Q5 _
26.         if (0 > connect(sockfd, (struct sockaddr*)&srv_addr, sizeof(srv_addr)))
    
27.         {
    & y) i  c4 H# @0 ]1 @  ^# X# T
28.                 perror("connect");
    
29.                 return -1; //exit //pthread_exit
    
30.         }
    + A' n" H/ O7 f% w
31.         printf("connect..............
    
32. ");
    
33.         char buf[100];
    
34.         int ret;
    
35.         while (1)
    8 G  y) z$ a; K6 L. u4 C. @
36.         {
    # W5 ~- C5 D6 u4 \
37.                 printf("send: ");
    
38.                 fgets(buf, sizeof(buf), stdin);
    
39.                 ret = write(sockfd, buf, sizeof(buf));
    4 m4 i" I$ V8 @+ q
40.                 if (ret < 0)
    " j6 W4 y" f& d' V  j# r$ v* F
41.                 {
    
42.                         perror("write");
    8 W0 H! u5 k- y. {* U2 Z
43.                         break;
    
44.                 }
    
45.                 if (strncmp(buf, "quit", 4) == 0)
    
46.                         break;
    
47.         }
    ! I, Y6 J$ @6 V6 r$ p' c3 M3 p
48.         close(sockfd);
    
49.         return 0;
    5 u8 p7 {: d5 y. W) b6 X
50. }

复制代码

* E. e# R+ Y! w; |) n7 c