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

admin

如果想要自己写一个服务器和客户端，我们需要掌握一定的网络编程技术，个人认为，网络编程中最关键的就是这个东西——socket（套接字）。
& k- p7 ?3 J$ @. v8 x
, W. K1 L* K1 Z7 Z4 H( [/ H2 I
socket（套接字）：简单来讲，socket就是用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。


# k. ?* K- C; d+ W" CTCP协议
TCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。
$ C  _# k, b3 m& ^9 u: j: s: ~( Y

关键词：三次握手，可靠，基于字节流。
, g0 @4 S! F- m
5 j' t" \' {, x
* R. L, k- @; |# E5 f" w% e0 ^可能有朋友会问，TCP就这么简单一句话吗？当然不是，TCP作为非常重要的传输协议，细节知识是很多的，细讲起来这一篇文章怕是不够。不过在本篇内容中，我们只需了解他的几个关键词特性，就能很好的理解下面的内容。

: F; d+ t, \& }, D( k) STCP服务器端和客户端的运行流程


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

! k) j3 l  l9 ]" G! A2 }
1.创建socket
socket是一个结构体，被创建在内核中
sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议
& {5 y; P: M8 K2 A$ _

2.调用bind函数
将socket和地址（包括ip、port）绑定。
- C0 D# a! O; g2 v! T 需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
struct sockaddr_in myaddr; //地址结构体
bind函数
bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))
/ O- V. n: r3 ?/ b. o. E
2 i8 }) p2 k" Z7 z! E3 D+ t
3.listen监听，将接收到的客户端连接放入队列
listen(sockfd,8) //第二个参数是队列长度


4.调用accept函数，从队列获取请求，返回socket描 述符
  如果无请求，将会阻塞，直到获得连接
8 U5 v  A8 ^. ]; g; w  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数


+ Y+ n4 ^2 `; n( ?# H4 v$ |5.调用read/write进行双向通信


) _& M" O  X2 T& D* k: s& W6.关闭accept返回的socket
  close(scokfd);
8 b) v, e/ E; i# F  F


& ~6 n5 t7 X) }+ Q% e
下面放出完整代码
8 s$ R& f7 b$ s* g0 V/ Z, z; x  G' W# L
# O/ F2 c8 v. S+ O7 K4 D. N/ y

1. /*服务器*/
   & F  y& [# I* X; V4 s% b
2. #include <stdio.h>
   7 i/ w! c# o  @' G4 |+ p" g, ]- d6 g
3. #include <string.h>
   8 O$ O& [  g9 P5 R
4. #include <stdlib.h>
   ! @: a- A: W. c+ S0 X+ e5 e7 o
5. #include <strings.h>
   % W5 R9 i# Z& n$ `
6. #include <sys/types.h>
   ) v( J$ r; e! y/ o
7. #include <sys/socket.h>
   
8. #include <arpa/inet.h>
   9 v$ }0 I/ F5 k) L! W$ c9 e
9. #include <netinet/in.h>
   
