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

admin

如果想要自己写一个服务器和客户端，我们需要掌握一定的网络编程技术，个人认为，网络编程中最关键的就是这个东西——socket（套接字）。
* f. T# M# U0 p) K' U+ y* v
: @  u( j- h/ U
% n. \/ p* I/ s; B# X0 F% dsocket（套接字）：简单来讲，socket就是用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。
" m7 D- _9 x( [6 ^; P1 F6 d  s
, K0 D8 b$ f3 U, n
" k5 s8 X) }: W. j  STCP协议
TCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。
- Z! Q8 [. Q- L/ `8 W% R: |
  N6 P- x  b" C+ p# F- J6 I  i4 ^) ^
关键词：三次握手，可靠，基于字节流。
+ P+ [& K* w% `! u: H2 G! s

* K, \' S) ]1 ^可能有朋友会问，TCP就这么简单一句话吗？当然不是，TCP作为非常重要的传输协议，细节知识是很多的，细讲起来这一篇文章怕是不够。不过在本篇内容中，我们只需了解他的几个关键词特性，就能很好的理解下面的内容。

9 V9 \% P, k! {  f5 m9 TTCP服务器端和客户端的运行流程
. E" q4 b" x4 W8 y- D/ H
0 T; Z/ M& r6 t3 N
如图，这是一个完整的TCP服务器——客户端的运行流程图，其实我个人认为程序啊，不管哪个语言都是一样，核心就在于算法的设计和函数的调用。那么图中的函数都是什么意思呢？
8 X4 W7 w$ t0 X& @
2 j0 W* F! y7 s# I2 e
! ^' K8 F+ c2 o4 ~" n1.创建socket
socket是一个结构体，被创建在内核中
sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议


2.调用bind函数
将socket和地址（包括ip、port）绑定。
" c8 v' u) `; F  e  T 需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
struct sockaddr_in myaddr; //地址结构体
. c5 n( s  P4 S; r2 t bind函数
bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))

' f6 F* k4 ?& p) d/ Z
& L6 j; o4 G' T) z* B- o  }3.listen监听，将接收到的客户端连接放入队列
0 Y8 y" q0 u  V6 A; M% J) c listen(sockfd,8) //第二个参数是队列长度
+ ?, x7 P8 o4 Q" j& c$ ^
8 _/ }  q$ l5 \( \3 J
. R' A/ y( `6 w: w4.调用accept函数，从队列获取请求，返回socket描 述符
  如果无请求，将会阻塞，直到获得连接
0 d) M1 z2 ?! k0 `; I  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数
+ O1 N4 K: _. @2 E& B

% Q7 ^: d+ V* E" ?9 C, P. S( `5.调用read/write进行双向通信
: U' f: y  t$ N& s1 a, c) @* \

6.关闭accept返回的socket
0 s7 \* P$ w, w& l( a; R! n  close(scokfd);
1 p4 O/ f6 a! @4 L
  W- f1 Q# H- X& F
2 k9 d: W5 u* L" M5 g  B  Z; h8 g
% G. B) C( J4 K- n/ y7 N
) T  G1 }4 t) Q# I下面放出完整代码
8 {5 P1 p5 r. [+ B4 p
6 ?  H% o3 r2 w! N) N. O

1. /*服务器*/
   ; O5 A+ b7 t7 u3 n. ^' K
2. #include <stdio.h>
   8 m! k* y* q9 h
3. #include <string.h>
   ( h7 u6 d, i! k0 ]
4. #include <stdlib.h>
   * X: ^+ b5 `" I! C1 f' `) L: W( R
5. #include <strings.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. #include <arpa/inet.h>
   
9. #include <netinet/in.h>
   
10. int main()
    ' X0 u& X5 p' g! U  U( V9 e) F* V
11. {
    
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    ' S' j$ P! l) v5 Q/ c. t6 j
13.         if (sockfd < 0)
    
14.         {
    ( f9 H( K5 D7 Y5 Y
15.                 perror("socket");
    
16.                 return -1;
    
17.         } //创建失败的错误处理
    / D, t! g1 T& [; ]
18.          printf("socket..............
    
19. "); //成功则打印“socket。。。。”
    3 G1 |; f" ?) W
20.          
    
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    " h& z7 `4 G/ B9 L
23.          myaddr.sin_family                 = AF_INET; //选择IPV4地址类型
    
24.          myaddr.sin_port                 = htons(8888); //选择端口号
    
25.          myaddr.sin_addr.s_addr         = inet_addr("192.168.3.169"); //选择IP地址
    2 E& k9 x6 Q- s) W/ I  t" }
26. 
    
27. if (0 > bind(sockfd, (struct sockaddr*)&myaddr, sizeof(myaddr)))//绑定套接字
    $ ~% Y  R, _; V& a$ H1 h4 }4 Y3 B
28.          {
    9 {6 ?0 D/ s0 \9 B5 J: C! B
29.                  perror("bind");
    / F" a% U! l+ e( N
30.                  return -1;
    
31.          }
    ( G& y6 u+ Q' h# j; i" l' {
32.          printf("bind..........
    
33. ");
    
34. 
    ; h* b$ c- [$ c9 P% S
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    
36.          {
    
37.                  perror("listen");
    
38.                  return -1;
    1 L' |0 m+ K) x8 x, n. d
39.          }
    
40.          printf("listen............
    5 L. `8 t/ r$ t0 A
41. ");
    ' Q% r, d$ [0 \7 t
42.          
    " w9 q+ P2 Y! U, [. e* J
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
    
44.         if (connfd < 0)
    " r: y  O) O# w- v
45.         {
    
46.                 perror("accept");
    + q* {& O+ a9 N7 Z+ @+ r7 I$ H  t
47.                 return -1;
    8 Z& F& E! K1 o) D+ S2 p# p$ V
48.         }
    , Q( D# L2 g! M# f
49.         printf("accept..............
    . q9 `" L9 |! g4 t; B6 K0 t
50. ");
    
51.         char buf[100];//定义一个数组用来存储接收到的数据
    
52.         int ret;
    ! _: X% l$ B% Q" D: s% v
53.         while (1)
    : `& h" V# f2 ]% }
54.         {
    
55.                 memset(buf, 0, sizeof(buf));
    ( M( ]0 F# j. q, Z' s
56.                 ret = read(connfd, buf, sizeof(buf));
    ( }6 f2 R' D! B# Y+ S  j7 q  N
57.                 if (0 > ret)
    & M2 {+ d! F0 K: [; y& Y- a/ L) T
58.                 {
    ; q6 L$ }$ j9 ^* f* d
59.                         perror("read");
    2 X* l. w2 Q# V% ^2 H, N4 X. l
60.                         break;
      e# }$ M. C: ]7 ^
61.                 }//执行while循环读取数据，当
    7 P" i, h' f+ s7 j  b2 J, v  x
62.                 else if (0 == ret)
    + y4 Z7 F; S$ R$ l
63.                 {
    
64.                         printf("write close!
    
65. ");
    
66.                         break;
    # ~) Z" W/ [8 k$ c; N* X  f
67.                 }
    
68.                 printf("recv: ");
    + ]2 Q" d# ^0 k) p, n2 N
69.                 fputs(buf, stdout);//打印接收到的数据
    
70.         }
    
71.         close(sockfd);//关闭套接字
    
72.         close(connfd);//断开连接
    
73.         return 0;
    " Q5 u+ D' v6 k# {8 f
74. }

复制代码

% p; e) e; n0 B. L
1 E' K. x$ f# ~' `

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   5 I. {+ ?$ j8 T# v& j5 k
2. #include <stdio.h>
   * k# U& L$ `5 n4 k1 o
3. #include <string.h>
   6 ]( J. ^# W1 M$ \# }& S: F
4. #include <stdlib.h>
   " B9 s9 K$ ]$ f5 [8 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()
    
11. {
    
12. int sockfd;
    
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    
14.         {
    
15.                 perror("socket");
      n0 ~7 X) e; h. @) y3 I
16.                 return -1;
    8 \7 ?# f1 `1 s& T% l1 ^2 U
17.         }
    & ?% _# g* p. K( c4 l
18.         printf("socket...........
    
19. ");
    
20.         
    
21.         struct sockaddr_in srv_addr;
    
22.         memset(&srv_addr, 0, sizeof(srv_addr));
    5 a& \, w( Q8 E; J9 y
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)))
    
27.         {
    % b1 R( W2 r* `* ]
28.                 perror("connect");
    0 }2 c( h$ T$ k
29.                 return -1; //exit //pthread_exit
    
30.         }
    $ M3 K' d3 \& C5 Y' Z  L
31.         printf("connect..............
    0 w- `! o" i, G
32. ");
    4 B6 _( A! [7 N" \6 k/ M
33.         char buf[100];
    
34.         int ret;
    ' P  G! r0 o/ D6 }/ v
35.         while (1)
    
36.         {
      c1 m1 p! h* S6 L9 P: v# {( e
37.                 printf("send: ");
    $ M6 I1 f8 e+ s/ K
38.                 fgets(buf, sizeof(buf), stdin);
    6 s8 I- ?! l5 [- g6 G) R; N$ g" z
39.                 ret = write(sockfd, buf, sizeof(buf));
    
40.                 if (ret < 0)
    
41.                 {
    0 _! `6 ^7 I1 d
42.                         perror("write");
    
43.                         break;
      \" H$ x% B! S
44.                 }
    
45.                 if (strncmp(buf, "quit", 4) == 0)
    % r0 Z" V. U- G2 W
46.                         break;
    
47.         }
    
48.         close(sockfd);
    
49.         return 0;
    & d, U+ I6 E1 M) x
50. }

复制代码

( I6 `$ i; l3 k  o/ r: N4 U