您尚未登录,请登录后浏览更多内容! 登录 | 立即注册

QQ登录

只需一步,快速开始

 找回密码
 立即注册

QQ登录

只需一步,快速开始

查看: 2787|回复: 0

[C] 编写一个简单的TCP服务端和客户端

[复制链接]
发表于 2020-5-9 01:53:20 | 显示全部楼层 |阅读模式
实验环境是linux系统,效果如下:
1.启动服务端程序,监听在6666端口上
1006989-20170811220309273-324593640[1].png
2.启动客户端,与服务端建立TCP连接
1006989-20170811220504273-1102389198[1].png
3.建立完TCP连接,在客户端上向服务端发送消息
1006989-20170811220710367-260545598[1].png
4.断开连接
1006989-20170811220732663-1219798729[1].png
实现的功能很简单,但是对于初来乍到的我费了不少劲,因此在此总结一下,如有错点请各位大神指点指点

4 @8 O/ E0 z- v0 a0 P9 ?7 b1 l; g
什么是SOCKET(插口):
     这里不用 "套接字" 而是用 "插口" 是因为在《TCP/IP协议卷二》中,翻译时也是用 "插口" 来表示socket的。. ~2 L& d: E6 L1 u* O# }1 p
     "套接字" 这词不知道又是哪个教授级人物造出来的,听起来总是很怪,虽然可以避免语义上的歧义,但不明显。
      对插口通俗的理解就是:它是一个可以用来输入或者输出的网络端,另一端也具有同样相对应的操作。
      具体其他高级的定义不是这里的重点。值得说的是:
      每个插口都可以标识某个程序通信的一端,通过系统调用使得程序与网络设备之间的交流连接起来。
      应用程序 -> 系统调用 -> 插口层 -> 协议层 -> 接口层  ->发送(接收的话与之相反)0 d7 s- M6 @  M7 s$ n8 v

1 }! X. V! d2 G) p  ]; R0 q) W4 a# O7 O7 o* E
如何标识一个SOCKET:
       如上定义所述,可以通过地址,协议,端口三要素来确定一个通信端,而在linux C程序中使用 标识符 来标识一个
       SOCKET,Unix系统对设备的读写操作等同于对描述符的读写操作,标识符可以用于:插口 管道 目录 设备 文件等等
! Y5 Q- \& Q2 S0 z1 w% _
       描述符是个正整数,事实上他是检查表表项中的一个下标,用于指向打开文件表的结构。
       述符前三个标识符0  1  2 分别系统保留:标准输入(键盘),标准输出(屏幕),标准错误输出
       当我们使用新的描述符来创建socket时,他一般从最小未使用的数字开始分配,也就是3
