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

admin

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


% V- U3 F, Y  F0 w9 |' s- Lsocket（套接字）：简单来讲，socket就是用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。
9 Z0 r/ u  }$ g; g+ n6 Z
$ @2 P$ ]! \$ V. H$ W# T
TCP协议
7 J! E) f+ ?) c) E( V5 wTCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。

7 h  Q) a1 f$ E% U, i4 U+ R
; R; c6 x5 j6 h5 Z4 @关键词：三次握手，可靠，基于字节流。

2 ^+ w1 g" }8 Q3 H
: J' _$ Q/ f$ S' q  C  O可能有朋友会问，TCP就这么简单一句话吗？当然不是，TCP作为非常重要的传输协议，细节知识是很多的，细讲起来这一篇文章怕是不够。不过在本篇内容中，我们只需了解他的几个关键词特性，就能很好的理解下面的内容。
$ j* G3 V! o6 w+ ], y( \6 Y! i
TCP服务器端和客户端的运行流程
; c, x& b) C9 d; }) Q  I
" w. x  e6 x4 q9 ~9 _9 J# @
如图，这是一个完整的TCP服务器——客户端的运行流程图，其实我个人认为程序啊，不管哪个语言都是一样，核心就在于算法的设计和函数的调用。那么图中的函数都是什么意思呢？
; ]: }) g) y( G9 d$ t. w& ^6 Q
5 l; }  K% X9 N( R
1.创建socket
socket是一个结构体，被创建在内核中
sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议

' ?( a$ y5 J7 J% m' O' W' N
2.调用bind函数
/ A; ]1 t) }5 p/ L 将socket和地址（包括ip、port）绑定。
; r" @( L2 b4 M" o0 |  O5 z 需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
struct sockaddr_in myaddr; //地址结构体
5 H! j; g  I2 E. ~% q% V) e( q bind函数
bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))

