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

admin

如果想要自己写一个服务器和客户端，我们需要掌握一定的网络编程技术，个人认为，网络编程中最关键的就是这个东西——socket（套接字）。
: n( l& Y6 W# g. D' I4 m
* `2 Q3 z6 Y- j5 D! U2 K
socket（套接字）：简单来讲，socket就是用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。


TCP协议
TCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。
: ^/ g" S; C3 f9 b; x3 y$ y

/ r4 C& h0 |+ m; y8 J& F  N: @& E关键词：三次握手，可靠，基于字节流。

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

5 f3 d- G( o6 ]/ ]% kTCP服务器端和客户端的运行流程

& B- Z$ d6 H; [* r6 }
如图，这是一个完整的TCP服务器——客户端的运行流程图，其实我个人认为程序啊，不管哪个语言都是一样，核心就在于算法的设计和函数的调用。那么图中的函数都是什么意思呢？
7 T2 e& w3 y8 H, V  M2 g" D

1.创建socket
socket是一个结构体，被创建在内核中
sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议
. r; Z+ V  p$ K3 r9 b
# V7 A9 W1 T# f. C/ u) C3 K( l
2.调用bind函数
0 k  {! j0 I2 ~5 A 将socket和地址（包括ip、port）绑定。
需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
; B  S% n0 P+ j struct sockaddr_in myaddr; //地址结构体
bind函数
3 P( u) z5 B- a* Z! e4 M bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))

. V: C3 D# g9 N- @# a* x1 ^# e/ Y
3.listen监听，将接收到的客户端连接放入队列
listen(sockfd,8) //第二个参数是队列长度

. Q0 i) M! ^2 |
4.调用accept函数，从队列获取请求，返回socket描 述符
  如果无请求，将会阻塞，直到获得连接
6 L- B5 l# i6 J  d4 V- m  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数
8 V7 U+ U% p9 x% U: T
( \" |7 [; i; Y0 `0 g  o' P
5.调用read/write进行双向通信
$ a/ q* E+ K+ W+ y! R

# M# B2 _# s. X  a6.关闭accept返回的socket
, _2 u$ q$ I! Z! l/ r  close(scokfd);
8 _: ?2 q9 Q* o2 X- F$ _


- O% t$ p. P& o. V7 U# D
下面放出完整代码
: k- v7 L* z: `; M
3 a6 N2 S/ X9 r' c+ f5 n

1. /*服务器*/
   
2. #include <stdio.h>
   # I# W+ Q/ Z) v! u) {% U) _
3. #include <string.h>
   
4. #include <stdlib.h>
   3 D# F% R: H3 h+ g  i* C
5. #include <strings.h>
   
6. #include <sys/types.h>
   9 H2 D$ j" }# e) m& a) q
7. #include <sys/socket.h>
   
8. #include <arpa/inet.h>
   9 W8 n" C1 N8 a( g
9. #include <netinet/in.h>
   6 n6 B3 [4 k2 G* D
10. int main()
    
11. {
    5 }: D$ T% r! `. i
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    
13.         if (sockfd < 0)
    
14.         {
    / l6 _$ L1 x9 K# ~2 I' Y5 c9 t5 F
15.                 perror("socket");
    ! O( k9 @* g! f6 ?6 K
16.                 return -1;
    
17.         } //创建失败的错误处理
    
18.          printf("socket..............
    
19. "); //成功则打印“socket。。。。”
    ; C7 |" ?2 y! R) O) L4 [$ c
20.          
    
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    
23.          myaddr.sin_family                 = AF_INET; //选择IPV4地址类型
    ) b, E5 ]- q7 V0 V1 t
24.          myaddr.sin_port                 = htons(8888); //选择端口号
    
25.          myaddr.sin_addr.s_addr         = inet_addr("192.168.3.169"); //选择IP地址
    
26. 
    7 l( w! P! J3 W, _
27. if (0 > bind(sockfd, (struct sockaddr*)&myaddr, sizeof(myaddr)))//绑定套接字
    7 X4 G& l8 w  I% \
28.          {
    * W, [5 m# {/ J) i/ P/ [
29.                  perror("bind");
    ; i; `7 I1 f; \% L9 i
30.                  return -1;
    ' p. ?5 r; t5 A9 v: n
31.          }
    
32.          printf("bind..........
    ( w1 g0 n3 n5 ?9 X! }- n
33. ");
    ) b! h  {) B7 o3 v0 @3 i! T
34. 
    
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    ( K! ]. e# {; Y$ F9 q" G
36.          {
    
37.                  perror("listen");
    
38.                  return -1;
    
39.          }
    & B- R4 D0 G" c; ]: O
40.          printf("listen............
    ) B; s2 o' V7 ~4 i
41. ");
    
42.          
    
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
    ; _  I3 P% ?; Y2 m
44.         if (connfd < 0)
    
45.         {
    
46.                 perror("accept");
    
47.                 return -1;
    3 G7 h) h2 H7 a: f# G% m
48.         }
    
49.         printf("accept..............
    % ?* E. n6 ]  O* z! q; {
50. ");
    : b- ]& ~6 J5 a" O9 w: H# V6 K
51.         char buf[100];//定义一个数组用来存储接收到的数据
    
52.         int ret;
    & E9 P( U! B5 ~  V2 w5 P$ z4 w
53.         while (1)
    " U$ v1 n( V) j& r! D! C  u! R
54.         {
    ' e+ [1 v. Z1 `$ |
55.                 memset(buf, 0, sizeof(buf));
    
56.                 ret = read(connfd, buf, sizeof(buf));
    
57.                 if (0 > ret)
    
58.                 {
    
59.                         perror("read");
    
60.                         break;
    
61.                 }//执行while循环读取数据，当
    
62.                 else if (0 == ret)
    
63.                 {
    
64.                         printf("write close!
    
65. ");
    , e1 {, v# n+ X, B. J( s
66.                         break;
    
67.                 }
    
68.                 printf("recv: ");
    1 r( b5 u: V5 ^1 }) q1 x! U( Z
69.                 fputs(buf, stdout);//打印接收到的数据
      v' B- @, s% W4 T: w7 {
70.         }
    
71.         close(sockfd);//关闭套接字
    
72.         close(connfd);//断开连接
    ! j) n% _# [" G1 k, q7 {8 y
73.         return 0;
    * p9 C$ H9 ?2 y4 s& o. i
74. }

复制代码

* L; T+ Z8 D* B' T' }% v

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   
2. #include <stdio.h>
   
3. #include <string.h>
     X" s9 C7 h! j6 b# Q' s- x  y
4. #include <stdlib.h>
   
5. #include <strings.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   
10. int main()
    / Q: z' ^; p5 J
11. {
    
12. int sockfd;
    / k0 L; }6 ?5 @
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    / W  F- Y% C& }7 l2 p& F
14.         {
    - k! y, I2 `  \, s+ p
15.                 perror("socket");
    
16.                 return -1;
    + L- _( F6 _: i4 n9 J
17.         }
    
18.         printf("socket...........
    
19. ");
    4 r" Q6 D- z3 H# P( r5 y6 }1 Z
20.         
    " t( t  G4 T# I
21.         struct sockaddr_in srv_addr;
    
22.         memset(&srv_addr, 0, sizeof(srv_addr));
    2 ?  p8 q; y1 v$ V- k, L
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");
    ) _6 `- l8 B' {! \: x
26.         if (0 > connect(sockfd, (struct sockaddr*)&srv_addr, sizeof(srv_addr)))
    + G7 E; A8 K; m7 Y- k  V& u1 n
27.         {
    
28.                 perror("connect");
    
29.                 return -1; //exit //pthread_exit
    # i) D$ d- X) U: S$ H; q
30.         }
    
31.         printf("connect..............
    2 n" X# e# N& ]& _& i8 G9 p( @
32. ");
    
33.         char buf[100];
    . {2 Y: l& I  d8 {
34.         int ret;
      l% E* X' h2 ?5 R
35.         while (1)
    : A% `! |$ h# l+ Q1 S$ [
36.         {
    
37.                 printf("send: ");
    
38.                 fgets(buf, sizeof(buf), stdin);
    
39.                 ret = write(sockfd, buf, sizeof(buf));
      s" V" p6 U0 b$ x4 ~
40.                 if (ret < 0)
    
41.                 {
    - F! s6 f1 F0 e. n/ W1 R/ F  L7 f% r
42.                         perror("write");
    
43.                         break;
    
44.                 }
    
45.                 if (strncmp(buf, "quit", 4) == 0)
    
46.                         break;
    , I) Q( ]$ W" u' l( k$ |6 l( u
47.         }
    
48.         close(sockfd);
    3 p' w/ ^" C, g  |. q% {0 l4 S
49.         return 0;
    " P, d: u& E& m7 i; J' v
50. }

复制代码

4 |9 B( |& T" X4 t" R0 `8 f
9 i  |  g7 c2 I) d