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

admin

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

' z5 o, k" V; S0 `& E
socket（套接字）：简单来讲，socket就是用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。
+ @6 {" z+ |, }$ ]; ~! q
4 P% _& Q( ^! F4 d
TCP协议
$ p/ t) b; i4 Y$ X  U7 N3 iTCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。
1 E& V2 f" o! V+ f  D. k5 G; h
1 a, Y, z) h" i3 p
关键词：三次握手，可靠，基于字节流。

, B1 D0 H5 h, ]- P
/ L3 K6 P$ M) m5 W$ w. V+ r可能有朋友会问，TCP就这么简单一句话吗？当然不是，TCP作为非常重要的传输协议，细节知识是很多的，细讲起来这一篇文章怕是不够。不过在本篇内容中，我们只需了解他的几个关键词特性，就能很好的理解下面的内容。
! ?$ E3 @- v" |3 l
: B" r- L) [, v( V6 UTCP服务器端和客户端的运行流程

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

# g8 @( t7 o4 m
! J" J! L& s$ n( n1.创建socket
socket是一个结构体，被创建在内核中
) A; O5 P! `8 J, W sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议
% C7 O' e6 Y/ s2 @
8 l, u2 ?8 Y. o7 Z9 u
2.调用bind函数
( D" a# \, Q! J! A 将socket和地址（包括ip、port）绑定。
需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
struct sockaddr_in myaddr; //地址结构体
8 e/ f" j6 v0 c- ^4 R2 j bind函数
bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))
6 b6 j  |6 s& H- D9 {5 A; `4 q+ a7 L
! ]3 _/ C; K/ P" X, x
3 A  G% p- y( h3.listen监听，将接收到的客户端连接放入队列
. T2 `- |3 L( r$ C3 V5 K listen(sockfd,8) //第二个参数是队列长度
7 j2 D! m3 f! J
( e0 V2 \+ U4 W- J+ d
6 d, Y! k" d( F& X, a4.调用accept函数，从队列获取请求，返回socket描 述符
/ a% o, ^* p$ @4 K, G) o. \  如果无请求，将会阻塞，直到获得连接
  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数
' @) x5 t; R3 t
  I. P8 l- J8 }1 P
$ k; f* @, w+ y: h! k: s' v: F5.调用read/write进行双向通信
3 o% E2 c/ v- \) x  ^

& x' T7 [( V- \( y0 \9 ]6.关闭accept返回的socket
6 _( q6 M9 I. f  T3 r  close(scokfd);
) p3 ^; \: H% C



下面放出完整代码
/ a: m1 O: N( P% k$ j

1. /*服务器*/
   
2. #include <stdio.h>
   
3. #include <string.h>
   
4. #include <stdlib.h>
   
5. #include <strings.h>
   
6. #include <sys/types.h>
   4 Q3 ?0 O% r8 X& r( m! {  a
7. #include <sys/socket.h>
   
8. #include <arpa/inet.h>
     w6 l% N! z% h. N( ~: x
9. #include <netinet/in.h>
   
10. int main()
    
11. {
    
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    
13.         if (sockfd < 0)
    % L- ?+ {& j1 P4 D" h
14.         {
    - l2 @9 U4 r$ w7 M1 a% n$ t) b/ n: u
15.                 perror("socket");
    
16.                 return -1;
    + g& d+ Y& S7 a+ f8 E; U
17.         } //创建失败的错误处理
    
18.          printf("socket..............
    & K; u# x5 C5 |; x2 o2 v
19. "); //成功则打印“socket。。。。”
    3 Q" v6 e4 S1 O" I
20.          
    , K1 e+ K' l+ f1 A" O$ E' B. Q
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    
23.          myaddr.sin_family                 = AF_INET; //选择IPV4地址类型
    & y# H: a8 d5 ^5 q3 E/ E5 N" H
24.          myaddr.sin_port                 = htons(8888); //选择端口号
    
25.          myaddr.sin_addr.s_addr         = inet_addr("192.168.3.169"); //选择IP地址
    
26. 
    . s& H6 C% s8 w0 z5 v* F
27. if (0 > bind(sockfd, (struct sockaddr*)&myaddr, sizeof(myaddr)))//绑定套接字
    " Y. e) r, Q( F( I# w$ M! J: w* R
28.          {
    0 k$ v, Z4 i& N- g
29.                  perror("bind");
    # M! M- k! z; H4 o# s: ?1 @
30.                  return -1;
    
31.          }
    ! x6 M; Y! D6 p6 u
32.          printf("bind..........
    5 ?$ v5 Y2 i) {( v0 p
33. ");
    2 h$ m* G. B! Y2 B, D" C9 w
34. 
    
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    
36.          {
    
37.                  perror("listen");
    
38.                  return -1;
    / \1 p/ u6 g) N' x
39.          }
    
40.          printf("listen............
    
41. ");
    , [/ i( g6 ^6 m# P6 G9 X
42.          
    
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
    8 P0 p9 W9 f& [2 c, l/ b. h
44.         if (connfd < 0)
    
45.         {
    1 M# N% p: p! G# e
46.                 perror("accept");
    , ^0 V& ]+ l# C! n
47.                 return -1;
    5 X  k* Z$ i& T) ^, X
48.         }
    + S  w& |+ o$ x( C( {+ y
49.         printf("accept..............
    & t3 s- y4 u! ]! `& k
50. ");
    3 l; N7 @9 F5 w; V: N2 y
51.         char buf[100];//定义一个数组用来存储接收到的数据
    
52.         int ret;
    
53.         while (1)
    
54.         {
    9 J8 }% z2 ~. F& m- t* Z
55.                 memset(buf, 0, sizeof(buf));
    ! Z1 s  R+ \8 k5 J- y% K
56.                 ret = read(connfd, buf, sizeof(buf));
    6 J3 r) `4 D' Y1 E
57.                 if (0 > ret)
    ( z2 c# @4 @% a7 H- |
58.                 {
    
59.                         perror("read");
    * o& h2 K) n. e' i" ]
60.                         break;
    
61.                 }//执行while循环读取数据，当
    ; W3 W% z! B$ R9 g, D9 W
62.                 else if (0 == ret)
    
63.                 {
    
64.                         printf("write close!
    
65. ");
    
66.                         break;
    
67.                 }
    7 f! C8 _8 |( T9 S! ]
68.                 printf("recv: ");
    ! o- J# o/ B! N- I+ G
69.                 fputs(buf, stdout);//打印接收到的数据
    
70.         }
    
71.         close(sockfd);//关闭套接字
    
72.         close(connfd);//断开连接
    
73.         return 0;
    
74. }

复制代码

7 ^. h( N" T5 a, d7 z0 s

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   
2. #include <stdio.h>
   2 R2 B9 ?& _# j4 Q% S4 s. p
3. #include <string.h>
   # S# w9 [4 A1 f
4. #include <stdlib.h>
   4 h: M/ i0 {# E  z" e
5. #include <strings.h>
   
6. #include <sys/types.h>
   ! s  S7 d8 Q1 R0 x$ {
7. #include <sys/socket.h>
   9 c4 m" c# p" W: a! H6 M; _
8. #include <netinet/in.h>
   8 u% A* G$ D- t0 V, U" n; j' X4 n: G
9. #include <arpa/inet.h>
   7 K1 [4 p. T/ l! n9 V1 W
10. int main()
    . h# s* h9 d2 ]5 w/ \* o
11. {
    8 k5 b! S1 |* F8 ]/ F
12. int sockfd;
    
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    
14.         {
    % ^8 U' A* @. H2 z
15.                 perror("socket");
    
16.                 return -1;
    9 k7 l1 D, ?' I( I, B
17.         }
    % I7 q5 W8 \* _0 w
18.         printf("socket...........
    8 M. k/ c3 ^0 M8 s% @$ `; q7 i$ I
