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

admin

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

socket（套接字）：简单来讲，socket就是用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。
' e3 ~2 @- B' @  V; f5 ~! l7 t0 |
* D: W; ~4 B1 y6 S1 C- k, O8 r
TCP协议
TCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。

: W+ v5 ~7 w% D) b3 w
/ K5 _- s9 u% `# j9 @! J+ T关键词：三次握手，可靠，基于字节流。

' q/ ~* N  \: ^
可能有朋友会问，TCP就这么简单一句话吗？当然不是，TCP作为非常重要的传输协议，细节知识是很多的，细讲起来这一篇文章怕是不够。不过在本篇内容中，我们只需了解他的几个关键词特性，就能很好的理解下面的内容。
0 l% _! h% O" R7 _; i! ^* l
TCP服务器端和客户端的运行流程
" I5 c; d$ W- H3 C* m

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

; H3 @0 x% X9 v7 H) ^9 \9 @
1.创建socket
socket是一个结构体，被创建在内核中
sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议
5 y# c" L1 I- b8 u/ y) D

2.调用bind函数
将socket和地址（包括ip、port）绑定。
需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
# f( b( R: X7 [# M" T/ ^# c( ~ struct sockaddr_in myaddr; //地址结构体
1 G/ _/ h4 Z1 U! d/ t* O* f bind函数
bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))
! o9 ^) x! l7 S' Y: H. ]

3.listen监听，将接收到的客户端连接放入队列
0 t; f2 q! N8 [& V/ F listen(sockfd,8) //第二个参数是队列长度
; I! h# ~" q: e" W' d( R
  A7 Y  E- @; M; M
4.调用accept函数，从队列获取请求，返回socket描 述符
+ Y# |3 h2 {. R8 r9 }2 e# ?  如果无请求，将会阻塞，直到获得连接
) W8 V& L( f9 H) g: k  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数
/ R3 s- [2 c. W  K: h: F
  S2 W' A' {" p1 W3 `& {
, m3 @% y! j1 R/ I' G# M& s5.调用read/write进行双向通信
" f1 H2 {" ~3 y* f- ~3 F( w
& |' {* m) S2 J" Z  e
6.关闭accept返回的socket
8 H; x/ j9 m+ ~% D  close(scokfd);
6 Z2 E9 V2 @3 |% X, `
' P5 b& u) {; }& ~1 }
+ \' Z2 R1 |6 k- |; w
1 w+ |  @' e) K# W
下面放出完整代码
- z- U9 D/ _% s! G& I

1. /*服务器*/
   6 {* P' g" z, A  T  q
2. #include <stdio.h>
   $ g9 v; i' x2 Y! {
3. #include <string.h>
   , D& J5 ?( n0 d" C- w
4. #include <stdlib.h>
   . V9 v; {* O( D4 ~& h0 m
5. #include <strings.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   ( h' r! x7 G! u8 _: g
8. #include <arpa/inet.h>
   
9. #include <netinet/in.h>
   , g: ]. p! h2 o$ ~0 J; |2 r
10. int main()
    
11. {
    ' @+ \0 i3 T0 B5 U) b9 x
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    : e( @/ o; y; y* t' R9 h
13.         if (sockfd < 0)
    2 M1 `6 |) \! q* O7 Z6 q3 o
14.         {
    
15.                 perror("socket");
    5 S+ t) X' c0 k
16.                 return -1;
    
17.         } //创建失败的错误处理
    ; a8 `/ C; @9 u9 u% H/ k4 F
18.          printf("socket..............
    / ]- ?+ f/ t8 Z, J7 j/ x) X, l
19. "); //成功则打印“socket。。。。”
    
20.          
    & k& p6 M2 Y* f) d3 G
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    
23.          myaddr.sin_family                 = AF_INET; //选择IPV4地址类型
    ' ?8 T2 V' z7 o: o. F9 S7 }+ z$ z
24.          myaddr.sin_port                 = htons(8888); //选择端口号
    
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.          {
    / C6 f# ^! D0 z. |; G' |8 }- {
29.                  perror("bind");
    
30.                  return -1;
    
31.          }
    ; s* l% g( h' U
32.          printf("bind..........
    
33. ");
    
34. 
    
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    3 @5 B% \5 V) y( t- c# N
36.          {
    
37.                  perror("listen");
    * c9 g3 ]! S* g% W0 ~
38.                  return -1;
    3 H2 \* c) X7 s5 {! w) E7 O
39.          }
    . g! o, V0 ~3 d4 g& D3 q* y
40.          printf("listen............
    
41. ");
    
42.          
    
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
    ' }- P3 t: d, f
44.         if (connfd < 0)
      M4 v- x3 M2 s; ?. R# T
45.         {
    
46.                 perror("accept");
    8 f5 q# L7 K7 B' F8 j
47.                 return -1;
    
48.         }
    
49.         printf("accept..............
    9 ]: V' t+ n0 s# t: K; @8 p
50. ");
    + F1 B# T) Q" j/ B8 n
51.         char buf[100];//定义一个数组用来存储接收到的数据
    ! ?  {) i3 |& T, r; x/ k' T* T
52.         int ret;
    
53.         while (1)
    
54.         {
    1 c+ a* {% S3 |) ?
55.                 memset(buf, 0, sizeof(buf));
    6 D) Y( I4 H: ?6 O; t5 d4 {5 A) H+ c
56.                 ret = read(connfd, buf, sizeof(buf));
    - g! v# i/ s, n3 C# i
57.                 if (0 > ret)
    
58.                 {
    ( ~- Z/ j; y1 }+ Z
59.                         perror("read");
    " ?5 B/ l) N  i+ @+ o3 q
60.                         break;
    2 ^) ^% l! F% u# o) W1 A
61.                 }//执行while循环读取数据，当
    
62.                 else if (0 == ret)
    
63.                 {
    
64.                         printf("write close!
    
65. ");
    
66.                         break;
    
67.                 }
    
68.                 printf("recv: ");
    8 g+ Z6 H6 ]5 @8 ]# {( O
69.                 fputs(buf, stdout);//打印接收到的数据
    8 |1 V; K2 v2 h
70.         }
    
71.         close(sockfd);//关闭套接字
      [$ W0 F( E) n
72.         close(connfd);//断开连接
    8 b* d. ~; O7 x
73.         return 0;
    0 S2 }- R1 s/ i+ M4 r0 Y
74. }

复制代码

, r, s3 C* m1 f8 O" v* y5 U
% }$ \- V; y) |

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   
2. #include <stdio.h>
   
3. #include <string.h>
   2 t0 I6 {7 e5 n
4. #include <stdlib.h>
   / R5 M9 A" v$ y0 N
5. #include <strings.h>
   6 |- c4 z8 z4 U4 c! R2 W; ?
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   . U( f! P. t- D. ?& S/ ]6 h/ _
9. #include <arpa/inet.h>
   
10. int main()
    / `4 H9 J/ ]* ?4 q
