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

admin

如果想要自己写一个服务器和客户端，我们需要掌握一定的网络编程技术，个人认为，网络编程中最关键的就是这个东西——socket（套接字）。
( I) G6 }4 K: ?) M" O8 S8 j
& P& _0 Y" h/ t+ G2 ~
  c7 w1 e# E6 S! i! m; R1 \socket（套接字）：简单来讲，socket就是用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。
* {0 ^' h/ \# J- z
6 j1 ^0 X2 k0 U% c, K( q
TCP协议
TCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。


: O0 z* X# E- ~) N# ~8 G关键词：三次握手，可靠，基于字节流。
9 y) w( a" G% E3 {; J4 l" y
* t3 f0 c& _3 g$ b" {
7 m& K8 X3 I  y. @可能有朋友会问，TCP就这么简单一句话吗？当然不是，TCP作为非常重要的传输协议，细节知识是很多的，细讲起来这一篇文章怕是不够。不过在本篇内容中，我们只需了解他的几个关键词特性，就能很好的理解下面的内容。
7 L% k9 l; ]  u5 V. d, i/ i0 h
+ H1 u5 A' Q; h; ^. cTCP服务器端和客户端的运行流程
5 P/ w& e1 \7 m/ `

如图，这是一个完整的TCP服务器——客户端的运行流程图，其实我个人认为程序啊，不管哪个语言都是一样，核心就在于算法的设计和函数的调用。那么图中的函数都是什么意思呢？
, T2 S6 t: ^( H: i" h& r+ s: C: D
6 d5 q7 y* |& z! R) I
' m0 W4 _& l" @8 {' e, b& \+ C1.创建socket
socket是一个结构体，被创建在内核中
sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议


7 W: i1 A5 N( x2 o! p0 ?* O1 J$ f" V2.调用bind函数
) ~, W9 E3 i: } 将socket和地址（包括ip、port）绑定。
7 V* T. N% F" o. \: L. `1 } 需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
struct sockaddr_in myaddr; //地址结构体
: d6 `( {0 D' [* t bind函数
bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))
. n* Q/ X; L0 M

3.listen监听，将接收到的客户端连接放入队列
listen(sockfd,8) //第二个参数是队列长度


" z& S  H% ^( p& v  s: v4.调用accept函数，从队列获取请求，返回socket描 述符
  如果无请求，将会阻塞，直到获得连接
  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数

; z% A+ i$ A& e' m7 i7 ?7 J. t; n$ t
5.调用read/write进行双向通信
; D7 D8 F3 a" j6 `' ?6 _8 v

& D" z" E3 K- y2 ?% _7 ]6.关闭accept返回的socket
  close(scokfd);
/ G1 u4 h- Q% H! x3 ?
5 `+ d. C4 o- J* b
' o, D+ f. r' R* a4 O, B

下面放出完整代码
' g6 W& u& Q$ e. o% G
1 h! T2 [$ k9 m" K  L5 T

1. /*服务器*/
   6 F( K  o3 q2 u- z  o2 I) t1 v
2. #include <stdio.h>
   
3. #include <string.h>
   
4. #include <stdlib.h>
   
5. #include <strings.h>
   
6. #include <sys/types.h>
   , b2 P$ l) F' E" s0 Z/ \- |. Y
7. #include <sys/socket.h>
   
8. #include <arpa/inet.h>
   
9. #include <netinet/in.h>
   
10. int main()
    4 t& _  A) g6 ~6 _) H! |! N
11. {
    5 x( p$ Q+ ~; R
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    + `5 [! w1 v  j' }- L( l% `8 r* u5 X
13.         if (sockfd < 0)
    - i. h4 A9 j, i- K$ d5 o; f: N1 p
14.         {
    
15.                 perror("socket");
    / m( r4 s' T! a, Z$ L
16.                 return -1;
    
17.         } //创建失败的错误处理
    ) |4 D$ [; y! Y% U
18.          printf("socket..............
    $ M) j: m$ h0 F2 _$ w. j3 S1 P% T3 }
19. "); //成功则打印“socket。。。。”
    : A* O2 G0 ]  U3 p
20.          
    
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    3 S  _* W* ~# n' F# E3 _! E, F
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    0 B5 }4 c, z! H' d' C% J+ S
23.          myaddr.sin_family                 = AF_INET; //选择IPV4地址类型
    
24.          myaddr.sin_port                 = htons(8888); //选择端口号
    : C, C7 f6 x6 @0 N2 g! g
25.          myaddr.sin_addr.s_addr         = inet_addr("192.168.3.169"); //选择IP地址
    
26. 
    
27. if (0 > bind(sockfd, (struct sockaddr*)&myaddr, sizeof(myaddr)))//绑定套接字
    