; M7 T# W8 u9 H2 r0 R. e
3 y- D  Z: W/ }' e& l/ F3.listen监听，将接收到的客户端连接放入队列
) H. L' C' ?( g! u8 `* @- r7 I2 k listen(sockfd,8) //第二个参数是队列长度
8 s/ \" g9 p8 i+ x% u. O

4.调用accept函数，从队列获取请求，返回socket描 述符
9 h1 ~& V. A4 H1 p3 a  如果无请求，将会阻塞，直到获得连接
8 t* e& i3 h7 d9 ]% V; f  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数
4 s6 Q# e# X( M" n4 H( c; H
. F/ k1 v7 I( L- N" n0 K7 X
5.调用read/write进行双向通信
) S+ c" B# c; j, s* h! w

- g2 }' e# M- h8 H1 N% t$ X: N6.关闭accept返回的socket
  close(scokfd);
: y% \$ i1 c+ @8 U: V1 e- g( q



下面放出完整代码

1. /*服务器*/
   7 p: t8 o, I5 Z2 Z2 w: a3 n
2. #include <stdio.h>
   6 i) B. F+ {$ p% e2 c
3. #include <string.h>
   
4. #include <stdlib.h>
   / T9 N; g3 ~$ B) D1 P: _8 \
5. #include <strings.h>
   8 x0 k, J: B( b0 _; l. _: t% K
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. #include <arpa/inet.h>
   
9. #include <netinet/in.h>
   0 Z9 M2 A, n8 r& \9 w- Z! P9 y+ j8 @6 ^
10. int main()
    
11. {
    
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    / I% V" j0 F7 e% ^
13.         if (sockfd < 0)
    5 d5 K; i$ T7 n3 L. b. [( Z
14.         {
    $ |0 w1 l, j0 h% W; H; y
15.                 perror("socket");
    . J% m( o# j% z3 r: c1 ^. T
16.                 return -1;
    6 s  s" t5 b" z1 l( g% |# X6 [) L# T
17.         } //创建失败的错误处理
    $ ^; Y! r) |$ l: V  `
18.          printf("socket..............
    # ]5 b2 s1 q1 U; ]7 F1 o
19. "); //成功则打印“socket。。。。”
    # M5 w7 d! L1 T* g  t: u
20.          
    
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    8 u& ^  `" g' K" t9 U- A8 J
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    
23.          myaddr.sin_family                 = AF_INET; //选择IPV4地址类型
    ( u% x% d9 g/ Y( O9 y
24.          myaddr.sin_port                 = htons(8888); //选择端口号
    % T- C9 A2 d8 B8 d9 {0 B
25.          myaddr.sin_addr.s_addr         = inet_addr("192.168.3.169"); //选择IP地址
    
26. 
    
27. if (0 > bind(sockfd, (struct sockaddr*)&myaddr, sizeof(myaddr)))//绑定套接字
    3 X  A3 f9 M, U# n5 ^' U: G
28.          {
    
29.                  perror("bind");
    8 @4 h8 d/ m5 J& k, h! W& ]
30.                  return -1;
    
31.          }
    
32.          printf("bind..........
    
33. ");
    " s2 H; [  X$ I
34. 
    
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    - Q# c& A1 r# v3 `: U
36.          {
    
37.                  perror("listen");
    8 J1 N6 Z4 h, l+ A
38.                  return -1;
    4 b, A, M5 V  C' q" ?
39.          }
    + Z# y( d! d3 n6 f* {- g* p
40.          printf("listen............
    ( j9 [5 S  t9 t, _  J, q
41. ");
    
42.          
    & ]1 O! b. y- i
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
      ]- z/ n* b. i2 a# i' f: B
44.         if (connfd < 0)
    
45.         {
    / z; d  b1 U9 m9 b4 C
46.                 perror("accept");
    
47.                 return -1;
    
48.         }
    
49.         printf("accept..............
    
50. ");
    
51.         char buf[100];//定义一个数组用来存储接收到的数据
    ) x4 w$ D" S$ B
52.         int ret;
    4 o9 ^8 z2 q3 M  V5 s
53.         while (1)
    . K3 I0 N6 b' i( U4 z- ?' ^
54.         {
    
55.                 memset(buf, 0, sizeof(buf));
    1 S# b  c* A2 x
56.                 ret = read(connfd, buf, sizeof(buf));
    
57.                 if (0 > ret)
    
58.                 {
    & |- W1 V& r# n, H
59.                         perror("read");
    
60.                         break;
    
61.                 }//执行while循环读取数据，当
      y* o' k6 V/ u$ J
62.                 else if (0 == ret)
    , m% c+ R2 C; Z: ^- x* [$ v" c4 t
63.                 {
    
64.                         printf("write close!
    1 b5 @( B, Q5 I- v1 p& H
65. ");
    
66.                         break;
    
67.                 }
    
68.                 printf("recv: ");
    
69.                 fputs(buf, stdout);//打印接收到的数据
    
70.         }
    
71.         close(sockfd);//关闭套接字
    
72.         close(connfd);//断开连接
    
73.         return 0;
    % {0 m% j1 [% c& H
74. }

复制代码

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   / B. ]8 Q7 }4 A4 ]
2. #include <stdio.h>
   + G4 c4 p6 a7 E
3. #include <string.h>
   ' p. }; J, j* ]; ]/ j+ H. N9 p
4. #include <stdlib.h>
   
5. #include <strings.h>
   9 T; M* I, N& T" ~, a+ \2 O, w
6. #include <sys/types.h>
   9 F9 e) l1 u0 m" E, e1 i
7. #include <sys/socket.h>
   & O6 B% @. I$ C; [! i
8. #include <netinet/in.h>
   5 c% G0 l( y% l, i+ x, S: I- `
9. #include <arpa/inet.h>
   4 L7 g2 O7 U* x/ b6 S+ |
10. int main()
    0 c- f9 |6 B) H" p7 A
11. {
    1 [7 I  q5 [0 n$ V' W  l* z
12. int sockfd;
    
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
      t# ]: u0 i/ `# o: O
14.         {
    
15.                 perror("socket");
    . x/ ~! u$ R1 M- n# D7 s
16.                 return -1;
    " g$ i9 j8 E7 o8 M9 g
17.         }
    5 V+ j) x! r, u1 f. i: n
18.         printf("socket...........
    9 b! i9 B) U" m) N  L; o8 o
19. ");
    + L) m* t' p% x) g# X! t
20.         
    
21.         struct sockaddr_in srv_addr;
    0 B. T' R/ [3 _9 F4 ?
22.         memset(&srv_addr, 0, sizeof(srv_addr));
    ! L2 M# Z; l' j2 i4 L9 v  A, N
23.         srv_addr.sin_family                 = AF_INET;
    . H& F0 M4 R+ e1 [$ m
24.         srv_addr.sin_port                         = htons(8888);
    
25.         srv_addr.sin_addr.s_addr         = inet_addr("192.168.3.169");
    2 u% \' n' f& p. @5 |& Q/ r0 A
26.         if (0 > connect(sockfd, (struct sockaddr*)&srv_addr, sizeof(srv_addr)))
    
27.         {
    . w9 C: V+ D- j8 z
28.                 perror("connect");
    6 c# I6 U1 Q6 |7 h% v
29.                 return -1; //exit //pthread_exit
    . D2 [0 Q: ?7 y0 e
30.         }
    
31.         printf("connect..............
    
32. ");
    2 y' e  {; ?2 J8 N8 s' O$ T% `
33.         char buf[100];
    9 f8 [/ E! u* _$ y: |
34.         int ret;
    * L  N- C0 o. s
35.         while (1)
    * e& u0 Z+ h, E+ V. o9 X) }: p  |
36.         {
    
37.                 printf("send: ");
    
38.                 fgets(buf, sizeof(buf), stdin);
    , B$ g; k' j& I6 v  J( Z
39.                 ret = write(sockfd, buf, sizeof(buf));
    % {. F3 s2 C1 p, k7 [6 }( N
40.                 if (ret < 0)
    
41.                 {
    
42.                         perror("write");
    
43.                         break;
    
44.                 }
    / X2 O  v! o( X+ L# C
45.                 if (strncmp(buf, "quit", 4) == 0)
    0 \3 X" c0 u' r
46.                         break;
    6 u* Y( V& c6 u" k/ h+ }
47.         }
    4 S# t! O) R+ s& k0 b+ u. T1 F
48.         close(sockfd);
    
49.         return 0;
    
50. }

复制代码

" k' {8 P0 Q  a' M
3 n  M- {0 r4 b1 ]+ H: r1 p