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

admin

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

9 p, \' `- ]& D
9 W! i4 d# U! U- L2 e& V( ]9 [socket（套接字）：简单来讲，socket就是用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。
( U8 x: ?% o4 @# R" I7 k  K

TCP协议
8 r* O/ u# b) KTCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。


0 E* T3 f0 o" Q4 f关键词：三次握手，可靠，基于字节流。
( k! ^8 }3 s6 @. W
" l7 b$ b1 a* K3 ?& p1 R
可能有朋友会问，TCP就这么简单一句话吗？当然不是，TCP作为非常重要的传输协议，细节知识是很多的，细讲起来这一篇文章怕是不够。不过在本篇内容中，我们只需了解他的几个关键词特性，就能很好的理解下面的内容。

TCP服务器端和客户端的运行流程
( P: A) v9 h8 m- s4 S. t  [0 B

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


) k( v9 `" S' e  U! x1.创建socket
" q: M$ o5 B* B- {1 S socket是一个结构体，被创建在内核中
% U) m0 S, o3 E sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议

( `* ^( D6 l" I- H  |& g6 N
" c) O3 x- B, A6 i3 s6 k: g! {2.调用bind函数
* D9 l2 b6 \* ^7 l8 Z& d* d 将socket和地址（包括ip、port）绑定。
4 z, Z/ v: e8 _ 需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
struct sockaddr_in myaddr; //地址结构体
bind函数
7 Z' v9 X) B1 p3 ] bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))
' z) u8 e- B& p9 Z

3.listen监听，将接收到的客户端连接放入队列
$ \7 z: i6 t' {; t$ N4 `. R listen(sockfd,8) //第二个参数是队列长度

/ L: }$ D+ _! l0 b
4.调用accept函数，从队列获取请求，返回socket描 述符
  如果无请求，将会阻塞，直到获得连接
  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数

: x7 B5 |* l# V4 t5 R  Q% X
! d, ?: p1 x* E, {* p5 B# }: |1 N) y5.调用read/write进行双向通信
9 w, u2 ^' ~/ j, w% |6 U! X7 a

6.关闭accept返回的socket
  close(scokfd);

: ]( t  R2 D& A: `
- L7 Q2 q4 \2 B7 Z$ h
" I! P$ N5 Y4 R+ C% \! R9 |
! w% G2 E; H9 _$ @( I# O下面放出完整代码
3 n( r4 Q! q& u
( I( z7 @7 H1 K( i& H4 ^: P

1. /*服务器*/
   ' e4 k9 m, }" r3 @4 l8 B* Z- X
2. #include <stdio.h>
   
3. #include <string.h>
     X: ^" I4 F& G, q6 E) V) ~
4. #include <stdlib.h>
   & i3 K+ A1 Y. V8 }/ E
5. #include <strings.h>
   
6. #include <sys/types.h>
   2 O/ c+ n! S1 I7 y/ O' R
7. #include <sys/socket.h>
   : z" a; @, e9 X
8. #include <arpa/inet.h>
   
9. #include <netinet/in.h>
   5 t- l  K6 g) f/ R( o2 O; k
10. int main()
    
11. {
    
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    
13.         if (sockfd < 0)
    : G: q, `( `: J. {! `
14.         {
      C6 e3 L& c, e- T7 O; f. ^
15.                 perror("socket");
    
16.                 return -1;
    5 G3 Z: Y1 P/ X) t/ A3 D
17.         } //创建失败的错误处理
    2 T9 y4 g8 d2 B3 r- O
18.          printf("socket..............
    3 u1 W/ k3 B9 _' P, f
19. "); //成功则打印“socket。。。。”
    
20.          
    4 d  R+ e2 L/ n+ K' m  Y
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    
23.          myaddr.sin_family                 = AF_INET; //选择IPV4地址类型
    2 h# L# G+ A9 t7 ~
24.          myaddr.sin_port                 = htons(8888); //选择端口号
    ! ^7 d/ Z3 `. c2 n5 T$ [" U( n1 B
25.          myaddr.sin_addr.s_addr         = inet_addr("192.168.3.169"); //选择IP地址
    
26. 
    ) L% M! k! f$ q, M+ n
27. if (0 > bind(sockfd, (struct sockaddr*)&myaddr, sizeof(myaddr)))//绑定套接字
    
28.          {
    9 w( z8 \3 l/ J# _4 v
29.                  perror("bind");
    ( s) r* j' k+ R8 ^! A$ J
30.                  return -1;
    
31.          }
    7 I# q& C7 c: ?$ V5 D( S
32.          printf("bind..........
    
33. ");
    
34. 
    8 B( a$ ]+ Y$ c' |! y4 x
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    0 s0 a5 z' s# O* C) o
36.          {
    
37.                  perror("listen");
    
38.                  return -1;
    0 ~4 h3 D( f- L5 q) t; C/ p, A
39.          }
    
40.          printf("listen............
    ) q( L6 h  K0 O# S
41. ");
    
42.          
    ) D8 R7 N* y7 K! g  a/ y5 q; t- }! S8 E# v
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
    
44.         if (connfd < 0)
    
45.         {
    
46.                 perror("accept");
    2 ]/ W" R8 y8 l3 o/ k
47.                 return -1;
    
48.         }
    
49.         printf("accept..............
    2 U) e, Q9 D& O* i! ~
50. ");
    6 T% p6 r; o- m5 r7 ~# n6 l
51.         char buf[100];//定义一个数组用来存储接收到的数据
    
52.         int ret;
    
53.         while (1)
    # p1 E" |% }( b" x
54.         {
    ! A* [6 G! A4 C
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循环读取数据，当
    6 X. \! _0 U7 y. b5 k1 p
62.                 else if (0 == ret)
    7 y' W! v4 `) I0 N$ F/ a$ n
63.                 {
    
64.                         printf("write close!
    . q' `7 U0 d) Q2 w$ V. q: y
65. ");
    / z2 _$ D1 t3 e. P5 _+ K9 N" i
66.                         break;
    " N* w& P4 @! L3 [
67.                 }
    
68.                 printf("recv: ");
    
69.                 fputs(buf, stdout);//打印接收到的数据
    
70.         }
    
71.         close(sockfd);//关闭套接字
    5 Y2 @: N) C% G2 u1 H# S
72.         close(connfd);//断开连接
    
73.         return 0;
    
74. }

复制代码

4 r8 W2 M  Y5 {! n  {

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   
2. #include <stdio.h>
   
3. #include <string.h>
   
4. #include <stdlib.h>
   
5. #include <strings.h>
   0 D6 |! N9 E) `( s% Z3 m
6. #include <sys/types.h>
   * t+ T+ c2 l& E: B- m
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   5 z' f3 q! Y" H+ g
9. #include <arpa/inet.h>
   
10. int main()
    
11. {
    
12. int sockfd;
    . M  \, b% E% V- e$ I5 S
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    4 E" y/ Z# }) x3 w, o
14.         {
    
15.                 perror("socket");
    
16.                 return -1;
    6 w' f, A  Z  E6 _2 k
17.         }
    $ b4 u7 W+ S, y7 ~" j8 _
18.         printf("socket...........
    
19. ");
    8 U* k  c0 D1 y; X
20.         
    
21.         struct sockaddr_in srv_addr;
    
22.         memset(&srv_addr, 0, sizeof(srv_addr));
    3 s" D0 a! J2 f
23.         srv_addr.sin_family                 = AF_INET;
    : y1 |7 ?1 c# @3 I; \
24.         srv_addr.sin_port                         = htons(8888);
    
25.         srv_addr.sin_addr.s_addr         = inet_addr("192.168.3.169");
    5 n  _' A& m0 N9 z% P9 E: M0 y
26.         if (0 > connect(sockfd, (struct sockaddr*)&srv_addr, sizeof(srv_addr)))
    , @1 a6 [7 }4 f$ I% W
27.         {
    7 w; @+ N2 z- q4 [/ u
28.                 perror("connect");
    " L: U1 E- r6 X" a, _$ m6 `
29.                 return -1; //exit //pthread_exit
    
30.         }
    % x; G2 {) M+ o9 S" Y
31.         printf("connect..............
    * Q- C3 i4 G. R' i2 V# p
32. ");
    
33.         char buf[100];
    
34.         int ret;
    
35.         while (1)
    1 m; r& b  w: M6 |2 f
36.         {
      `0 y! A0 p+ c
37.                 printf("send: ");
    
38.                 fgets(buf, sizeof(buf), stdin);
    7 E8 [1 c, y8 _: B3 b8 F/ Q
39.                 ret = write(sockfd, buf, sizeof(buf));
    
40.                 if (ret < 0)
    
41.                 {
    
42.                         perror("write");
    
43.                         break;
    1 R4 r' ^+ U) o
44.                 }
    
45.                 if (strncmp(buf, "quit", 4) == 0)
    
46.                         break;
    
47.         }
    - C* K2 k" h: p5 W5 ?; ]
48.         close(sockfd);
    
49.         return 0;
    $ D0 O9 ]- K1 E' G1 E
50. }

复制代码

' x: k+ h( O- o6 n7 o  W9 u8 m5 Q& U