7 k/ ^( L4 X9 V8 e( T0 h4 \
7 I# q3 H: y! Q& M
服务端实现的流程:
       1.服务端开启一个SOCKET(socket函数)
       2.使用SOCKET绑定一个端口号(bind函数)
       3.在这个端口号上开启监听功能(listen函数)
       4.当有对端发送连接请求,向其发送ack+syn建立连接(accept函数)
       5.接收或者回复消息(read函数 write函数)
! [# l9 \, N* P( {% g5 p9 O7 |) B
6 W1 u- [7 U/ k7 i% O; k7 b
客户端实现流程:
      1.打开一个SOCKET
      2.向指定的IP 和端口号发起连接(connect函数)
      3.接收或者发送消息(send函数  recv函数)
: D* r4 R) q8 {7 z0 Z' \0 e8 Y
# E  v1 Y) i6 K: f  M+ i$ k0 i0 b/ x

+ @3 h4 _- N/ e0 @: e3 G0 x
如何并发处理:
      如果按照以上流程实现其实并不难,但是有个缺陷,因为C语言是按顺序单一流程运行,也就是说如果
      直接在程序当中使用accept函数(建立连接)的话,那么程序会阻塞在accept这里,这是因为如果客户端
      一直没有发送connect连接,那么accept就无法得知客户端的IP和端口,也就只能一直等待(阻塞)直到
      有请求触发继续执行为止,这样就导致如果同时多个客户向服务端发送请求连接,那么服务端只能按照
      单一线程去处理第一个客户端,无法开启多个线程同时处理多个用户的请求。
& X7 |' O1 M" P
3 h" P% g2 r( Q. g( I
如何解决:
下面摘文截取网上的资料,有兴趣者可以看看
系统提供select函数来实现多路复用输入/输出模型,该函数用于在非阻塞中,当一个套接字或一组套接字有信号时通知你
  1. int select(int nfds, fd_set *readfds, fd_set *writefds, exceptfds, const struct timeval* timeout);
复制代码
所在的头文件为:
  1. #include <sys/time.h>+ u; Z1 |! b1 a' s# d6 \& `) w" g

  2. 0 s3 Q: R! r/ w9 ]* ~/ J
  3. #include <unistd.h>
复制代码
  功能:测试指定的fd是否可读,可写 或者 是否有异常条件待处理
( q& A- h$ r3 I3 W9 Y* o
    readset  用来检查可读性的一组文件描述字。
4 |/ x- u; i/ T: P" c
    writeset 用来检查可写性的一组文件描述字。
% u) A* R0 E$ \* L
    exceptset用来检查是否有异常条件出现的文件描述字。(注:不包括错误)

) U8 m" k; @6 A, S' }    timeout  用于描述一段时间长度,如果在这个时间内,需要监视的描述符没有事件发生则函数返回,返回值为0。0 O0 d: q( I& p9 T5 B) \: p/ ^; [

/ ?8 F* L7 |- V5 G    对于select函数的功能简单的说就是对文件fd做一个测试。测试结果有三种可能:
- c! U! A2 u3 c) w" o) d  g

# c  `  \/ f4 s- Y9 v7 w0 Q
  1. 1.timeout=NULL                 (阻塞:select将一直被阻塞,直到某个文件描述符上发生了事件)+ i$ ^( R- g) g4 i0 F
  2. 8 l1 m7 a! _* M0 s, ?0 |9 K
  3.     2.timeout所指向的结构设为非零时间  (等待固定时间:如果在指定的时间段里有事件发生或者时间耗尽,函数均返回)6 H' B: f& h" B0 \8 C

  4. / ]" b7 n5 y* I+ ]. j
  5.     3.timeout所指向的结构,时间设为0   (非阻塞:仅检测描述符集合的状态,然后立即返回,并不等待外部事件的发生)