10. int main()
    5 @4 y& C5 {7 f
11. {
    
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    
13.         if (sockfd < 0)
    " f6 n5 M- m8 s$ Z( ]# n) O3 o+ T
14.         {
    , R# t2 U0 b. ]" J, b
15.                 perror("socket");
    # h1 y* k, o$ ?% N- `' X
16.                 return -1;
    ) Z4 X0 Q2 A7 k
17.         } //创建失败的错误处理
    # U( n7 ~9 q) |$ ]2 }
18.          printf("socket..............
    2 q6 R! s5 T0 V8 g- x
19. "); //成功则打印“socket。。。。”
    
20.          
    
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    
23.          myaddr.sin_family                 = AF_INET; //选择IPV4地址类型
    
24.          myaddr.sin_port                 = htons(8888); //选择端口号
    * c. ~/ K/ K/ X4 O
25.          myaddr.sin_addr.s_addr         = inet_addr("192.168.3.169"); //选择IP地址
    ' D. b9 s; p/ `- Q" [# m8 X+ q" U
26. 
    
27. if (0 > bind(sockfd, (struct sockaddr*)&myaddr, sizeof(myaddr)))//绑定套接字
    3 Y$ d& _: j3 {# C: e/ z6 g( U
28.          {
    9 a! v' O+ k# t( d
29.                  perror("bind");
    $ w8 n' {9 T& u0 _! T
30.                  return -1;
      a! i% f; L8 ^. @, o
31.          }
    
32.          printf("bind..........
    # ^* F% l6 y5 W( M$ _5 ~
33. ");
    
34. 
    
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    
36.          {
    " O' o+ g0 ], I! g
37.                  perror("listen");
    " u% s) X* \9 K9 ], t5 P/ K
38.                  return -1;
    . A" l/ X; |9 g4 ]2 X( N
39.          }
    
40.          printf("listen............
    & c+ n8 C# z, [7 ^/ T
41. ");
    + }$ ^" D' H' C- |8 z$ ?" @) d
42.          
    - e' ]6 ]. c: S1 m- a6 N
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
    
44.         if (connfd < 0)
    * ~* \8 ^# z/ @
45.         {
    # T) R7 z) {( x$ u7 |2 r3 t
46.                 perror("accept");
    ! g- I3 g' U2 {9 g9 f1 J
47.                 return -1;
    . k0 y4 g) o, I
48.         }
    # t" R0 ?7 w8 }0 p
49.         printf("accept..............
    
50. ");
    . O2 y# K: T: j
51.         char buf[100];//定义一个数组用来存储接收到的数据
    ) [. a" `5 n2 S0 z6 n( x
52.         int ret;
    5 y+ e8 ~% _5 S" y
53.         while (1)
    
54.         {
    
55.                 memset(buf, 0, sizeof(buf));
    3 c- p! b7 W' d/ E- ?$ t5 @
56.                 ret = read(connfd, buf, sizeof(buf));
    1 [: u) \$ V  n# I" D
57.                 if (0 > ret)
    + V' H( O$ f' C1 x7 M
58.                 {
    9 R9 E% r7 C! O5 f8 e  Q, D
59.                         perror("read");
    % K, C; `# N. a1 @5 e/ w
60.                         break;
    3 }1 |# b8 X4 X
61.                 }//执行while循环读取数据，当
    5 E( ?6 j& ?$ Y. H6 F: E) @, v
62.                 else if (0 == ret)
    - D; J  E! u4 d! g2 f: B0 k; n
63.                 {
    
64.                         printf("write close!
    
65. ");
    
66.                         break;
    
67.                 }
    
68.                 printf("recv: ");
    + `) {) ^9 D' V0 l4 \# X9 v# [
69.                 fputs(buf, stdout);//打印接收到的数据
    
70.         }
    
71.         close(sockfd);//关闭套接字
    % f& J7 V$ S, j+ G8 X
72.         close(connfd);//断开连接
    
73.         return 0;
    
74. }

复制代码

8 n5 v$ p) I1 @% ~

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   - f9 Z3 `; e5 k1 f. O
2. #include <stdio.h>
   ! V" F" K0 n* _( L& J
3. #include <string.h>
   
4. #include <stdlib.h>
   : s/ _' Z8 T) E
5. #include <strings.h>
   - D& N- ?8 @. M& m0 z
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   8 F* J: V1 p6 B/ ^, P
10. int main()
    
11. {
    
12. int sockfd;
    
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    
14.         {
    5 r1 B) D4 p, s: A2 s
15.                 perror("socket");
    
16.                 return -1;
    7 y+ o; z/ m1 U0 H* `! `& R
17.         }
    
18.         printf("socket...........
    
19. ");
    3 ?5 h7 `6 f: e
20.         
    
21.         struct sockaddr_in srv_addr;
    
22.         memset(&srv_addr, 0, sizeof(srv_addr));
    0 k7 }4 s; f' Q% [/ `
23.         srv_addr.sin_family                 = AF_INET;
    ! \% R0 N- \* X0 n
24.         srv_addr.sin_port                         = htons(8888);
    $ u% G4 e' t" T& W( ^: \3 d6 c
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)))
    7 n7 Z$ E3 w3 t) I6 U
27.         {
    
28.                 perror("connect");
    
29.                 return -1; //exit //pthread_exit
    9 b& Y) ^- c, \7 `* Q. L7 \
30.         }
    
31.         printf("connect..............
    ) A7 A8 _  U/ E$ F
32. ");
    
33.         char buf[100];
    
34.         int ret;
      ^* y0 U; _" F% g
35.         while (1)
    
36.         {
    
37.                 printf("send: ");
    ! R2 v0 W# s, j% t# V5 c
38.                 fgets(buf, sizeof(buf), stdin);
    
39.                 ret = write(sockfd, buf, sizeof(buf));
    3 [( U) S- w1 ]+ q) }+ v+ u1 r
40.                 if (ret < 0)
    - M5 R% A& }/ y+ r! j
41.                 {
    ) a9 b4 ~7 ]" [; i. Z
42.                         perror("write");
    
43.                         break;
    & }' Q+ j! l) R% D6 O3 Z: f2 r9 o% `
44.                 }
    
45.                 if (strncmp(buf, "quit", 4) == 0)
    
46.                         break;
    
47.         }
      ^! D/ I9 C& f7 Q. l% S
48.         close(sockfd);
    
49.         return 0;
    
50. }

复制代码

- u4 v( d% o5 Z6 Y