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

admin

如果想要自己写一个服务器和客户端，我们需要掌握一定的网络编程技术，个人认为，网络编程中最关键的就是这个东西——socket（套接字）。
; A( l5 @+ g, _; R' y) w5 e1 C+ a

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

# I0 T# |8 `/ ~4 |6 c" F4 Z, R1 e
' U- k. q* l, e5 Q2 W, `' _TCP协议
TCP协议：是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。


关键词：三次握手，可靠，基于字节流。


可能有朋友会问，TCP就这么简单一句话吗？当然不是，TCP作为非常重要的传输协议，细节知识是很多的，细讲起来这一篇文章怕是不够。不过在本篇内容中，我们只需了解他的几个关键词特性，就能很好的理解下面的内容。
5 Y; S) P$ D8 k6 d6 l* b0 o8 J
TCP服务器端和客户端的运行流程

7 E# L" H# j4 ?2 [% `9 j, ^; }
: I, K% S# K+ @; Q2 x3 a如图，这是一个完整的TCP服务器——客户端的运行流程图，其实我个人认为程序啊，不管哪个语言都是一样，核心就在于算法的设计和函数的调用。那么图中的函数都是什么意思呢？
: J  A" u1 ^9 E$ y9 j+ S! m$ I

0 |1 v" j7 \) g/ h1 b1.创建socket
socket是一个结构体，被创建在内核中
7 U' i2 K$ S6 p4 _3 M sockfd=socket(AF_INET,SOCK_STREAM,0); //AF_INT:ipv4, SOCK_STREAM:tcp协议
5 B/ A# @+ T- w) x$ Y' c* m

. l' l  S0 H. m2.调用bind函数
7 k& w  A5 K/ C3 R1 M5 S8 D- D 将socket和地址（包括ip、port）绑定。
需要定义一个结构体地址，以便于将port的主机字节序转化成网络字节序
5 x) X3 X( {2 ]5 [7 O' G+ W, s struct sockaddr_in myaddr; //地址结构体
; s6 }- j5 i0 ?! z bind函数
bind(sockfd,(struct sockaddr*)&myaddr,sizeof(serveraddr))


3.listen监听，将接收到的客户端连接放入队列
7 n8 L7 g( M, j  r4 | listen(sockfd,8) //第二个参数是队列长度
4 M. P. }4 U: O  b' U: u

4.调用accept函数，从队列获取请求，返回socket描 述符
  如果无请求，将会阻塞，直到获得连接
" U# t% a" z! u( v) E( @, B1 i  K6 D  int fd=accept(sockfd, NULL，NULL);//这边采用默认参数

  F$ e, E! {# U; L. n6 U/ X9 V! p
5.调用read/write进行双向通信
) C6 s& x: @  E5 P" V/ z' m' Q

+ \' g0 T2 m1 G; `& L6.关闭accept返回的socket
0 l( k. ?; D, \1 P5 z  close(scokfd);
4 f6 @6 ?9 o5 b



* C' `, Q2 \  _0 w$ H& [3 ~. P4 N下面放出完整代码

6 E! L* M4 @5 c/ o$ D

1. /*服务器*/
   6 q6 ~  f5 g/ c% Z
2. #include <stdio.h>
   * E% y% ?/ s! @" Q0 M. V
3. #include <string.h>
   
4. #include <stdlib.h>
   4 _/ K7 a! v% }  e
5. #include <strings.h>
   $ l, g$ R2 J5 T/ c7 q+ H
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   ) v9 Z, M3 }9 D* v, o" t
8. #include <arpa/inet.h>
   
9. #include <netinet/in.h>
   ' y" B: T8 P+ x1 u8 D; W
10. int main()
    1 ~0 O' L; [  F9 m% X  I0 T
11. {
    7 J0 O2 j) O- s" k+ U+ A  S- t
12.         int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    
13.         if (sockfd < 0)
    & x+ }4 b5 T# p5 j
14.         {
    
15.                 perror("socket");
    
16.                 return -1;
    
17.         } //创建失败的错误处理
    
18.          printf("socket..............
    
19. "); //成功则打印“socket。。。。”
    
20.          
    
21.          struct sockaddr_in myaddr; //创建“我的地址”结构体
    2 Y" H0 H) i# \+ H
22.          memset(&myaddr, 0, sizeof(myaddr)); //对内存清零（保险起见）
    ( h1 F8 J8 B( c
23.          myaddr.sin_family                 = AF_INET; //选择IPV4地址类型
    " w- L$ z' o, U2 L
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)))//绑定套接字
    9 S# M. ^# ?/ e6 c6 v% o) G! v
28.          {
    
29.                  perror("bind");
    9 K* W/ ]: W+ C, m, [
30.                  return -1;
    / l; L7 u) ^0 C! I/ c
