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

admin

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

7 y6 V# f6 H/ ?; ^  ^% R0 D
socket（套接字）：简单来讲，socket就是用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。
, K1 o) z+ e% k' U3 k  q0 \

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

+ \6 P: f5 E+ _/ _2 W9 t
关键词：三次握手，可靠，基于字节流。
: F- l6 F3 v( o# J2 N

/ a6 a) ~0 G. S6 L) m. b; {可能有朋友会问，TCP就这么简单一句话吗？当然不是，TCP作为非常重要的传输协议，细节知识是很多的，细讲起来这一篇文章怕是不够。不过在本篇内容中，我们只需了解他的几个关键词特性，就能很好的理解下面的内容。
/ f: |) B* e4 {  T3 h+ ~  w
+ {# x8 b/ K9 GTCP服务器端和客户端的运行流程


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

  b1 z6 d+ p$ Z% ^4 L+ ]$ U
1.创建socket
socket是一个结构体，被创建在内核中
2 \4 |. z; \7 I+ Q sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议
7 q% X4 u; ^* I* _
; x4 b. s2 X1 j% s) A
; Z9 v' z# [4 y" u; w4 q2.调用bind函数
- x, Z# C" y; o8 K0 P+ U 将socket和地址（包括ip、port）绑定。
$ Z& t# C6 b; K, s, \ 需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
8 i9 {% `- b4 S# [: C: f  Z- r struct sockaddr_in myaddr; //地址结构体
bind函数
2 q7 D/ _* Q/ q  C bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))


1 x) a& I9 x  G' M- Z3 w" Y3.listen监听，将接收到的客户端连接放入队列
listen(sockfd,8) //第二个参数是队列长度

4 R2 o1 B7 D9 G" q2 t: S6 M
4.调用accept函数，从队列获取请求，返回socket描 述符
9 f/ {0 o$ L- M  如果无请求，将会阻塞，直到获得连接
  K' @7 o- m' k) e8 y  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数

# X2 i; ~  O% k8 G0 i, j: G
5.调用read/write进行双向通信
) o+ Z4 Y! k% R( `+ t& d2 y
7 v* `; W  }& |" z5 s
6.关闭accept返回的socket
. ~5 D, ^: G$ n  `- W  close(scokfd);
: j& T/ H6 W5 p( r; q  p
. [% g6 `. ~. K1 ?$ r% h8 U0 ^


5 W& S4 R9 W/ y$ j: G8 b, o$ p9 F下面放出完整代码
* M; U. n3 V; }8 s: F5 L: l
3 E; ]1 G# b! @0 M- N

1. /*服务器*/
   ) {) U6 G% D# f, @- P1 ~1 l
2. #include <stdio.h>
   4 a$ M! t$ w# D6 J! V2 U% O
3. #include <string.h>
   . T3 c1 |3 [( p$ d
4. #include <stdlib.h>
   , |: D8 k0 n1 N$ j" H% f6 o% ~9 O
5. #include <strings.h>
   / `% t: l5 i4 R7 v, c2 m
6. #include <sys/types.h>
   9 b0 Q' G) y: h; ?5 X
7. #include <sys/socket.h>
   
8. #include <arpa/inet.h>
   + K" G& I  _9 p0 \7 p$ X" g# {1 b
9. #include <netinet/in.h>
   
10. int main()
    
11. {
    
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    ) e2 ^# o# ?. f0 J! U
13.         if (sockfd < 0)
    
14.         {
    2 m; m# W' j: G# P1 p6 C) ^. V
15.                 perror("socket");
    1 ~) T$ `* C: d0 E% [! m
16.                 return -1;
    / }( V4 [& r7 S: U; S9 c
17.         } //创建失败的错误处理
    ' j- o9 r: m, ~3 v7 v
18.          printf("socket..............
    9 T4 u7 y) c9 r  n3 U  V
19. "); //成功则打印“socket。。。。”
      E1 D  ]" Z6 [# ?8 F& a* e6 a
20.          
    % W0 T5 A, {3 x% a8 q& O# {9 X
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    5 v( a$ H# E* H* d! @" h6 g! N& U
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    & D' B/ K4 y- o  A/ _7 \$ r
23.          myaddr.sin_family                 = AF_INET; //选择IPV4地址类型
    
24.          myaddr.sin_port                 = htons(8888); //选择端口号
    ' J$ d5 o  A8 d9 E
25.          myaddr.sin_addr.s_addr         = inet_addr("192.168.3.169"); //选择IP地址
    6 S( Q5 X/ l  v: A
26. 
    ! I* W& }" J4 K% I* O, U
27. if (0 > bind(sockfd, (struct sockaddr*)&myaddr, sizeof(myaddr)))//绑定套接字
    ' A4 U* v( @- P0 A% n0 {& I
28.          {
    
29.                  perror("bind");
    " a1 m, Y: E: i+ ^6 ^1 Z0 N! ~# a' k
30.                  return -1;
    
31.          }
    
32.          printf("bind..........
    " ^8 S! [# k9 a  f8 p1 x
33. ");
    7 K4 u) r- W! C  s( k2 s
34. 
    
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    
36.          {
    
37.                  perror("listen");
    3 {+ T7 w1 h2 ~4 j  c4 [, z
38.                  return -1;
    ( D3 x+ T% Y0 G2 A  e$ L# V6 u
39.          }
    
40.          printf("listen............
    
41. ");
    + Z4 u1 z. G8 Z: c" ]1 `- q) {5 a0 c
42.          
    
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
    - N- n, Q# u: n! @8 J
44.         if (connfd < 0)
    
45.         {
    # O0 @4 J7 J3 Q. V6 B; E
46.                 perror("accept");
    1 D) e+ B% |  M  }% k( W! L% d+ y8 @
47.                 return -1;
    0 @. T/ o1 |1 ?3 O3 A2 q
48.         }
    
49.         printf("accept..............
    : P. z+ V) z& a! s9 Y
50. ");
    
51.         char buf[100];//定义一个数组用来存储接收到的数据
    & o( d* t# }0 G. W4 o  [, y
52.         int ret;
    
53.         while (1)
    
54.         {
    ! [) j; N4 S5 y! M0 l) f3 j
55.                 memset(buf, 0, sizeof(buf));
    / @3 N$ l2 H# B. {. ?! m% x8 `; K+ D
56.                 ret = read(connfd, buf, sizeof(buf));
      i3 n0 b: r! C7 @
57.                 if (0 > ret)
    8 k7 b. h; h8 P# f
58.                 {
    
59.                         perror("read");
    
60.                         break;
    " ^' i/ y5 `* J8 x1 u
61.                 }//执行while循环读取数据，当
    / \' ~) @  H4 ~4 `( c# V4 J
62.                 else if (0 == ret)
    
63.                 {
    . I' u$ ]+ e2 x6 Y4 g+ L' R
64.                         printf("write close!
    # I: W# T0 c/ h1 X' q4 x: w' y
65. ");
    . R$ h% u, _$ ^& i- s: @, z
66.                         break;
    
67.                 }
    
68.                 printf("recv: ");
    . Y) |+ H+ I0 e0 }8 P5 h
69.                 fputs(buf, stdout);//打印接收到的数据
    
70.         }
    & `8 J- m, c- l4 v+ l' e
71.         close(sockfd);//关闭套接字
    
72.         close(connfd);//断开连接
    ) s% |& l: F( u0 b
73.         return 0;
    " z6 g, O( j2 B4 t
74. }

复制代码

: [! a* Q) J3 m$ S* a! `" @7 W

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   
2. #include <stdio.h>
   0 A) }8 l- i& a
