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

admin

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


socket（套接字）：简单来讲，socket就是用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。
) H8 ]5 e. J7 f/ o; b( W

TCP协议
TCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。
% S1 ]6 M0 r1 O5 p

4 ~% j1 z- C. i7 J2 Y关键词：三次握手，可靠，基于字节流。


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

% ~, W+ k  }/ I6 A7 ITCP服务器端和客户端的运行流程


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

4 O: m: l4 a! l) B4 B* n% o1.创建socket
socket是一个结构体，被创建在内核中
! A, C4 }3 \" L/ ^7 E sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议
/ G3 @' G6 `# R  E

1 D: r6 l0 w  j! v( E" E9 x2.调用bind函数
4 F% k' s4 g' ^  C. P& z 将socket和地址（包括ip、port）绑定。
需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
struct sockaddr_in myaddr; //地址结构体
+ t: ]8 z6 w' ~. G' G3 w, l4 L% m' O bind函数
bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))


3.listen监听，将接收到的客户端连接放入队列
7 A0 C' B' m! e0 I& v, D$ g listen(sockfd,8) //第二个参数是队列长度

, F! R2 M1 p7 a8 Q8 J2 I
, ~7 |  R4 {9 n- y- {4 ]1 N4.调用accept函数，从队列获取请求，返回socket描 述符
4 d' H# T& t6 W: I% N' y. |  如果无请求，将会阻塞，直到获得连接
+ b4 B% P, u2 V* G; S) h% N' k  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数
( a: B% D4 o9 T  B

5.调用read/write进行双向通信
$ l' _1 q. M- X3 J

6.关闭accept返回的socket
' g/ G( \. t4 R+ e  close(scokfd);
8 ~. O4 g- {9 M' q$ M9 [1 {

$ p. U; r$ G: P( R8 R

, x- Z# s; t% Q  v下面放出完整代码

1. /*服务器*/
   * L/ m* K, x, F' Y, o
2. #include <stdio.h>
   & o+ h3 \9 O, F- T
3. #include <string.h>
   5 w: Y6 d# x7 j2 ]" C
4. #include <stdlib.h>
   
5. #include <strings.h>
   
6. #include <sys/types.h>
   . Z- N' k3 \" Y+ M2 ?5 N9 C
7. #include <sys/socket.h>
   ' Y% K. i0 @; Y5 a& P0 u3 u0 v; |$ _
8. #include <arpa/inet.h>
   0 o) J' Q5 W+ B* Z8 G% P
9. #include <netinet/in.h>
   
10. int main()
    
11. {
    : H* z; k. Y; I/ T
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    3 P( ^" x7 |# X: L0 h2 n" G; x+ R0 ~
13.         if (sockfd < 0)
    
14.         {
    
15.                 perror("socket");
    ; I0 G: z8 E+ k! {( i- S8 U
16.                 return -1;
    
17.         } //创建失败的错误处理
    
18.          printf("socket..............
    
19. "); //成功则打印“socket。。。。”
    7 F" O7 a8 ]0 a$ E
20.          
    / m# @0 H! p9 L' \# o& Q; x
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    4 ^+ W3 y; Z6 g
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    - X) A* b% }+ ]$ T: r
23.          myaddr.sin_family                 = AF_INET; //选择IPV4地址类型
    
24.          myaddr.sin_port                 = htons(8888); //选择端口号
    ( ^8 R  Z- u. ~) F- `- l
25.          myaddr.sin_addr.s_addr         = inet_addr("192.168.3.169"); //选择IP地址
    
26. 
    
27. if (0 > bind(sockfd, (struct sockaddr*)&myaddr, sizeof(myaddr)))//绑定套接字
      q0 R# R6 `8 H) D3 B0 `
28.          {
    0 q; e" G6 H5 g. H( x4 @
29.                  perror("bind");
    8 {$ u) p1 s5 |+ c- S
30.                  return -1;
    
31.          }
    . z" W5 {2 K( }. G* s+ {% r" ]$ A
32.          printf("bind..........
    ) s  F' y% h! ?0 A1 u1 L' ]  `3 w
33. ");
    
34. 
    8 Z' U9 j2 ~' [( Y( ^; S$ a
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    5 V: V# h, V" U! r. v: M7 P( M
36.          {
    
37.                  perror("listen");
    0 k8 x; \( D. d- H. H0 J7 _5 K% K* O
38.                  return -1;
    / \% n: r" @* i  ?( w! p- \
39.          }
    ; C* t' J) J3 @6 J9 W  O7 Q8 \# X  l
40.          printf("listen............
    
41. ");
    
42.          
    
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
    
44.         if (connfd < 0)
    
45.         {
    9 N, l# W9 d# ~
46.                 perror("accept");
    ) q0 U1 x" v' V6 V# {& D# p6 J
47.                 return -1;
    : v6 i  [7 F; G" e6 ]
48.         }
    0 e, |- i% x1 D/ E! M
49.         printf("accept..............
    3 T9 D& j2 K, r
50. ");
    
51.         char buf[100];//定义一个数组用来存储接收到的数据
    
52.         int ret;
    
53.         while (1)
    
54.         {
    
55.                 memset(buf, 0, sizeof(buf));
    
56.                 ret = read(connfd, buf, sizeof(buf));
    2 U" D: q3 Z( [# W
57.                 if (0 > ret)
      O! _0 B& V7 i0 e
58.                 {
    , @" x0 C  E  `0 _; _& }  {+ l
59.                         perror("read");
    
60.                         break;
    
61.                 }//执行while循环读取数据，当
    
62.                 else if (0 == ret)
    4 @) j4 i& |5 b: k3 T5 d
63.                 {
    7 W: l6 s" l: }
64.                         printf("write close!
    3 X2 j# ^" i3 y7 k
65. ");
    
66.                         break;
    2 G9 O( x; N1 I0 a3 ^/ }
67.                 }
    / A! M7 L5 h/ T% m3 r# s) I; @& B
68.                 printf("recv: ");
    
69.                 fputs(buf, stdout);//打印接收到的数据
    
70.         }
    
71.         close(sockfd);//关闭套接字
    
72.         close(connfd);//断开连接
    $ v) r; e0 s: `1 F
73.         return 0;
    
74. }

复制代码

2 y" `: I6 W# a* `! H
/ w+ y- C. M( n- i% C0 k

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   5 n: c6 G* j2 @, ?' K# f( t
2. #include <stdio.h>
   
3. #include <string.h>
   : U. K9 r& O- f
4. #include <stdlib.h>
   
5. #include <strings.h>
   # i5 `( S5 O% \4 i+ R
6. #include <sys/types.h>
   8 o6 H" a* h" E: t* ]1 O
7. #include <sys/socket.h>
   9 x, t2 k" X1 k9 J4 \& |
8. #include <netinet/in.h>
   + I$ w. y* Q" K) E5 w+ m
9. #include <arpa/inet.h>
   6 M; v8 @% u$ S
10. int main()
    
11. {
    
12. int sockfd;
    % e$ n. @& U( L+ w1 [' L$ m  w
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    - v1 L* I% m6 x9 b' H" s0 U
14.         {
    ' R5 E. M: \! s* _  K9 R
15.                 perror("socket");
    
16.                 return -1;
    ) M9 }9 o: b9 ^; j& y8 ]
17.         }
    5 @  l1 _( Y$ F& ?) b9 l
18.         printf("socket...........
    7 x, h. h" v" \' h6 i2 j; l
19. ");
    
20.         
    % z' E+ a# ^, e" l# x
21.         struct sockaddr_in srv_addr;
    
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");
    7 |/ ~# L0 _2 x, |
26.         if (0 > connect(sockfd, (struct sockaddr*)&srv_addr, sizeof(srv_addr)))
    8 J# D8 E2 ~- Z% b- h0 k
27.         {
    ( |3 S: U( V' Z$ |5 [, r: n
28.                 perror("connect");
    0 G! C& N: P# y$ R3 C
29.                 return -1; //exit //pthread_exit
    
30.         }
    3 v" s* Z" f* ^  \" d
31.         printf("connect..............
    0 Q: W1 h# M+ ]+ g) i6 G
32. ");
    
33.         char buf[100];
    
34.         int ret;
    
35.         while (1)
    ! E& z; e1 G8 Q/ Z8 Y0 q" x6 i
36.         {
    + C8 k2 q0 @& Q- y) c/ L
37.                 printf("send: ");
    " M+ \: O; ^1 D: N
38.                 fgets(buf, sizeof(buf), stdin);
    6 |9 p6 V5 Y2 x# b2 E3 U) Y
39.                 ret = write(sockfd, buf, sizeof(buf));
    
40.                 if (ret < 0)
    
41.                 {
    3 ?1 \5 I+ f1 B6 r! L
42.                         perror("write");
    8 M/ H  |% K; E
43.                         break;
    
44.                 }
    
45.                 if (strncmp(buf, "quit", 4) == 0)
    
46.                         break;
    
47.         }
    , \- U& e4 B- I: I( O. v2 I) w
48.         close(sockfd);
    
49.         return 0;
    
50. }

复制代码

( o7 \! a) s% C4 Q# m