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

admin

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

6 u+ K+ B' \+ C3 T# B
socket（套接字）：简单来讲，socket就是用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。
* l$ c0 B* ?+ R, S

* _# \/ y7 F; y6 u. vTCP协议
TCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。
, T# n3 X3 U1 h, V  j+ G$ X

) l- K" z+ ^5 i0 n关键词：三次握手，可靠，基于字节流。
1 a4 A0 ^  ]* }5 p' ]

) T  |5 [! b, R& v5 n可能有朋友会问，TCP就这么简单一句话吗？当然不是，TCP作为非常重要的传输协议，细节知识是很多的，细讲起来这一篇文章怕是不够。不过在本篇内容中，我们只需了解他的几个关键词特性，就能很好的理解下面的内容。
" }0 S9 A1 M' f) j# V9 R0 U* K
8 Z4 v8 o7 T/ k: A/ h) s, ZTCP服务器端和客户端的运行流程

# T2 c, Q4 ^5 J* e# F* U% _
如图，这是一个完整的TCP服务器——客户端的运行流程图，其实我个人认为程序啊，不管哪个语言都是一样，核心就在于算法的设计和函数的调用。那么图中的函数都是什么意思呢？
# z0 M8 @' L$ J, N& G0 R  h% O
8 m' P# k; e# e$ W/ T% f
# h1 a6 `3 _, `- N1.创建socket
1 O7 W/ L- l2 |; @ socket是一个结构体，被创建在内核中
( v; t# X7 s7 o; u6 D sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议

, j+ c+ z& o1 u" n& V* D/ O3 X& j
' e* _/ x& n; T2.调用bind函数
将socket和地址（包括ip、port）绑定。
需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
struct sockaddr_in myaddr; //地址结构体
2 @4 @6 V4 A6 |1 ?8 q4 v bind函数
bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))

0 O5 c5 l0 H# g6 R
3 v! k# C! s$ [- x1 a3.listen监听，将接收到的客户端连接放入队列
0 ~7 ^; m3 J' u0 C: ]6 w: j6 R listen(sockfd,8) //第二个参数是队列长度