11. {
    
12. int sockfd;
    
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    
14.         {
    
15.                 perror("socket");
    * N; i4 O2 V* |3 F$ W/ S" X
16.                 return -1;
    9 K# Z  T' F1 `. Q9 H
17.         }
    
18.         printf("socket...........
    
19. ");
    
20.         
    
21.         struct sockaddr_in srv_addr;
    
22.         memset(&srv_addr, 0, sizeof(srv_addr));
    
23.         srv_addr.sin_family                 = AF_INET;
    8 {2 U' ~5 ^0 R+ P$ D% B4 \6 m
24.         srv_addr.sin_port                         = htons(8888);
    4 R) f+ T$ G$ o9 \9 f( x
25.         srv_addr.sin_addr.s_addr         = inet_addr("192.168.3.169");
    . L& X8 E7 F( z( v/ o
26.         if (0 > connect(sockfd, (struct sockaddr*)&srv_addr, sizeof(srv_addr)))
    7 |- q6 ]& A, u& e0 F
27.         {
    
28.                 perror("connect");
    
29.                 return -1; //exit //pthread_exit
    $ }- L; Z- Z( i7 N3 [
30.         }
    $ l9 ]. T& S+ r9 j* G) a. F
31.         printf("connect..............
    
32. ");
    
33.         char buf[100];
    / d  c0 c6 p4 [5 z
34.         int ret;
    
35.         while (1)
    , w8 ?1 o5 _. W- @- `5 y+ h
36.         {
    
37.                 printf("send: ");
    
38.                 fgets(buf, sizeof(buf), stdin);
    
39.                 ret = write(sockfd, buf, sizeof(buf));
    
40.                 if (ret < 0)
    
41.                 {
    4 ~' H% |% o- z1 v7 g
42.                         perror("write");
    
43.                         break;
    
44.                 }
    
45.                 if (strncmp(buf, "quit", 4) == 0)
    
46.                         break;
    
47.         }
    1 S' \& Y/ B& N/ ^2 S* L$ n
48.         close(sockfd);
    0 _' o6 w. W5 Y/ I
49.         return 0;
    + e; L! p6 y: ]+ s  T0 w
50. }

复制代码

, k  u4 S. s3 I: ?" Q1 \