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

admin

如果想要自己写一个服务器和客户端，我们需要掌握一定的网络编程技术，个人认为，网络编程中最关键的就是这个东西——socket（套接字）。
. L+ v, ]2 X2 Y6 ~0 {1 ]& s
" h4 f' J5 U! j# r9 K% H  S9 ^
socket（套接字）：简单来讲，socket就是用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。
- b$ H# X7 n  S! o( ]

TCP协议
. |; D8 \( M3 c: R. `, B" ATCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。


+ W! c: v. S3 o0 h关键词：三次握手，可靠，基于字节流。
- {# U( T" V  Z. F" ?1 E9 b

4 ]4 n& S0 @+ T# U可能有朋友会问，TCP就这么简单一句话吗？当然不是，TCP作为非常重要的传输协议，细节知识是很多的，细讲起来这一篇文章怕是不够。不过在本篇内容中，我们只需了解他的几个关键词特性，就能很好的理解下面的内容。

  Q7 n% X5 ^! J1 x* NTCP服务器端和客户端的运行流程
/ `/ ?( H: X0 Y6 d
+ @+ G! z0 [+ {9 o
如图，这是一个完整的TCP服务器——客户端的运行流程图，其实我个人认为程序啊，不管哪个语言都是一样，核心就在于算法的设计和函数的调用。那么图中的函数都是什么意思呢？

) E( K! q" B3 w
6 i; x! _" W2 X3 `+ B! V6 P1.创建socket
. C( X% d2 D/ l4 X socket是一个结构体，被创建在内核中
( A7 X, X0 i! Q0 S sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议
* a, l! G- b' B) @( G

# q9 A( _5 W& k+ \3 i7 x0 d2.调用bind函数
将socket和地址（包括ip、port）绑定。
需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
* `  B, k/ L0 U! D' @& L struct sockaddr_in myaddr; //地址结构体
( R  V! I3 i( Y6 ?& @) P5 ~% z bind函数
" K' H$ ^3 G2 W2 E8 R, v4 i1 y bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))
7 e# D3 Y/ I1 W% H+ H. x

3.listen监听，将接收到的客户端连接放入队列
7 h* K% F6 U' q* B: \, _ listen(sockfd,8) //第二个参数是队列长度
; v4 B# e7 [2 c- a# y

4.调用accept函数，从队列获取请求，返回socket描 述符
# u6 y3 _5 b  _  如果无请求，将会阻塞，直到获得连接
  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数
8 g+ \4 q$ E1 M6 d" ?" b
8 `7 x5 z, ?% X7 }, o5 S
5.调用read/write进行双向通信


& A0 J6 j) e% ?8 \/ T6.关闭accept返回的socket
) h$ J# H& G4 z4 }7 a) g8 [7 |( e$ o  close(scokfd);
0 e: j4 O& }1 T% M  F9 u# m
; g+ c3 D1 ^% f' O4 O


下面放出完整代码

1. /*服务器*/
   
2. #include <stdio.h>
   8 f% ?2 ~( E6 W( M# _3 Q, [
3. #include <string.h>
   / T2 y5 n( T# R) }2 }9 X5 d# h
4. #include <stdlib.h>
   
5. #include <strings.h>
   # Z+ t- q: |2 p( z5 V6 D! j
6. #include <sys/types.h>
   6 g" d1 ~/ R; m9 k* n0 Y9 V2 c- V
7. #include <sys/socket.h>
   : ?4 d6 @" o4 x" J( ~- @' V
8. #include <arpa/inet.h>
   
9. #include <netinet/in.h>
   
10. int main()
    
11. {
    
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    
13.         if (sockfd < 0)
    2 d+ q$ q. L# m* z
14.         {
    2 p' E! `- I& b+ A! {3 o
15.                 perror("socket");
    
16.                 return -1;
    5 S+ M- b0 K# C1 j, n9 B
17.         } //创建失败的错误处理
    5 c9 R. ]9 B; Z. J$ j' B  t0 k$ E
18.          printf("socket..............
    
19. "); //成功则打印“socket。。。。”
    4 U- F- S7 t9 @0 j! U
20.          
    
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    - \. m) W5 v4 T9 g, M
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. 
    6 A& Y( ^0 g- z# W6 ^- q+ s% u) m
27. if (0 > bind(sockfd, (struct sockaddr*)&myaddr, sizeof(myaddr)))//绑定套接字
    
28.          {
    
29.                  perror("bind");
    $ k. h" c4 j7 S- e7 X! D
30.                  return -1;
    
31.          }
    
32.          printf("bind..........
    . B5 h/ i( }+ B5 a9 Z1 l
33. ");
    9 ?* t; V" u" S5 F- ]$ B
34. 
    ( ]. D' n5 G) `5 \. U  a
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    
36.          {
    
37.                  perror("listen");
    8 R$ z" n& y7 [
38.                  return -1;
    0 S) u  u! \6 _5 M! w; c
39.          }
    8 I0 ^" D! G$ z) z3 \
40.          printf("listen............
    6 D( e% Q4 x( H6 X& L+ d) b
41. ");
    
42.          
    
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
    
44.         if (connfd < 0)
    
45.         {
    
46.                 perror("accept");
    - t' X6 i- s5 `# E
47.                 return -1;
      }. v  }- \2 S
48.         }
    
49.         printf("accept..............
    
50. ");
    
51.         char buf[100];//定义一个数组用来存储接收到的数据
    4 j3 ~7 ]. o1 x
52.         int ret;
    
53.         while (1)
    5 A# |! O1 @1 k- i8 L6 H3 e
54.         {
    * Y3 H4 G4 A+ I3 u
55.                 memset(buf, 0, sizeof(buf));
    
56.                 ret = read(connfd, buf, sizeof(buf));
    & {5 k2 c& d6 m
57.                 if (0 > ret)
    2 p6 G0 |  W+ [3 w/ X
58.                 {
    
59.                         perror("read");
    
60.                         break;
    1 q4 T; {: `# p/ P4 A- C" m
61.                 }//执行while循环读取数据，当
    
62.                 else if (0 == ret)
    
63.                 {
    
64.                         printf("write close!
    9 r/ T4 G3 U9 K# u5 g8 I, c$ f/ H
65. ");
    
66.                         break;
    ; U: _. @$ g7 S( K+ f
67.                 }
    
68.                 printf("recv: ");
    & W8 R7 ?* R2 G4 v# |& L2 n
69.                 fputs(buf, stdout);//打印接收到的数据
    
70.         }
    * u7 R  |. D3 ~
71.         close(sockfd);//关闭套接字
    ) r! y5 a4 j9 y) K0 |& g, P1 j; D
72.         close(connfd);//断开连接
    
73.         return 0;
    ( @5 i, H+ x. h- Z
74. }

复制代码

& h$ F9 e# X( D+ S- g5 k& f

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   
2. #include <stdio.h>
   + S, k& A- e6 c- C" y& C0 f
3. #include <string.h>
   4 Z# f: w3 P, u2 H/ H; q
4. #include <stdlib.h>
   
5. #include <strings.h>
   5 I1 Q4 f3 \, Y0 B! p/ i  d
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   2 W3 {% v/ t$ f& _8 F( s1 D
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   , ~/ @" o8 I: Y; F+ K  \+ O; \
10. int main()
    
11. {
    2 D1 ]9 D; C; O! o. R
12. int sockfd;
    
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    ) k: G1 ]7 _' R7 d% r6 F! j
14.         {
    1 Q0 ^0 _. e% f  P* g
15.                 perror("socket");
    
16.                 return -1;
    
17.         }
    ) i; ]- k1 d1 Z# s- _& ]
18.         printf("socket...........
    
19. ");
    
20.         
    
21.         struct sockaddr_in srv_addr;
    9 B5 w0 T" J7 u$ R6 G+ a( i. N
22.         memset(&srv_addr, 0, sizeof(srv_addr));
    
23.         srv_addr.sin_family                 = AF_INET;
    
24.         srv_addr.sin_port                         = htons(8888);
    
25.         srv_addr.sin_addr.s_addr         = inet_addr("192.168.3.169");
    ' p6 }( E4 B6 E( `* C
26.         if (0 > connect(sockfd, (struct sockaddr*)&srv_addr, sizeof(srv_addr)))
    1 p# @7 [5 h, E9 a- x, S/ j5 s% G
27.         {
    # A2 ~2 m+ v3 X. }- t8 G: y- m
28.                 perror("connect");
    
29.                 return -1; //exit //pthread_exit
    # Q9 C3 M6 n) J
30.         }
    
31.         printf("connect..............
    
32. ");
    
33.         char buf[100];
    
34.         int ret;
    7 }( S7 ]! N$ U- X8 E3 \
35.         while (1)
    
36.         {
    % Y. L6 q1 Z4 e6 g" B4 L
37.                 printf("send: ");
    5 D7 n. l  @! p
38.                 fgets(buf, sizeof(buf), stdin);
    , S% A# B# T8 R
39.                 ret = write(sockfd, buf, sizeof(buf));
    4 x3 `  k7 Z( {2 B2 {
40.                 if (ret < 0)
    , _) H: E0 f9 N
41.                 {
    
42.                         perror("write");
    & H$ k# R$ {/ s+ l
43.                         break;
    
44.                 }
    
45.                 if (strncmp(buf, "quit", 4) == 0)
    
46.                         break;
    " }1 V% X0 k* M* `+ z5 s; |
47.         }
    
48.         close(sockfd);
    
49.         return 0;
    ( m8 d1 f- w! m6 @8 z# l! x
50. }

复制代码