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

admin

如果想要自己写一个服务器和客户端，我们需要掌握一定的网络编程技术，个人认为，网络编程中最关键的就是这个东西——socket（套接字）。
" @8 e' m" \; n/ B$ {

socket（套接字）：简单来讲，socket就是用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。

/ R( ~0 G1 r. @3 K1 Q% v/ H
TCP协议
TCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。

% Q1 M- _7 F! z6 [( w
关键词：三次握手，可靠，基于字节流。
8 t! c; Z. A5 C6 E
, ?3 K0 V7 S7 _3 q. u/ _& i% T( c- x
可能有朋友会问，TCP就这么简单一句话吗？当然不是，TCP作为非常重要的传输协议，细节知识是很多的，细讲起来这一篇文章怕是不够。不过在本篇内容中，我们只需了解他的几个关键词特性，就能很好的理解下面的内容。
! u4 Q' l6 ]3 e
TCP服务器端和客户端的运行流程
  ^8 v, q8 ?, y8 ]% `6 o

, M, ?: t" _; I9 A# @2 p# m8 k如图，这是一个完整的TCP服务器——客户端的运行流程图，其实我个人认为程序啊，不管哪个语言都是一样，核心就在于算法的设计和函数的调用。那么图中的函数都是什么意思呢？


1.创建socket
socket是一个结构体，被创建在内核中
sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议
) ?# b5 Z3 @- q2 m$ {

; ^# G: [: ~5 b) o! C. u1 l6 Q2.调用bind函数
  _4 s8 d4 ]  ]# q 将socket和地址（包括ip、port）绑定。
需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
struct sockaddr_in myaddr; //地址结构体
bind函数
bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))

0 l2 n- @* R$ M  h% G) f4 \
+ q, L* L1 y. h: _' |+ Z4 F- M3.listen监听，将接收到的客户端连接放入队列
listen(sockfd,8) //第二个参数是队列长度
- h, J6 m4 O8 B7 X

5 Q' B# c, e8 p5 Z4.调用accept函数，从队列获取请求，返回socket描 述符
  如果无请求，将会阻塞，直到获得连接
  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数


5.调用read/write进行双向通信

+ v% S  j! T0 \! a1 C
6.关闭accept返回的socket
  {8 [9 K( y  i  close(scokfd);
/ U- Z& P% Q9 T+ C
# ]9 }, [& F, }$ u3 M8 @, ]
5 E+ v2 D4 F" f: \2 ~, R

4 F" y: ]) u. I7 {- i' X; o下面放出完整代码

1. /*服务器*/
   ! I0 J1 q+ @" H; }! V
2. #include <stdio.h>
   
3. #include <string.h>
     w. L- N* {! g. a
4. #include <stdlib.h>
   
5. #include <strings.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   - ~  q0 X2 s* y+ @% S1 K
8. #include <arpa/inet.h>
   # S( m/ u! U- [4 @4 e2 a, t4 ]: `
9. #include <netinet/in.h>
   - ^7 E8 R3 w, t$ |  K; M4 t
10. int main()
      l" S6 R, ~8 R, x; c8 {  F
11. {
    0 H/ J$ ]5 O6 ^
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    
13.         if (sockfd < 0)
    ' }# r( q. s  c$ y, ?
14.         {
    5 i& q) J; r/ P" b: ]+ |
15.                 perror("socket");
    2 ?* x% A7 b) N0 Y4 y! |! y! j; [
16.                 return -1;
    
17.         } //创建失败的错误处理
    # g1 D0 W7 V" X4 J- I0 v
18.          printf("socket..............
    
19. "); //成功则打印“socket。。。。”
    ' s; I2 \8 F2 r5 p
20.          
    : j9 T4 i( M" U2 O0 }
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    : X3 i# f. w. w  V$ P1 l9 `8 }. q* L
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    
23.          myaddr.sin_family                 = AF_INET; //选择IPV4地址类型
    
24.          myaddr.sin_port                 = htons(8888); //选择端口号
    - U  n$ y6 b7 N# \$ ]. {
25.          myaddr.sin_addr.s_addr         = inet_addr("192.168.3.169"); //选择IP地址
    ) ^/ V2 A) S6 `- y
26. 
    & Y9 N- j, Y4 a# f0 X6 S
27. if (0 > bind(sockfd, (struct sockaddr*)&myaddr, sizeof(myaddr)))//绑定套接字
    
28.          {
    " @9 x, g* z$ j; Z* d
29.                  perror("bind");
    ' D: Q) I. X) M4 g  l# Y
30.                  return -1;
    5 W% C" Z% J6 p/ d  y- O% i
31.          }
    + A$ G; j4 j* M1 J5 C
32.          printf("bind..........
    
33. ");
    
34. 
    
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    
36.          {
    4 q5 p2 d1 x7 g1 P) w
37.                  perror("listen");
    ) J# n9 O  |/ W( c$ w' y3 \
38.                  return -1;
    
39.          }
    
40.          printf("listen............
    
41. ");
    5 m/ {% J+ b- {8 b
42.          
    . I( l/ i5 ^3 x) V- C$ H( y% x* F
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
    
44.         if (connfd < 0)
    
45.         {
    
46.                 perror("accept");
    2 i( g. e' Y) ]  M, g. _% x
47.                 return -1;
    
48.         }
    2 @1 w9 [  o) U8 S
49.         printf("accept..............
    
50. ");
    
51.         char buf[100];//定义一个数组用来存储接收到的数据
    
52.         int ret;
    4 p. [$ p# C% V
53.         while (1)
    
54.         {
    5 V, u/ B4 V; [* Y, n0 _- v5 h
55.                 memset(buf, 0, sizeof(buf));
    
56.                 ret = read(connfd, buf, sizeof(buf));
    8 f$ x4 o4 [2 p$ r5 b. y, O
57.                 if (0 > ret)
    , |1 ?' u; u) K
58.                 {
    
59.                         perror("read");
    , H- O# a2 [% J( k" \
60.                         break;
    3 i$ K  p, t: L+ \3 g+ t
61.                 }//执行while循环读取数据，当
    4 e- q' g; ]( Z' j1 \: r* `! G# n
62.                 else if (0 == ret)
    
63.                 {
    
64.                         printf("write close!
    
65. ");
    8 z) |4 ]2 A- J4 s
66.                         break;
    ! R( x; u6 {/ Z2 H! W( ]; T% k
67.                 }
    
68.                 printf("recv: ");
    3 Q, d9 a3 L% J- [* m6 t* V
69.                 fputs(buf, stdout);//打印接收到的数据
    7 \  K2 Q0 w9 [
70.         }
    / m% [1 v  s* d! k! v
71.         close(sockfd);//关闭套接字
    
72.         close(connfd);//断开连接
    
73.         return 0;
    8 x# s' I/ K0 Z, T3 r7 i
74. }

复制代码

, b1 F4 q7 P# k8 P

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   ; V" ~" L0 A; h6 Z
2. #include <stdio.h>
   
3. #include <string.h>
   
4. #include <stdlib.h>
   ! i1 F" p! w5 T. I5 M8 r4 M
5. #include <strings.h>
   % z/ t7 K1 x% ?8 [4 X( A
6. #include <sys/types.h>
   9 k0 G" \. p; v4 ?. n& E' @+ C
7. #include <sys/socket.h>
   ' t  g# }  U2 |' y8 F3 P6 _; `
8. #include <netinet/in.h>
   ; a( P+ i& J2 v
9. #include <arpa/inet.h>
   
10. int main()
    
11. {
    ' ?0 h9 D. Y; a! h1 J
12. int sockfd;
    
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    
14.         {
    
15.                 perror("socket");
    
16.                 return -1;
    
17.         }
    
18.         printf("socket...........
    ) W" A( h' o- H( h3 c5 W! C2 Z8 a8 ~: l
19. ");
    
20.         
    3 H7 S( m* ]/ U! t4 P1 G, c
21.         struct sockaddr_in srv_addr;
    
22.         memset(&srv_addr, 0, sizeof(srv_addr));
    
23.         srv_addr.sin_family                 = AF_INET;
    + M  \- U. M2 ]* z; c3 A4 _
24.         srv_addr.sin_port                         = htons(8888);
      Q# ]: s( k  \+ K: i' j
25.         srv_addr.sin_addr.s_addr         = inet_addr("192.168.3.169");
    % l3 ~" f6 j: g0 K
26.         if (0 > connect(sockfd, (struct sockaddr*)&srv_addr, sizeof(srv_addr)))
    
27.         {
    
28.                 perror("connect");
    7 e% `8 S  A# \% O
29.                 return -1; //exit //pthread_exit
    ) p% q) J) I( Q4 [8 {
30.         }
    
31.         printf("connect..............
    3 ^- o7 A4 N0 Z- N, N$ f0 T" `- w( Y
32. ");
    # U* H! I0 E5 R5 v# O
33.         char buf[100];
    6 q- Q+ `/ s5 J7 a9 l1 ]( ^
34.         int ret;
    
35.         while (1)
    
36.         {
    
37.                 printf("send: ");
    
38.                 fgets(buf, sizeof(buf), stdin);
    
39.                 ret = write(sockfd, buf, sizeof(buf));
    
40.                 if (ret < 0)
    
41.                 {
    
42.                         perror("write");
    1 p% I+ _4 f/ \% m# h6 \5 U
43.                         break;
    
44.                 }
    
45.                 if (strncmp(buf, "quit", 4) == 0)
    2 D7 m, z' ~; o& l
46.                         break;
    
47.         }
    " P# W. z# L! o, T" ~* ^9 ^
48.         close(sockfd);
    # V& t0 W0 ~5 l# I2 U2 B" z$ x( O
49.         return 0;
    
50. }

复制代码

( _) ^9 M+ |% n7 F