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

QQ登录

只需一步,快速开始

 找回密码
 立即注册

QQ登录

只需一步,快速开始

查看: 11581|回复: 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
实现的功能很简单,但是对于初来乍到的我费了不少劲,因此在此总结一下,如有错点请各位大神指点指点

3 w) i0 d# I# J7 ]
什么是SOCKET(插口):
     这里不用 "套接字" 而是用 "插口" 是因为在《TCP/IP协议卷二》中,翻译时也是用 "插口" 来表示socket的。
/ L5 n* p% c' D) a8 S) X
     "套接字" 这词不知道又是哪个教授级人物造出来的,听起来总是很怪,虽然可以避免语义上的歧义,但不明显。
      对插口通俗的理解就是:它是一个可以用来输入或者输出的网络端,另一端也具有同样相对应的操作。
      具体其他高级的定义不是这里的重点。值得说的是:
      每个插口都可以标识某个程序通信的一端,通过系统调用使得程序与网络设备之间的交流连接起来。
      应用程序 -> 系统调用 -> 插口层 -> 协议层 -> 接口层  ->发送(接收的话与之相反)/ X" M) f! F4 k" F# x* T+ }9 M4 n
4 M) N3 P  L: P% ~0 a& Y% V

- D2 X& ^' u  _" ^. e
如何标识一个SOCKET:
       如上定义所述,可以通过地址,协议,端口三要素来确定一个通信端,而在linux C程序中使用 标识符 来标识一个
       SOCKET,Unix系统对设备的读写操作等同于对描述符的读写操作,标识符可以用于:插口 管道 目录 设备 文件等等4 c% ]; X$ M1 d
       描述符是个正整数,事实上他是检查表表项中的一个下标,用于指向打开文件表的结构。
       述符前三个标识符0  1  2 分别系统保留:标准输入(键盘),标准输出(屏幕),标准错误输出
       当我们使用新的描述符来创建socket时,他一般从最小未使用的数字开始分配,也就是3
1 A1 g5 a, h8 B5 F5 ]
: v% L5 c8 @, z, ~( Z! X
服务端实现的流程:
       1.服务端开启一个SOCKET(socket函数)
       2.使用SOCKET绑定一个端口号(bind函数)
       3.在这个端口号上开启监听功能(listen函数)
       4.当有对端发送连接请求,向其发送ack+syn建立连接(accept函数)
       5.接收或者回复消息(read函数 write函数)
0 l! P* F) ^/ @" \) c7 g6 J

/ D$ [- E* U& B, g) _: o; e
客户端实现流程:
      1.打开一个SOCKET
      2.向指定的IP 和端口号发起连接(connect函数)
      3.接收或者发送消息(send函数  recv函数)

: O. z, J3 C/ ~: n" l1 J, E: ^

" l2 e' S4 z: Y1 `2 j# ]
如何并发处理:
      如果按照以上流程实现其实并不难,但是有个缺陷,因为C语言是按顺序单一流程运行,也就是说如果
      直接在程序当中使用accept函数(建立连接)的话,那么程序会阻塞在accept这里,这是因为如果客户端
      一直没有发送connect连接,那么accept就无法得知客户端的IP和端口,也就只能一直等待(阻塞)直到
      有请求触发继续执行为止,这样就导致如果同时多个客户向服务端发送请求连接,那么服务端只能按照
      单一线程去处理第一个客户端,无法开启多个线程同时处理多个用户的请求。
- @0 A9 c; ^. J$ Y2 l

7 w' f! T- J3 n- {$ j5 G4 X
如何解决:
下面摘文截取网上的资料,有兴趣者可以看看
系统提供select函数来实现多路复用输入/输出模型,该函数用于在非阻塞中,当一个套接字或一组套接字有信号时通知你
  1. int select(int nfds, fd_set *readfds, fd_set *writefds, exceptfds, const struct timeval* timeout);