" D6 f& M: j2 j/ {$ Q+ L
4.调用accept函数，从队列获取请求，返回socket描 述符
0 {; W" N" w2 P  如果无请求，将会阻塞，直到获得连接
  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数

* M: e* U- C6 U# F& g8 J
5.调用read/write进行双向通信

' D4 O- z# q+ r0 _
6.关闭accept返回的socket
  close(scokfd);
; b; W9 K7 [/ J! v; z" f



$ B  T# k, D& d# g: ]/ g4 a1 E: m% X! e" Y下面放出完整代码

4 p9 b" Q1 j3 d# s2 T$ s) t

1. /*服务器*/
   
2. #include <stdio.h>
   
3. #include <string.h>
   7 M+ Z8 {, j2 G8 m
4. #include <stdlib.h>
   
5. #include <strings.h>
   
6. #include <sys/types.h>
   ; s/ c5 C7 d6 Q. q* ~1 E& A7 z
7. #include <sys/socket.h>
   " G) l  F. r, \" G5 D5 X8 ~
8. #include <arpa/inet.h>
   
9. #include <netinet/in.h>
   . E$ A: }9 P3 c% e
10. int main()
    ) Q1 D, r5 w! C6 f1 B
11. {
    
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    
13.         if (sockfd < 0)
    ! P( _+ ?" M- F( O- Z. v
14.         {
    , b0 e+ k  t" Y* h
15.                 perror("socket");
    
16.                 return -1;
    
17.         } //创建失败的错误处理
    
18.          printf("socket..............
    6 D$ ~1 {: j1 j- _2 z0 H2 }3 [0 r
19. "); //成功则打印“socket。。。。”
    
20.          
    0 B  A* D6 g" c9 r8 r
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    3 m: f- n; b  _1 t7 J# E
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    
23.          myaddr.sin_family                 = AF_INET; //选择IPV4地址类型
    6 X: L: g2 q8 u4 b0 e1 E
24.          myaddr.sin_port                 = htons(8888); //选择端口号
      ^! ]) y0 P0 @4 e4 w& |8 u! c+ h
25.          myaddr.sin_addr.s_addr         = inet_addr("192.168.3.169"); //选择IP地址
    ! W% L' \2 a( e# ^
26. 
    ' U+ ~! C3 g" y9 v( L/ b
27. if (0 > bind(sockfd, (struct sockaddr*)&myaddr, sizeof(myaddr)))//绑定套接字
    
28.          {
    + F. r9 F& `& K
29.                  perror("bind");
    & T$ N: j' \% Z2 q+ |
30.                  return -1;
    ) r3 U0 u7 h6 A
31.          }
    
32.          printf("bind..........
    
33. ");
    2 }/ c7 l4 e9 {$ }3 A
34. 
    
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    
36.          {
    7 m, n7 L) Y9 s
37.                  perror("listen");
    
38.                  return -1;
    
39.          }
    , c9 T. T8 e/ k0 F3 R4 F
40.          printf("listen............
    & H4 `( h, `% Y& C
41. ");
    . W; ~: m( T( \5 M: @, G1 B
42.          
    , o; i* A0 K3 R" e, n: |
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
    * b6 j" y3 J( T/ a1 p2 o3 Z
44.         if (connfd < 0)
    
45.         {
    
46.                 perror("accept");
    
47.                 return -1;
    
48.         }
    
49.         printf("accept..............
    
50. ");
    ! [+ d" ~! N7 w& C- r* }9 [! n
51.         char buf[100];//定义一个数组用来存储接收到的数据
    
52.         int ret;
    7 h" B* a; o, l' u5 d7 G, l6 C
53.         while (1)
    
54.         {
    7 C* ?! f% @$ Q0 Q% j# m' L4 M
55.                 memset(buf, 0, sizeof(buf));
    
56.                 ret = read(connfd, buf, sizeof(buf));
    2 V. }$ T" k# ?$ [  p3 p
57.                 if (0 > ret)
    9 x7 l  q  h) N0 N
58.                 {
    
59.                         perror("read");
    + Q7 v( T7 n7 p! ]: J# Y9 J
60.                         break;
    - R: T( \- s$ |
61.                 }//执行while循环读取数据，当
    
62.                 else if (0 == ret)
    ' f6 M" h" c; _% R
63.                 {
    
64.                         printf("write close!
    
65. ");
    * h6 a6 U" |  b+ \8 c7 |
66.                         break;
    , B0 q2 v: z6 ]! R7 U* H
67.                 }
    # ]6 a) x3 S( V2 w
68.                 printf("recv: ");
    + e$ s! V' r6 C4 j. C5 L
69.                 fputs(buf, stdout);//打印接收到的数据
    . `8 T# a* B+ b% s" a1 c/ V
70.         }
    
71.         close(sockfd);//关闭套接字
    
72.         close(connfd);//断开连接
    
73.         return 0;
    & c( F7 G% Q+ o; _9 F
74. }

复制代码

* H: H% h: Z) `/ ]

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   
2. #include <stdio.h>
   . x; P* b3 m: |  O0 V
3. #include <string.h>
   
4. #include <stdlib.h>
   
5. #include <strings.h>
   ! M+ ~; Q5 Y) R& J4 b5 n2 a
6. #include <sys/types.h>
   2 m7 D$ I! H4 }
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   6 u8 K: K% P2 |+ d
9. #include <arpa/inet.h>
   . o2 P" G+ b4 s( K' q) o
10. int main()
    
11. {
    
12. int sockfd;
    1 T: K. U1 r, N1 w2 R6 ]7 h
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    
14.         {
    & N: P- W: x* g- S* Q# W
15.                 perror("socket");
    
16.                 return -1;
    
17.         }
    9 G+ o3 s2 I0 ~9 ?/ i* v
18.         printf("socket...........
    
19. ");
    
20.         
    * q9 x, o0 N  w- D1 q& ^3 v
21.         struct sockaddr_in srv_addr;
    
22.         memset(&srv_addr, 0, sizeof(srv_addr));
    9 e( C) ?& T* p( p4 a2 ?
23.         srv_addr.sin_family                 = AF_INET;
    6 [$ T' D" y& |8 k# }
24.         srv_addr.sin_port                         = htons(8888);
    
25.         srv_addr.sin_addr.s_addr         = inet_addr("192.168.3.169");
    4 X! w6 a! t5 `, F
26.         if (0 > connect(sockfd, (struct sockaddr*)&srv_addr, sizeof(srv_addr)))
    & H. ]" K7 Z6 |! B: ^# ~
27.         {
    
28.                 perror("connect");
    
29.                 return -1; //exit //pthread_exit
    ( i0 c# g# \7 o! q6 `' `. G
30.         }
    ! L7 s5 y9 a( E0 }
31.         printf("connect..............
      A7 R2 m/ ^* J# F1 r5 W
32. ");
    , i9 C( A) w& o9 m, x3 ^$ m6 Q
33.         char buf[100];
    
34.         int ret;
    
35.         while (1)
    
36.         {
    ) u  d8 o/ \. G
37.                 printf("send: ");
    % ^/ o2 H: `3 R4 i8 O8 H
38.                 fgets(buf, sizeof(buf), stdin);
    5 S* l6 P& L, }+ ~! A
39.                 ret = write(sockfd, buf, sizeof(buf));
    
40.                 if (ret < 0)
    
41.                 {
    
42.                         perror("write");
    ! p. i" C/ d7 B2 v2 P
43.                         break;
    
44.                 }
    ' {9 d5 W0 F7 a4 ?4 ]
45.                 if (strncmp(buf, "quit", 4) == 0)
      @6 n; i# c3 Y
46.                         break;
    
47.         }
    
48.         close(sockfd);
    $ E  }; b* i1 B+ a
49.         return 0;
    
50. }

复制代码

- m. [+ }; ?1 Q/ T- V" l
% ]  l1 `& A. m