28.          {
    6 L0 s* Q+ p3 u- o
29.                  perror("bind");
    
30.                  return -1;
    : \1 P& E/ ?$ p
31.          }
    
32.          printf("bind..........
    # o* O: X8 I, X6 U! l3 b, p
33. ");
    
34. 
    
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    
36.          {
    
37.                  perror("listen");
      {0 J, j$ U/ Y/ K, o( T
38.                  return -1;
    
39.          }
    6 E7 O+ f4 ^( m' ^  h
40.          printf("listen............
    
41. ");
      q8 l; `6 e! R6 k
42.          
    7 [& j" |) p+ [/ n% V" S) X: r; G( Q
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
    0 |  `% a2 B4 S( S
44.         if (connfd < 0)
    $ Q2 `) c4 V& g, P! N0 A
45.         {
    & s& u$ l" b9 v
46.                 perror("accept");
    7 @2 C; V7 p; Z; ^0 s+ |
47.                 return -1;
    
48.         }
    
49.         printf("accept..............
    
50. ");
    * G9 f: e7 k3 t! w9 w
51.         char buf[100];//定义一个数组用来存储接收到的数据
    
52.         int ret;
    
53.         while (1)
    
54.         {
    
55.                 memset(buf, 0, sizeof(buf));
    - Z( l+ q; B+ k; `# J& k/ }
56.                 ret = read(connfd, buf, sizeof(buf));
    
57.                 if (0 > ret)
    
58.                 {
    
59.                         perror("read");
    : r# m. [8 T, b  q$ R
60.                         break;
    
61.                 }//执行while循环读取数据，当
    
62.                 else if (0 == ret)
    
63.                 {
    
64.                         printf("write close!
    
65. ");
    ! z# W1 t% N% P1 I
66.                         break;
    
67.                 }
    
68.                 printf("recv: ");
    4 L! N" J5 c7 N( i& P
69.                 fputs(buf, stdout);//打印接收到的数据
    
70.         }
    4 h4 f( b5 u5 H( i. |* h
71.         close(sockfd);//关闭套接字
    
72.         close(connfd);//断开连接
    1 U* y0 H: K/ ~, k  z, i! L. f
73.         return 0;
    6 B$ A! ^  N- o) L0 |, j
74. }

复制代码

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   : E/ V& M, u0 i) a
2. #include <stdio.h>
   , W6 f# s- _% n, a' e: Y. S
3. #include <string.h>
   
4. #include <stdlib.h>
   ! A8 @) k/ l: i" G  @- |9 W
5. #include <strings.h>
   
6. #include <sys/types.h>
   / X5 i3 r  ?6 j' E( a' |- M2 a( T
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   ) z8 h6 u0 ~9 D
10. int main()
    
11. {
    
12. int sockfd;
    
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    ( F2 n2 V1 n1 ]
14.         {
    1 @/ \) h+ \& A  ~2 U( C# b
15.                 perror("socket");
    3 D# s, i8 M8 v
16.                 return -1;
    5 E2 j" F% `" A, c, G/ Y# F
17.         }
    1 \- [: V) ^  ^# u- l! @3 \
18.         printf("socket...........
    
19. ");
    
20.         
    2 V  l4 j( W0 B6 l% `+ O* ^
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");
    
26.         if (0 > connect(sockfd, (struct sockaddr*)&srv_addr, sizeof(srv_addr)))
    4 ?3 j0 V8 ~/ u8 Y, V; g, S
27.         {
    9 j% {+ ]# y3 a# O9 n5 q9 S/ }8 Z
28.                 perror("connect");
    # z2 I6 f# `1 V" }# L
29.                 return -1; //exit //pthread_exit
    
30.         }
    
31.         printf("connect..............
    
32. ");
    
33.         char buf[100];
    
34.         int ret;
    ( Z$ g& D4 ^& t4 W( h
35.         while (1)
    ' L* ~1 @6 ~& V4 u% Q; S: G
36.         {
    
37.                 printf("send: ");
    
38.                 fgets(buf, sizeof(buf), stdin);
    
39.                 ret = write(sockfd, buf, sizeof(buf));
    5 R( f# I" S  Q5 }) V3 e
40.                 if (ret < 0)
    4 _2 K' i/ s/ d5 A$ J
41.                 {
    
42.                         perror("write");
    
43.                         break;
    
44.                 }
    
45.                 if (strncmp(buf, "quit", 4) == 0)
      W+ a2 G  q3 T2 L- M# j
46.                         break;
    
47.         }
    
48.         close(sockfd);
    
49.         return 0;
    + @4 P2 T2 a$ d
50. }

复制代码