19. ");
    
20.         
    
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);
    5 h  L% Y. Y- Y6 y
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)))
    . s# j! [& r$ |$ ^$ r
27.         {
    
28.                 perror("connect");
    
29.                 return -1; //exit //pthread_exit
    ! B2 h- y- N6 h7 [4 l# N: W1 q2 s, u
30.         }
    ) y2 F  u. ]5 R5 `  @$ r
31.         printf("connect..............
    ( H$ @' t" U0 [8 U: M; j" s% v% o& [
32. ");
    " W7 z( u7 s# H! d: ]9 K7 V
33.         char buf[100];
    4 n" x) o- v; N
34.         int ret;
    
35.         while (1)
    . z7 [$ k2 F- x( r3 s
36.         {
    , u9 Y4 [7 [- ?, T+ T1 X3 E
37.                 printf("send: ");
    & ]4 e" M3 b# q5 g
38.                 fgets(buf, sizeof(buf), stdin);
    
39.                 ret = write(sockfd, buf, sizeof(buf));
    1 h. S- \8 o# I5 E7 m0 T+ C
40.                 if (ret < 0)
    - o: k' [  g2 b/ I5 O/ X4 |! }
41.                 {
    $ ?1 }: \  K! v) d) V, a  k4 B, e) B
42.                         perror("write");
    
43.                         break;
    7 Z7 L* D& j: z) |2 B; N2 D) o
44.                 }
    
45.                 if (strncmp(buf, "quit", 4) == 0)
    
46.                         break;
    1 w2 M7 w5 D: f; W4 n
47.         }
    * r! k, e' W; \( Y1 M! \6 _  o
48.         close(sockfd);
    9 V/ }% o/ [: W  {3 L* q' p
49.         return 0;
    & r+ r: I3 I5 N# b2 S+ ^: F
50. }

复制代码

) }  r/ J. F7 @5 J! z1 c! Y