3. #include <string.h>
   
4. #include <stdlib.h>
   
5. #include <strings.h>
   $ e/ o. F* m& l) i" n& f1 {
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   $ y( O* v4 D6 k! _8 h, m5 v
9. #include <arpa/inet.h>
   
10. int main()
    6 P' W* N+ d1 V  r, R' Z7 Y% @5 O
11. {
    $ E& {2 w  f) i& c+ A7 J
12. int sockfd;
    
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    
14.         {
    7 k; ?  h, J; e& y) B5 E$ J
15.                 perror("socket");
    
16.                 return -1;
    
17.         }
    
18.         printf("socket...........
    
19. ");
    
20.         
    5 @' @; v6 [" p+ M3 O7 k
21.         struct sockaddr_in srv_addr;
    $ K# _% l# c5 N7 Y  R  c
22.         memset(&srv_addr, 0, sizeof(srv_addr));
    
23.         srv_addr.sin_family                 = AF_INET;
    + M9 ~# p# R% ], _2 \. S  N3 M) g
24.         srv_addr.sin_port                         = htons(8888);
    ) m1 z* D  E' h9 O
25.         srv_addr.sin_addr.s_addr         = inet_addr("192.168.3.169");
    ( \2 A, G3 P5 l
26.         if (0 > connect(sockfd, (struct sockaddr*)&srv_addr, sizeof(srv_addr)))
    , K! W% ?8 A! x5 F4 s2 @0 l
27.         {
    
28.                 perror("connect");
    
29.                 return -1; //exit //pthread_exit
    4 m/ U, f2 n- V3 v. m) O
30.         }
    $ D* H- s5 ~" F2 F6 c
31.         printf("connect..............
    
32. ");
    7 k) u% A! q' p; B$ Y7 y
33.         char buf[100];
    
34.         int ret;
    
35.         while (1)
    
36.         {
    
37.                 printf("send: ");
    
38.                 fgets(buf, sizeof(buf), stdin);
    1 ?4 z  B8 u7 D) b( v1 N
39.                 ret = write(sockfd, buf, sizeof(buf));
    6 O' U. b7 n9 I  ~3 h; R
40.                 if (ret < 0)
    
41.                 {
    
42.                         perror("write");
    
43.                         break;
    
44.                 }
    
45.                 if (strncmp(buf, "quit", 4) == 0)
    
46.                         break;
    5 E# V9 Y4 z. K  _& t
47.         }
    3 x  {; }2 {) ]# p0 e" i
48.         close(sockfd);
      h  |& m6 b+ M/ u+ M3 E+ Y
49.         return 0;
    ( a5 Z, j6 V+ F) |! P4 ]! {8 j& p
50. }

复制代码

0 ]. g) {1 T3 n- e