复制代码
所在的头文件为:
  1. #include <sys/time.h>
    ' J5 \0 g2 {2 }& O

  2. , F- q4 q) S$ @0 n: U. B) `
  3. #include <unistd.h>
复制代码
  功能:测试指定的fd是否可读,可写 或者 是否有异常条件待处理
$ C$ r5 n8 H% r  l
    readset  用来检查可读性的一组文件描述字。

* g! u6 U) \5 M# J3 X    writeset 用来检查可写性的一组文件描述字。
% E: s. B2 w7 u7 b
    exceptset用来检查是否有异常条件出现的文件描述字。(注:不包括错误)

2 y  Q  h& A7 u% [    timeout  用于描述一段时间长度,如果在这个时间内,需要监视的描述符没有事件发生则函数返回,返回值为0。7 W) H, |7 V) b' _' |) U

" H! S* H/ h/ H$ F8 h1 Y' c    对于select函数的功能简单的说就是对文件fd做一个测试。测试结果有三种可能:( ?" t* F1 |/ W4 P

* X" L; A2 s, s) T
  1. 1.timeout=NULL                 (阻塞:select将一直被阻塞,直到某个文件描述符上发生了事件)
    3 I( W1 `+ y- s. d* l, U$ E
  2. # S: i) N7 K* g0 _) k2 F( i. v
  3.     2.timeout所指向的结构设为非零时间  (等待固定时间:如果在指定的时间段里有事件发生或者时间耗尽,函数均返回)
    . k$ S0 L9 T+ G" g
  4. 5 w* B- d# E2 ]; {1 }
  5.     3.timeout所指向的结构,时间设为0   (非阻塞:仅检测描述符集合的状态,然后立即返回,并不等待外部事件的发生)
复制代码
   返回值:
    返回对应位仍然为1的fd的总数。注意啦:只有那些可读,可写以及有异常条件待处理的fd位仍然为1。
    否则为0哦。举个例子,比如recv(), 在没有数据到来调用它的时候,你的线程将被阻塞,如果数据一直不来,
   你的线程就要阻塞很久.这样显然不好。所以采用select来查看套节字是否可读(也就是是否有数据读了) 。
   现在,UNIX系统通常会在头文件<sys/select.h>中定义常量FD_SETSIZE,它是数据类型fd_set的描述字数量,
   其值通常是1024,这样就能表示<1024的fd。
: h2 V* W! B. H3 z: Y' E3 ], O' I& o. ?; a9 B/ N
   
' J7 K; H8 _& o* Q; _: K
fd_set结构体:
     文件描述符集合,用于存放多个fd(文件描述符,这里就是套接字)
       可以存放服务端的fd,有客户端的fd。下面是对这个文件描述符集合的操作:
  1. FD_ZERO(*fds):     将fds设为空集; I) V& q; Q2 y5 u
  2.    
    2 [! i) T+ x' x  T1 {4 X; l
  3. FD_CLR(fd,*fds):   从集合fds中删除指定的fd( I4 p2 ~  ~7 _- T
  4. 7 I0 b8 j; a0 a$ y. {; n; c
  5. FD_SET(fd,*fds):   从集合fds中添加指定的fd
    3 d! Z: i2 V% s

  6. 4 Z; ~% V# Z: ~7 @$ x' s& k/ x
  7. FD_ISSET(fd,*fds): 判断fd是否属于fds的集合
复制代码
步骤如下
  1. socket s;
    ) O8 y, P0 I' V: d% I
  2. .....0 i! n' W) x( T5 Y# R7 d& \. a
  3. fd_set set;* ?5 c! K3 H1 s! h: t& J) d$ n
  4. while(1){
    2 `1 k+ V) b# F& `" ^2 c/ v
  5. FD_ZERO(&set);                    //将你的套节字集合清空
    ; q0 Q. P3 v. y9 g7 z
  6. FD_SET(s, &set);                 //加入你感兴趣的套节字到集合,这里是一个读数据的套节字s7 K& P# \& ]5 h- M  n& H
  7. select(0,&set,NULL,NULL,NULL);   //检查套节字是否可读,
    7 I0 Y/ M5 W* b& O: T
  8. if(FD_ISSET(s, &set)            //检查s是否在这个集合里面,
    . R0 d2 @+ o7 N! C3 n
  9. {                               //select将更新这个集合,把其中不可读的套节字去掉
    . z/ a: _/ V9 ^  v
  10.                                 //只保留符合条件的套节字在这个集合里面
    5 e0 j1 O/ s- x: i. o& n$ i# }% z
  11. recv(s,...);. _3 _3 r; D# B: a+ M. b
  12. }
    4 m: ~) g) Z9 O3 ^$ ]
  13. //do something here9 j! {! y2 n2 }  o& p2 Q
  14. }