31.          }
    ( u/ ^. b, L# V
32.          printf("bind..........
    
33. ");
    5 H; ]4 y' V7 d( W
34. 
    
35.          if (0 > listen(sockfd, 8))//调用listen对指定端口进行监听
    ' j% w! [: d0 e
36.          {
    + k% z: e* S2 r3 J6 Q  T% E2 s7 n
37.                  perror("listen");
    
38.                  return -1;
    
39.          }
    
40.          printf("listen............
    
41. ");
    
42.          
    
43.         int connfd = accept(sockfd, NULL, NULL);//使用accept从消息队列中获取请求
    2 C" R, P1 s  q$ ]" \& s4 E! K
44.         if (connfd < 0)
    ( F% ]* s  t( b# |8 s( X
45.         {
    ( v  j# K$ L7 d8 ]
46.                 perror("accept");
    1 R: {) Q. ]! p& H. ?$ v
47.                 return -1;
    , |0 W7 B% f* C( o, K  @9 a* A2 [
48.         }
    ) q9 U! q: M9 R  W
49.         printf("accept..............
    / ~* Z& L" z" x0 B  m% E7 [( t9 H
50. ");
    , M8 F- x% U' @" {6 J$ T1 M* v
51.         char buf[100];//定义一个数组用来存储接收到的数据
    
52.         int ret;
    ' ~! F* e. `( O  S
53.         while (1)
    
54.         {
    
55.                 memset(buf, 0, sizeof(buf));
    
56.                 ret = read(connfd, buf, sizeof(buf));
    - K9 e6 |! d0 \: q* Z- l8 I+ s, |
57.                 if (0 > ret)
    * K5 J5 S! G. \9 Z" s7 l7 u
58.                 {
    " f7 L* g$ Q  }& \
59.                         perror("read");
    
60.                         break;
    
61.                 }//执行while循环读取数据，当
    2 V( e% ^, N- D  p3 [, x9 ]
62.                 else if (0 == ret)
    
63.                 {
    ! `6 M* ?* _. G/ [/ k9 u8 i+ d
64.                         printf("write close!
    / r& ^( N, D4 b, L7 K5 f2 o
65. ");
    4 @/ F( t$ w+ R7 U
66.                         break;
    - Q/ l) |! k" c" i4 [3 `0 u
67.                 }
    4 }+ z( n6 _. I+ S' q( e2 {  S
68.                 printf("recv: ");
    . h5 z3 t4 h: \9 Y' q3 x
69.                 fputs(buf, stdout);//打印接收到的数据
    
70.         }
    
71.         close(sockfd);//关闭套接字
    * e+ v& n1 i; p
72.         close(connfd);//断开连接
    
73.         return 0;
    $ R) W" ^6 [/ L; O" A4 D
74. }

复制代码

& R7 @0 S; z1 o- H) |, h0 w

1. /*客户端*/（具体功能和服务器一样，所以不再加注释）
   
2. #include <stdio.h>
   
3. #include <string.h>
   $ p6 Z  J0 e- P# y
4. #include <stdlib.h>
   - ?" r( s5 a& w) ]0 A  }
5. #include <strings.h>
   - e1 X) r2 x# g6 J/ T, c- {  j
6. #include <sys/types.h>
   ( `- j  @6 e% v5 p! X( b
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   + a5 k1 q) S' v; a& X1 v+ \
9. #include <arpa/inet.h>
   8 o, Z' S! I4 Q1 C0 W! V0 x9 |
10. int main()
    
11. {
    
12. int sockfd;
    % \) C( s7 G: E7 u3 T
13.         if (0 > (sockfd = socket(AF_INET, SOCK_STREAM, 0)))
    . b) R, E- u5 u6 e* x# E! m
14.         {
    ! m$ F4 t- f/ H' M4 T* M6 e
15.                 perror("socket");
    : G. i+ F  v6 x- S# O2 x, q
16.                 return -1;
      \. ?# q1 M( P) l5 P- D3 S' H
17.         }
    
18.         printf("socket...........
    $ z2 ]9 d: K/ z, u
19. ");
    3 g2 l. ~6 H: ]; e; U
20.         
    ; v8 \1 M! o3 X
21.         struct sockaddr_in srv_addr;
    / F: k6 Y/ P, H  \% p$ F2 r
22.         memset(&srv_addr, 0, sizeof(srv_addr));
    
23.         srv_addr.sin_family                 = AF_INET;
    0 W  `0 m+ J$ G$ O
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.         {
    
28.                 perror("connect");
    # L* j) m# X7 ?' q" A+ ^0 A
29.                 return -1; //exit //pthread_exit
    
30.         }
    # a5 L  r  S8 u% g5 c
31.         printf("connect..............
    " x' w# d3 ]8 A& {3 P
32. ");
    1 `2 g3 V/ s1 y+ b0 S7 K) Y
33.         char buf[100];
    1 ?) T7 p9 J  G; c
34.         int ret;
    
35.         while (1)
    
36.         {
    
37.                 printf("send: ");
    
38.                 fgets(buf, sizeof(buf), stdin);
    
39.                 ret = write(sockfd, buf, sizeof(buf));
    3 M, {8 s. V2 P0 p  l
40.                 if (ret < 0)
    
41.                 {
    9 G& d4 |6 [3 W& \
42.                         perror("write");
    
43.                         break;
    
44.                 }
    9 U5 T" X1 s( D% ?. t
45.                 if (strncmp(buf, "quit", 4) == 0)
    
46.                         break;
    ; h6 V+ O/ Q# [" ^* n. B2 a6 r
47.         }
    
48.         close(sockfd);
    ' r+ P6 s4 m! p) G) F
49.         return 0;
    0 q' S8 G. j- u' B) k1 v0 d
50. }

复制代码

' `) n2 N, S5 i. E+ d* g' H* }& S