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

admin

如果想要自己写一个服务器和客户端，我们需要掌握一定的网络编程技术，个人认为，网络编程中最关键的就是这个东西——socket（套接字）。
+ H# C( Q4 F5 ]

socket（套接字）：简单来讲，socket就是用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。


TCP协议
) j! t! V1 K3 r  p% H  M1 O4 PTCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。

+ N) e% h4 R5 a% x+ W0 `2 X
( X+ y6 x3 k, L关键词：三次握手，可靠，基于字节流。
. q! h4 a) a0 X4 j
3 H2 M5 ~6 D3 x/ e: `
可能有朋友会问，TCP就这么简单一句话吗？当然不是，TCP作为非常重要的传输协议，细节知识是很多的，细讲起来这一篇文章怕是不够。不过在本篇内容中，我们只需了解他的几个关键词特性，就能很好的理解下面的内容。
3 v+ y  R8 H/ i8 x1 q' t
TCP服务器端和客户端的运行流程

: r& @/ t8 ~* M& {8 k
# J* ^2 j+ f, A7 x0 d( Y如图，这是一个完整的TCP服务器——客户端的运行流程图，其实我个人认为程序啊，不管哪个语言都是一样，核心就在于算法的设计和函数的调用。那么图中的函数都是什么意思呢？
3 X: v9 \$ D# Z: o6 C
( A% m( X! Q+ V5 F
& E. k7 I/ p& U2 l6 A* A" n1.创建socket
- P9 m; o( p7 \% u& P socket是一个结构体，被创建在内核中
+ n6 T# B$ b9 ^2 H sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议


2.调用bind函数
" V$ j% O8 J" N+ A& `* i 将socket和地址（包括ip、port）绑定。
需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
struct sockaddr_in myaddr; //地址结构体
3 A6 {+ G* ^7 _ bind函数
bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))

2 [5 `8 }" W5 j' c
) a& g7 u5 O0 k* ]) u  G) \3.listen监听，将接收到的客户端连接放入队列
$ S* A; J$ o5 E4 x* k listen(sockfd,8) //第二个参数是队列长度
8 L1 z: E; e) E9 a
" z1 U& Q8 `/ k  {% z3 i9 J4 r
, x3 p% _. j0 R! f4 k6 g4.调用accept函数，从队列获取请求，返回socket描 述符
  如果无请求，将会阻塞，直到获得连接
  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数


4 h7 K& [* R  u& H5.调用read/write进行双向通信

! `4 l. W4 C0 |
- E0 u- p; @% m9 ]5 r6.关闭accept返回的socket
5 T# d( q) U7 F  close(scokfd);
- \' t- o1 P8 w


5 E6 o+ d, G3 B. ^2 g$ a
- p8 j' s2 ^+ S+ }6 v下面放出完整代码

. Y$ Q2 ~: H6 u% L& H

1. /*服务器*/
   : `: T" U! ]/ _
2. #include <stdio.h>
   7 n( X% E  @) l4 q) L
3. #include <string.h>
   $ q, f4 t2 B7 o- t4 z- a
4. #include <stdlib.h>
   6 j- Y+ i! i0 I6 g* c
5. #include <strings.h>
   
6. #include <sys/types.h>
   2 c! ~( l/ I$ J6 E& I3 X! P9 c
7. #include <sys/socket.h>
   - R' a2 f/ E. k" Z- B4 \! M0 W3 }
8. #include <arpa/inet.h>
   
9. #include <netinet/in.h>
   
10. int main()
    ( P6 X+ W2 @, v# g+ S6 V
11. {
    
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    * F: o3 @, ]- ~* m
13.         if (sockfd < 0)
    # @' X( L9 \2 _* ]" o4 v5 c, ^( Z
14.         {
    # ~/ |# t2 q# A7 X" E' ?7 R3 e
15.                 perror("socket");
    
16.                 return -1;
    
17.         } //创建失败的错误处理
    3 |* \$ p* I! W5 q& `" B% t
18.          printf("socket..............
    
19. "); //成功则打印“socket。。。。”
    
20.          
    * k1 _# \8 u! o# n! Z2 v  i
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    - f3 |! m& J3 S% L  ]
23.          myaddr.sin_family                 = AF_INET; //选择IPV4地址类型
    ' F" Y& w$ Y/ s7 \) O3 h$ s8 v
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)))//绑定套接字
    ( r( C% N" y( `! s& }0 X
28.          {
    
29.                  perror("bind");
    
30.                  return -1;
    8 g! J) ]! t" U; v6 T" p. _+ E
31.          }
    . R# c3 }. N' ?, v