复制代码
假设fd_set长度为1字节,fd_set中的每一位可以对应一个文件描述符,那么1字节最大可以对应8个fd
  1. (1)执行fd_set set; FD_ZERO(&set);  则set用位为0000,0000。
    ) P1 h# E  u" M5 j
  2. 8 P4 t5 N/ d4 _# `( O. \5 Q3 `, t4 p0 o
  3.    (2)若fd=5,执行FD_SET(fd,&set);     后set变为 0001,0000(第5位置为1)
      I/ E6 L8 `* L! T, Q3 `/ n

  4. % S( n1 A$ I2 V, v: ]4 {* T
  5.    (3)若再加入fd=2,fd=1               则set变为 0001,00116 J- H. K4 S% G) a' U
  6. 5 a2 r' V9 Q, x/ s) L
  7.    (4)执行select(6,&set,0,0,0)        阻塞等待
    # v9 L8 }7 Y/ e" U7 u+ }' F

  8. 3 I5 f3 R5 b( E  {
  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.具体过程看代码会好理解
) u6 g1 L1 |! e* u: t. D, ?

+ q4 M& `* V: e4 [, J
使用select函数的过程一般是:

' }' f7 M% l* i3 k+ q    先调用宏FD_ZERO将指定的fd_set清零,然后调用宏FD_SET将需要测试的fd加入fd_set,
    接着调用函数select测试fd_set中的所有fd,最后用宏FD_ISSET检查某个fd在函数select调用后,相应位是否仍然为1
     复制粘贴的摘文排版起来真的是痛苦,我已经尽力排版了。。。
3 \# b/ g' ^7 Z1 I

! C/ B7 v' }( |
客户端:
  1. #include <time.h>
    8 ^1 C4 M/ P! {2 i
  2. #include <stdio.h>
    # P) ~; f" T1 B+ g* r, z3 D
  3. #include <stdlib.h>, Y, L( o8 e9 ^: L$ C  L% T
  4. #include <string.h>
    . t( [; p3 Q3 X
  5. #include <unistd.h>- b4 [- l  H" {- t7 T
  6. #include <arpa/inet.h>
    5 L9 `3 D, C) m5 [  ]  b3 K
  7. #include <netinet/in.h>
    . U' [+ n. v( G- ?- Z
  8. #include <fcntl.h>
    0 h' }' S: N8 N
  9. #include <sys/stat.h>
    * |' V* W% d0 M. c, ]8 Z' ?
  10. #include <sys/types.h>2 X0 \2 b' F  R
  11. #include <sys/socket.h>
    9 A7 S) J; Q* v

  12. ) V2 m! \; x! H3 |7 @3 }' Q
  13. #define REMOTE_PORT 6666        //服务器端口  H0 o: j1 \! O" X8 d# L, J: S
  14. #define REMOTE_ADDR "127.0.0.1"     //服务器地址7 q5 ~& M3 D  p; w

  15. . p5 K7 n3 e8 Y: S2 s6 A( }
  16. int main(){
    , ~! ?% `5 g! ^- \+ S  l# p
  17.   int sockfd;6 H9 }. \. W0 V2 ~" U0 ?" P
  18.   struct sockaddr_in addr;
    ; _: Z6 O( N" N
  19.   char msgbuffer[256];6 z, u# v* g9 j* q6 t9 R
  20.    
    - u8 B0 b. g1 w- x2 [% Z- j
  21.   //创建套接字
    2 F) Y' Q+ V7 L
  22.   sockfd = socket(AF_INET,SOCK_STREAM,0);2 C! ~) G. q+ v. ]1 Y4 K4 v. A
  23.   if(sockfd>=0)$ V8 [% y( L$ @9 @  d* H1 z
  24.     printf("open socket: %d\n",sockfd);
    $ ~& j4 k& t$ F; T6 a5 G" u
  25. 1 ~$ k- b# R3 ~7 F# ?
  26.   //将服务器的地址和端口存储于套接字结构体中0 a* _: H2 v1 i/ m
  27.   bzero(&addr,sizeof(addr));, y- J5 N/ y+ U
  28.   addr.sin_family=AF_INET;# Y$ [5 R5 a, Z, X6 |; P
  29.   addr.sin_port=htons(REMOTE_PORT);, x5 R! ^  }1 t; L) W: @
  30.   addr.sin_addr.s_addr = inet_addr(REMOTE_ADDR);
    5 u# Q' O, F0 M
  31.   
    7 d$ Y( W" g' F. ?+ H! L
  32.   //向服务器发送请求
    , {4 e: y+ h& _9 Y* g
  33.   if(connect(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)! }7 `& T& s4 ^
  34.     printf("connect successfully\n");5 B- `( |# K4 q& W! ~2 I- Y& s7 k2 Z
  35.    : X+ I9 @) R3 B- f3 l% g
  36.   //接收服务器返回的消息(注意这里程序会被阻塞,也就是说只有服务器回复信息,才会继续往下执行)! u8 Q. Z3 s) d9 \8 F: a7 R
  37.   recv(sockfd,msgbuffer,sizeof(msgbuffer),0);
    6 F2 P( @+ y! N6 I1 a  _
  38.     printf("%s\n",msgbuffer);
      D# m; N7 n' K9 }( w/ g' R3 [9 _
  39.   
    : t+ ]. X6 m7 Y) H, L
  40.   while(1){
    0 y* V  @9 Y# R6 R' w
  41.     //将键盘输入的消息发送给服务器,并且从服务器中取得回复消息
    # Q& C* R8 z$ |+ M. ^% t
  42.     bzero(msgbuffer,sizeof(msgbuffer));
    ' @4 A4 I1 b+ \% r" k% Y$ d
  43.     read(STDIN_FILENO,msgbuffer,sizeof(msgbuffer));7 L) X' e% |4 t: z0 t: e
  44.     if(send(sockfd,msgbuffer,sizeof(msgbuffer),0)<0)
    - A4 Q* y( x9 s
  45.       perror("ERROR");
    ; W1 j& R2 `: T, d1 z2 T
  46.     7 e2 ^6 @0 P" Z. t- C; A
  47.     bzero(msgbuffer,sizeof(msgbuffer));5 z5 ?' Z2 F) O3 L1 J8 U1 P0 q
  48.     recv(sockfd,msgbuffer,sizeof(msgbuffer),0);
    6 B0 U4 ~7 p* A" J& J: k
  49.     printf("[receive]:%s\n",msgbuffer);
    , a" o7 d' H- Y9 {
  50.     8 p: n& E7 z4 @: E
  51.     usleep(500000);9 H# ~. V9 ]# u* a: O7 O
  52.   }7 y' X' Y2 K& ^# B, K
  53. }