复制代码
   返回值:
    返回对应位仍然为1的fd的总数。注意啦:只有那些可读,可写以及有异常条件待处理的fd位仍然为1。
    否则为0哦。举个例子,比如recv(), 在没有数据到来调用它的时候,你的线程将被阻塞,如果数据一直不来,
   你的线程就要阻塞很久.这样显然不好。所以采用select来查看套节字是否可读(也就是是否有数据读了) 。
   现在,UNIX系统通常会在头文件<sys/select.h>中定义常量FD_SETSIZE,它是数据类型fd_set的描述字数量,
   其值通常是1024,这样就能表示<1024的fd。- ^; {+ S2 f  z
: p# D) x$ b: f6 O
   4 N7 P: M: ^# A! g; y! J
fd_set结构体:
     文件描述符集合,用于存放多个fd(文件描述符,这里就是套接字)
       可以存放服务端的fd,有客户端的fd。下面是对这个文件描述符集合的操作:
  1. FD_ZERO(*fds):     将fds设为空集3 f7 T  ]9 z- T7 y0 w: y+ O3 p: U5 Y
  2.     . p- \; F+ j7 K# d: F! o- _5 C
  3. FD_CLR(fd,*fds):   从集合fds中删除指定的fd/ {# @' y4 w8 X9 N: y. T! P
  4. 8 d. @, R# ], e( w- X! ]
  5. FD_SET(fd,*fds):   从集合fds中添加指定的fd
    $ F2 g; I1 I: L2 x0 X

  6. 3 R2 M5 c+ X7 U' F$ k$ C& l
  7. FD_ISSET(fd,*fds): 判断fd是否属于fds的集合
复制代码
步骤如下
  1. socket s;8 Z, z5 w- f6 r. ^
  2. .....
    0 z7 G: U6 y6 E, ~
  3. fd_set set;5 G* w- F1 z3 H; B
  4. while(1){
    3 F# i6 x" O* e0 F" K4 A
  5. FD_ZERO(&set);                    //将你的套节字集合清空
    9 J# @  w  L! z; N
  6. FD_SET(s, &set);                 //加入你感兴趣的套节字到集合,这里是一个读数据的套节字s
    : G2 e2 R+ q' w7 |$ z8 z( R
  7. select(0,&set,NULL,NULL,NULL);   //检查套节字是否可读,- u6 w! v$ I9 g5 f5 Q2 e3 f
  8. if(FD_ISSET(s, &set)            //检查s是否在这个集合里面,
    2 _; p* R  `1 q9 @
  9. {                               //select将更新这个集合,把其中不可读的套节字去掉
    8 C! G' C1 m$ A; k0 f" T" n: q- ?2 j
  10.                                 //只保留符合条件的套节字在这个集合里面8 Z4 [  ?/ k' d, h! M
  11. recv(s,...);$ [4 ^+ P% x+ e9 M8 X
  12. }* m- P0 S& a( c! J
  13. //do something here
    2 M3 A, X! a1 |0 C& s6 `  G
  14. }
复制代码
假设fd_set长度为1字节,fd_set中的每一位可以对应一个文件描述符,那么1字节最大可以对应8个fd
  1. (1)执行fd_set set; FD_ZERO(&set);  则set用位为0000,0000。0 V: J% r) K" @" ^& L) P& V

  2. 6 M/ t5 I! J# u2 b
  3.    (2)若fd=5,执行FD_SET(fd,&set);     后set变为 0001,0000(第5位置为1)2 L& J" d9 G# D4 U2 {
  4.   g1 l/ v; p& G# N0 L
  5.    (3)若再加入fd=2,fd=1               则set变为 0001,00114 y1 h- L' ~) ]% u. G2 Y! K( R

  6. 0 T3 D4 k: V1 w' c0 Z, J3 o+ F
  7.    (4)执行select(6,&set,0,0,0)        阻塞等待
    ( R7 o! U1 L. Q& w

  8. # f# H. g1 U- c+ Z: f! B
  9.    (5)若fd=1,fd=2                    上都发生可读事件,则select返回,此时set变为0000,0011。注意:没有事件发生的fd=5被清空。
复制代码
1.可监控描述符的个数取决与sizeof(fd_set)的值
2.文件描述符的上限可以修改
3.将fd加入select监控集时,还需要一个array数组保存所有值
   因为每次select扫描之后,有信号的fd在集合中应被保留,但select将集合清空
   因此array数组可以将活跃的fd存放起来,方便下次加入fd集合中
   对集合fe_set与array进行遍历存储,即所有fd都重新加入fd_set集合中
   另外活跃状态在array中的值是1,非活跃状态的值是0
4.具体过程看代码会好理解

: O/ h; H: [# E
5 P. V. d" Y0 Z/ c7 C' L6 ?
使用select函数的过程一般是:

7 k  Z* l5 O3 p3 _8 q7 `    先调用宏FD_ZERO将指定的fd_set清零,然后调用宏FD_SET将需要测试的fd加入fd_set,
    接着调用函数select测试fd_set中的所有fd,最后用宏FD_ISSET检查某个fd在函数select调用后,相应位是否仍然为1
     复制粘贴的摘文排版起来真的是痛苦,我已经尽力排版了。。。. v4 L+ z4 x, G/ n& J4 \* J

6 p3 D; v3 [9 [, l
客户端:
  1. #include <time.h>
    7 H$ X3 o( m+ F
  2. #include <stdio.h>
    8 z# _$ `% m2 [# o! E5 @
  3. #include <stdlib.h>
    0 E& w& n3 _. K( p
  4. #include <string.h>
    - K/ t7 V4 }! i. {5 |
  5. #include <unistd.h>: R7 B! ]) f" q' ^2 k
  6. #include <arpa/inet.h>
    % q) D! r  [) q" K  i4 n
  7. #include <netinet/in.h>
    8 x1 D1 _7 a& K# D8 y
  8. #include <fcntl.h>
    ! x7 e) E2 X8 N) h/ U4 }
  9. #include <sys/stat.h>
    ! J( U/ n& v" S; G" y
  10. #include <sys/types.h>
    6 T% `% x1 x! g. i4 ]% H5 I+ L
  11. #include <sys/socket.h>. U9 f( v/ ?2 }1 r+ h4 C
  12. 1 ?/ A$ c: [: `3 P+ @0 c* J
  13. #define REMOTE_PORT 6666        //服务器端口
    # m+ ]! H2 |& y  O0 b
  14. #define REMOTE_ADDR "127.0.0.1"     //服务器地址9 G: u6 h/ U* p/ @1 B: G  n

  15. 9 A) I2 e/ J  q* [
  16. int main(){
    1 E: h- N7 {! ^3 B/ v) X  e# j
  17.   int sockfd;
    : I* a' _; F& O
  18.   struct sockaddr_in addr;' Q6 S1 w- {# [. B7 s: V, C
  19.   char msgbuffer[256];
    % |- D7 u9 u, `
  20.    
    - [' c0 n4 _# `" U) k: }; h3 X# x; }
  21.   //创建套接字; Q! j+ x+ Z4 Z, y
  22.   sockfd = socket(AF_INET,SOCK_STREAM,0);$ l: E  x) o1 H" E# x
  23.   if(sockfd>=0)
    ( h+ B: R; M. h6 z" y% f+ l% Y
  24.     printf("open socket: %d\n",sockfd);
    ) w6 Z* k  i1 [2 B
  25. % C: _$ }# ~# S% `: F% P4 e6 }7 Z
  26.   //将服务器的地址和端口存储于套接字结构体中
    4 |5 \0 l  C, I( H
  27.   bzero(&addr,sizeof(addr));
    , H) E" J& P* j/ Y3 U* g$ G  X; D- _
  28.   addr.sin_family=AF_INET;
    9 n' R1 k( ~# a
  29.   addr.sin_port=htons(REMOTE_PORT);
    2 @. o( ~  ?6 A
  30.   addr.sin_addr.s_addr = inet_addr(REMOTE_ADDR);  x' D; ^6 V9 K' m* E% t$ \3 c
  31.   " Y0 i* f* @! }* v2 G$ T% d2 B
  32.   //向服务器发送请求
    ! {" j! B( I6 H! m. f, s
  33.   if(connect(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0), ~/ T( ?$ E6 x& m) x6 q
  34.     printf("connect successfully\n");
    * ?% c. Z' K, W$ i  k, x
  35.    
    " m0 d. ?$ |1 P
  36.   //接收服务器返回的消息(注意这里程序会被阻塞,也就是说只有服务器回复信息,才会继续往下执行)$ Z" L1 Y1 n7 s% p1 q
  37.   recv(sockfd,msgbuffer,sizeof(msgbuffer),0);( C5 ]! @; j0 v
  38.     printf("%s\n",msgbuffer);
    * i! d! D8 V- l6 q, ?9 Q  A
  39.   + y4 z& Z4 T. g$ f8 ]4 t
  40.   while(1){
    + e1 e- O& d' j: A0 G: J9 d
  41.     //将键盘输入的消息发送给服务器,并且从服务器中取得回复消息
    6 i6 K: s4 G; ~# |9 f# G4 s
  42.     bzero(msgbuffer,sizeof(msgbuffer));  n  y$ M  ]- x0 H' o- o" w8 N9 u
  43.     read(STDIN_FILENO,msgbuffer,sizeof(msgbuffer));
    . h4 \1 d2 d0 @9 x5 P) ^+ \
  44.     if(send(sockfd,msgbuffer,sizeof(msgbuffer),0)<0)
    / P2 c( C2 h3 w0 Y
  45.       perror("ERROR");2 g3 G; v2 x% D; Z' z# J" K* Z; C3 `
  46.    
    0 c3 W2 X" s& Q
  47.     bzero(msgbuffer,sizeof(msgbuffer));
    : l* E1 g8 C. m+ @
  48.     recv(sockfd,msgbuffer,sizeof(msgbuffer),0);& e$ m- G& {4 z* O
  49.     printf("[receive]:%s\n",msgbuffer);* n0 R. z1 s9 D7 o: z
  50.    
    ! T4 L; G3 Y  Y1 o# [* M
  51.     usleep(500000);
    # m3 R8 }& \7 K
  52.   }
    5 Y  B: G5 x9 f0 l" ?4 Y
  53. }
复制代码
8 r) Z9 Z" a: I7 B

6 F* R7 D! n; S5 |' k" E' W# o
服务端:
  1. #include <time.h>
    + X/ I, H! g# F
  2. #include <stdio.h>1 e7 k: ^6 s( n" e4 \
  3. #include <stdlib.h>& i* F0 f1 G$ ^5 w" p
  4. #include <string.h>6 m6 `; h+ F0 d5 A$ a
  5. #include <unistd.h>
    - w/ K) B7 S5 {' K4 Z
  6. #include <arpa/inet.h>
    5 R2 L7 R7 D  S5 r' X
  7. #include <netinet/in.h>3 F5 g0 h3 `# l
  8. #include <sys/types.h>, e' w) K7 y: p, a
  9. #include <sys/socket.h>$ M. C" e1 Z' k7 \

  10. ' W' h( ~: M: z& _$ o1 p
  11. #define LOCAL_PORT 6666      //本地服务端口
    4 k# \) J/ c% U! f+ h7 Y
  12. #define MAX 5            //最大连接数量8 e' L# T. ^" ]4 N; C2 w
  13. 1 I* K/ F! D3 W9 r. E3 P' O" @
  14. int main(){
    ) c4 E0 ^; t4 w9 D5 _" [
  15.   int sockfd,connfd,fd,is_connected[MAX];
    . r2 {  f  I& J$ m8 F
  16.   struct sockaddr_in addr;# E/ Q6 p/ l$ G- }4 n& v3 g) s3 I
  17.   int addr_len = sizeof(struct sockaddr_in);& Y( D; t+ Q2 h0 z
  18.   char msgbuffer[256];
    % U6 R1 a' e0 I# a1 D' ~
  19.   char msgsend[] = "Welcome To Demon Server";9 {, R8 A/ c; P5 H/ q3 d
  20.   fd_set fds;
    ' G4 S4 l$ A! S# }5 J
  21.    
      @* _# ?: v$ d
  22.   //创建套接字
    6 D; N. T$ m6 h! R5 W
  23.   sockfd = socket(AF_INET,SOCK_STREAM,0);
    ( z- s1 X' J, w" r' y
  24.   if(sockfd>=0)
    . m9 Z4 T" D* h2 G) S
  25.     printf("open socket: %d\n",sockfd);
    & p* M1 B& |, Y8 E5 u
  26. % O) v8 v4 d& J& }8 N; n8 M3 [/ Y
  27.   //将本地端口和监听地址信息保存到套接字结构体中
    3 r' d% d; Z9 h/ Z& v+ r3 O( ^' q
  28.   bzero(&addr,sizeof(addr));2 Y8 a2 I% U% L- T$ J
  29.   addr.sin_family=AF_INET;
    ' C* ]& y, t) r; T) l" b
  30.   addr.sin_port=htons(LOCAL_PORT);# R5 K7 D3 e* O; w: q1 H
  31.   addr.sin_addr.s_addr = htonl(INADDR_ANY);   //INADDR_ANY表示任意地址0.0.0.0 0.0.0.03 E, I: t9 F& @  V9 q2 u
  32.    ) c0 d1 }, a5 Y2 |' ]+ M6 C4 F7 A% L
  33.   //将套接字于端口号绑定- _: m/ V5 T$ N; j, K
  34.   if(bind(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)
    , Z4 u) g! Z6 [
  35.     printf("bind the port: %d\n",LOCAL_PORT);4 N# C. q3 N; v5 T- \1 r& E6 {+ D

  36. ; J+ X$ n$ Q+ e0 M5 B' m2 G$ `9 y
  37.   //开启端口监听7 Q1 p- N- w* Y  \/ w1 n- `$ `1 |, B
  38.   if(listen(sockfd,3)>=0)
    2 h  U0 i& ?- u$ x
  39.     printf("begin listenning...\n");; L4 d( l- t2 y# e) T
  40. & D4 ]1 }; a8 ^+ d. N
  41.   //默认所有fd没有被打开/ \' F! X3 b$ ~0 m5 l+ w- _
  42.   for(fd=0;fd<MAX;fd++)1 r/ [) u4 v5 I1 P, d5 G
  43.     is_connected[fd]=0;' I, O5 A% f) L

  44. + G1 i1 g6 U# X, s5 |9 d
  45.   while(1){. I* p1 a" E- ~4 A' D
  46.     //将服务端套接字加入集合中, Z/ B  l. E/ H# z: C$ K  f# M& e
  47.     FD_ZERO(&fds);
    5 X5 c' c& J9 e& n8 L$ a3 {- y* r
  48.     FD_SET(sockfd,&fds);
    : q4 V# [& Z2 `2 x
  49.      4 o7 r8 S" K, m
  50.     //将活跃的套接字加入集合中
    # V: m' C% R8 F. R0 p* t, b
  51.     for(fd=0;fd<MAX;fd++)5 i. h- G- N4 N8 k( n  c
  52.       if(is_connected[fd])6 {4 c6 h' x) P, |
  53.         FD_SET(fd,&fds);
    " n& D/ S4 i" M7 T
  54. + b0 g- W9 ?# H! B2 r
  55.     //监视集合中的可读信号,如果某个套接字有信号则继续执行,此时集合中只有存在信号的套接字会被置为1,其他置为0
    8 R- y- B, f& ]/ O, V
  56.     if(!select(MAX,&fds,NULL,NULL,NULL))* t' @2 M' j  G* O* @9 x' g
  57.       continue;8 ]; J; p2 t9 A1 B/ S* e$ w4 z, u
  58. ) r0 z8 n) g: u5 G7 M8 w
  59.     //遍历所有套接字判断是否在属于集合中的活跃套接字; q9 @2 ^+ R: i* p
  60.     for(fd=0;fd<MAX;fd++){
    $ Z1 T/ X5 n5 G1 f/ G$ `3 F
  61.       if(FD_ISSET(fd,&fds)){
    6 t. s4 s; s; s, o2 n
  62.         if(fd==sockfd){                             //如果套接字是服务端,那么与客户端accept建立连接; ~: C6 ^% Y# Q
  63.           connfd = accept(sockfd,(struct sockaddr*)&addr,&addr_len);; Y  W: {* ~5 _) j. F  \7 J( t
  64.           write(connfd,msgsend,sizeof(msgsend));    //向其输出欢迎语2 f* V! a; d% T, ~: G3 V
  65.           is_connected[connfd]=1;                   //对客户端的fd对应下标将其设为活跃状态,方便下次调用
    2 P0 J9 v8 k# j9 e2 q( B
  66.           printf("connected from %s\n",inet_ntoa(addr.sin_addr));
    9 {& m; D( \$ N1 d0 k
  67.         }else{                                      //如果套接字是客户端,读取其信息并返回,如果读取不到信息,冻结其套接字
    1 \2 O" A6 m' g. l1 f  M
  68.           if(read(fd,msgbuffer,sizeof(msgbuffer))>0){ 3 a* ?2 J9 \4 @
  69.             write(fd,msgbuffer,sizeof(msgbuffer));
    5 w! }* Z# D5 x5 ?7 u4 H- x
  70.             printf("[read]: %s\n",msgbuffer);; Q( ~9 y8 m$ [
  71.           }else{) n2 [& @4 m4 f, [  t- Y
  72.              is_connected[fd]=0;7 C' c1 D5 h, f: t9 k
  73.              close(fd);: L7 Z" \2 a8 L" g
  74.              printf("close connected\n");
    1 h/ b$ z' i7 J% L
  75.           }
    , |1 V# x. }9 K. U
  76.         }* ^6 Q1 H* c  h0 F8 }! O
  77.       }
      c" t5 _9 `; W6 C. P
  78.     }9 L0 |  ?6 C( n  n$ L, E
  79.   }
    / p: M7 w3 J9 y) b; {2 J
  80. }
复制代码
# r  X5 l% K" ]# t0 `
- d" b" @* s/ P' Y1 ^
( n( i0 }9 |7 Z0 K

% F: p. e1 V5 z9 B; E7 ?# V
* M: B6 b  d/ ?) L$ q
2 O7 m- u4 E& G0 b2 V* {0 |
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

GMT+8, 2021-6-13 22:16 , Processed in 0.169574 second(s), 25 queries .

Copyright © 2001-2021 Powered by cncml! X3.2. Theme By cncml!