32.          printf("bind..........
    
33. ");
    / c0 [) l# F% F
34. 
    
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    ) u$ `: L5 w" u8 z
36.          {
    
37.                  perror("listen");
    
38.                  return -1;
    
39.          }
    
40.          printf("listen............
    - S8 A* Z4 ^. @8 d
41. ");
    4 s2 l% S3 R8 A! o/ r6 k) z: L0 v( p  B
42.          
    / b- _( r  @: T3 J4 `( W
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
    0 K% d- `' f: v2 g. r* t" [
44.         if (connfd < 0)
    
45.         {
    
46.                 perror("accept");
    
47.                 return -1;
    # w7 f+ F5 R) o! F
48.         }
    
49.         printf("accept..............
    " U- x" V; N7 c$ G. ^
50. ");
    
51.         char buf[100];//定义一个数组用来存储接收到的数据
    
52.         int ret;
    & \/ G$ [$ X* q3 e: H# o& r
53.         while (1)
    
54.         {
    
55.                 memset(buf, 0, sizeof(buf));
    
56.                 ret = read(connfd, buf, sizeof(buf));
    7 n% \! B# N) O/ R4 n" @0 X4 C
57.                 if (0 > ret)
    & }# ?; H$ I+ D9 _# P
58.                 {
    8 b/ p9 E* v2 p; y0 C6 d; W
59.                         perror("read");
    + j5 v& O& O- {" A) c
60.                         break;
    " B7 J/ Y) R' @
61.                 }//执行while循环读取数据，当
    
62.                 else if (0 == ret)
    + }1 x# j: `" X0 R. I
63.                 {
    
64.                         printf("write close!
    5 U8 d. p2 u* B& y- v; {
65. ");
    5 a2 W6 h0 K. S. N
66.                         break;
    : N. b; [! c1 _; }2 o# z& A
67.                 }
    
68.                 printf("recv: ");
    
69.                 fputs(buf, stdout);//打印接收到的数据
    ! _0 S! Z. }$ I% ]- v. K# L
70.         }
    
71.         close(sockfd);//关闭套接字
    
72.         close(connfd);//断开连接
    ; c! N, a+ p% y2 A5 y
73.         return 0;
    , d; u' |5 R6 @) ]: g2 u/ \3 d
74. }

复制代码

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   / p+ C4 ]) x" u" B5 e) T# Q
2. #include <stdio.h>
   " C4 l2 @! S  `: q1 b, Q
3. #include <string.h>
   : |2 A* W* @; B* p
4. #include <stdlib.h>
   
5. #include <strings.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   $ _3 d. Q: b! W
9. #include <arpa/inet.h>
   2 D( m6 ^' v1 C, i4 i& h
10. int main()
    5 x5 l  s, z. Q. A+ b( }
11. {
    
12. int sockfd;
    : `# Q& a4 k9 n+ y: y: w; Y
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    
14.         {
    
15.                 perror("socket");
      N: b+ F1 {8 T1 e% y% T! Y
16.                 return -1;
    
17.         }
    3 a) |6 ^3 c* l3 _, M0 @/ ~
18.         printf("socket...........
    
19. ");
      D& ?/ u, f' z$ }/ K& U& v
20.         
    + C1 o7 ~. j+ w8 W
21.         struct sockaddr_in srv_addr;
    & A: d) W1 `+ P" M6 y0 }8 K
22.         memset(&srv_addr, 0, sizeof(srv_addr));
    2 h/ G. ]+ Q! l9 g
23.         srv_addr.sin_family                 = AF_INET;
    
24.         srv_addr.sin_port                         = htons(8888);
    2 E. T, r1 K3 }+ s
25.         srv_addr.sin_addr.s_addr         = inet_addr("192.168.3.169");
    3 U8 I3 o+ S8 M$ `
26.         if (0 > connect(sockfd, (struct sockaddr*)&srv_addr, sizeof(srv_addr)))
    
27.         {
    
28.                 perror("connect");
    
29.                 return -1; //exit //pthread_exit
    
30.         }
    
31.         printf("connect..............
    
32. ");
    
33.         char buf[100];
    
34.         int ret;
    
35.         while (1)
    
36.         {
    
37.                 printf("send: ");
    
38.                 fgets(buf, sizeof(buf), stdin);
    
39.                 ret = write(sockfd, buf, sizeof(buf));
    
40.                 if (ret < 0)
    
41.                 {
    
42.                         perror("write");
    - f; m" U8 U" O5 O0 P9 H
43.                         break;
    # {& P' Q- _9 D; y* q
44.                 }
    # b9 [# j3 b, j$ N
45.                 if (strncmp(buf, "quit", 4) == 0)
    * A1 @& L9 g% A! x2 r$ E
46.                         break;
    ( O- D7 {" e# p1 ]- L  c
47.         }
    / p. l# a; R$ O+ F( C/ d
48.         close(sockfd);
    5 P) J* P# z" m" q6 T! C7 ?+ b
49.         return 0;
    0 Q6 x7 s4 S/ |4 y, u, [% j0 z
50. }

复制代码

7 r  v- I' \, d# S, T+ \6 W