复制代码

% q- f: T; W- {- \+ I7 P
5 d' x! d% j' V: }4 j7 V
服务端:
  1. #include <time.h>. c" K2 \  M; c8 `2 c
  2. #include <stdio.h>
    6 d6 Q/ j2 \* g% g
  3. #include <stdlib.h>: C- m# X2 [& f
  4. #include <string.h>
    1 c, u) D: G9 G/ R% R3 ]6 c2 _8 Q
  5. #include <unistd.h>
    , u- I0 z# j: S
  6. #include <arpa/inet.h>1 }* j3 \) J8 G5 P
  7. #include <netinet/in.h>
    7 v$ U- W. U$ k1 X* Y( i. O
  8. #include <sys/types.h>
    % W- S* P. N( Z+ t" X% H) q6 M
  9. #include <sys/socket.h>) {% x1 q. R" ~3 C
  10. 0 B) l& q8 w* A$ u
  11. #define LOCAL_PORT 6666      //本地服务端口
    & k$ C7 w% Y( F: q* [# x
  12. #define MAX 5            //最大连接数量* U' J, k3 S! l: f
  13.   F4 s" W$ F7 n$ C  Q+ E
  14. int main(){% l: F3 W. X9 V1 E$ \8 \. K" K
  15.   int sockfd,connfd,fd,is_connected[MAX];
    3 W6 I: v. b8 r( g2 f
  16.   struct sockaddr_in addr;
    6 m4 Y1 [- }# `: w
  17.   int addr_len = sizeof(struct sockaddr_in);
    - }* p  j) p  s  e6 e
  18.   char msgbuffer[256];/ G% q2 x$ B  e; e! Y
  19.   char msgsend[] = "Welcome To Demon Server";2 K/ j. X; \0 w$ T! j- {) z
  20.   fd_set fds;
    ; x: ?9 V  j: t" j& P
  21.    
    2 `) @  n" J8 ~" O: N( j
  22.   //创建套接字
    # z0 b- p3 q/ D+ g- E, m6 U4 B
  23.   sockfd = socket(AF_INET,SOCK_STREAM,0);& D, R/ F9 f' Y, v1 S+ j
  24.   if(sockfd>=0)
    * B: v$ b  O, c$ I. q
  25.     printf("open socket: %d\n",sockfd);
    , M; C, ^$ j( K  D! ~* ~

  26. ! O- ^) }. M3 E5 l6 @1 @
  27.   //将本地端口和监听地址信息保存到套接字结构体中
    4 E* @  c( K# I
  28.   bzero(&addr,sizeof(addr));
    # m+ d  o/ w- v1 x$ P& b
  29.   addr.sin_family=AF_INET;
    ! E0 P1 B. @% b
  30.   addr.sin_port=htons(LOCAL_PORT);- e8 }( e9 c; `3 R
  31.   addr.sin_addr.s_addr = htonl(INADDR_ANY);   //INADDR_ANY表示任意地址0.0.0.0 0.0.0.0
    ' f5 U6 I. _* x3 O8 S
  32.    9 B+ T- J$ e6 I: @% v  h8 `
  33.   //将套接字于端口号绑定
    ; l' {& M1 m. i% T' Z" ]( q, O+ G
  34.   if(bind(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)0 k7 l9 q8 H; {/ q0 y# e! K
  35.     printf("bind the port: %d\n",LOCAL_PORT);. K5 F7 c3 \, M/ X+ j
  36. . E/ J" y! `: B& m+ `+ c* C3 G: c; W# V
  37.   //开启端口监听( k: C$ H, Y# R$ t+ D+ a! m
  38.   if(listen(sockfd,3)>=0)2 R# I2 W4 I3 ^& H$ D4 F
  39.     printf("begin listenning...\n");' `* @* H( G* O9 d( v9 i

  40. 8 e3 ~  M6 w- V
  41.   //默认所有fd没有被打开+ t9 [$ F$ p8 a, j* c6 {4 f
  42.   for(fd=0;fd<MAX;fd++)% D% T2 j- d6 v; P
  43.     is_connected[fd]=0;
    . k1 g+ y( t  l
  44. $ C! A* M. h' G& U
  45.   while(1){
    ; D1 N6 T( B* E  p7 n* p* T
  46.     //将服务端套接字加入集合中
    2 j: O0 m' o9 L8 y7 m+ {9 a
  47.     FD_ZERO(&fds);2 [% d  M7 A5 E5 J4 |  V
  48.     FD_SET(sockfd,&fds);
    1 ~* B0 a6 J5 f
  49.      * n2 P' [7 k) r; ]2 ?, E
  50.     //将活跃的套接字加入集合中
    $ h/ {4 J# D1 H. V
  51.     for(fd=0;fd<MAX;fd++)
    ! H" ?2 w' h# I* ~* Z
  52.       if(is_connected[fd])
    ' r) M; P9 A' V  a) S1 ?2 g
  53.         FD_SET(fd,&fds);/ t9 s  ~/ O5 H( Y+ z* _4 `

  54. ) `3 L" k: {  r( x' H) z  c
  55.     //监视集合中的可读信号,如果某个套接字有信号则继续执行,此时集合中只有存在信号的套接字会被置为1,其他置为0% J7 M- {' M. L/ a- t) V
  56.     if(!select(MAX,&fds,NULL,NULL,NULL))- w8 E* _2 x1 y6 D, M+ Y
  57.       continue;* _- U6 e8 V, P  c9 m/ B1 J
  58. 7 Z+ g3 @+ R. n- p, f9 J$ V. Q
  59.     //遍历所有套接字判断是否在属于集合中的活跃套接字
    5 r# G. o- N5 X. T; b! O: z, q
  60.     for(fd=0;fd<MAX;fd++){
    / m( J' X; p$ \8 A
  61.       if(FD_ISSET(fd,&fds)){' @' V( s- a9 n
  62.         if(fd==sockfd){                             //如果套接字是服务端,那么与客户端accept建立连接2 k3 n4 Z) e9 }6 R. R, M$ c
  63.           connfd = accept(sockfd,(struct sockaddr*)&addr,&addr_len);
    3 F" p4 M( m5 w& r/ D& f
  64.           write(connfd,msgsend,sizeof(msgsend));    //向其输出欢迎语
      k$ W% z, a' H- v
  65.           is_connected[connfd]=1;                   //对客户端的fd对应下标将其设为活跃状态,方便下次调用# v, {, {' e, ^* k- n" t+ D
  66.           printf("connected from %s\n",inet_ntoa(addr.sin_addr));
    5 r' |- C( {- r4 M
  67.         }else{                                      //如果套接字是客户端,读取其信息并返回,如果读取不到信息,冻结其套接字
    # T8 ], t; \+ \8 P  z# f5 P
  68.           if(read(fd,msgbuffer,sizeof(msgbuffer))>0){ # m; C5 L' _+ e
  69.             write(fd,msgbuffer,sizeof(msgbuffer));
    + e: G# f$ t' p$ L" l
  70.             printf("[read]: %s\n",msgbuffer);
    0 H% O. N9 w$ ]& ~( |
  71.           }else{
    6 g8 ~# n5 t2 _' e( m
  72.              is_connected[fd]=0;
    1 q: f+ b% E0 b8 n
  73.              close(fd);$ Q. F' x' G+ h' Z2 G
  74.              printf("close connected\n");
    0 x7 C3 \( A/ F: r
  75.           }
    , W  [& b: L0 R* W" `
  76.         }
    5 o- G0 K; `( y# y" |
  77.       }6 e2 U! e5 Y  h5 W. A
  78.     }! i8 L6 d9 r1 a- h3 D4 M
  79.   }9 e: c5 ^1 k7 Z. y) A6 A& y& i
  80. }
复制代码

6 L3 G: ^$ d. v2 d+ l6 w5 ~3 ?0 L9 i0 f& i+ \8 U& i5 ^
* ?% h7 |5 e& ^* t6 U$ k& e2 v; v

$ o% R9 M7 D0 E# _) l
2 a4 _. ~; H6 h2 Q+ X' z- r9 p4 O' b1 a# V  p% A7 U1 L2 X5 G
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

GMT+8, 2024-5-26 22:07 , Processed in 0.138949 second(s), 25 queries .

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