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

QQ登录

只需一步,快速开始

 找回密码
 立即注册

QQ登录

只需一步,快速开始

查看: 18743|回复: 0
打印 上一主题 下一主题

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

[复制链接]
跳转到指定楼层
楼主
发表于 2020-5-9 01:53:20 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
实验环境是linux系统,效果如下:
1.启动服务端程序,监听在6666端口上
2.启动客户端,与服务端建立TCP连接
3.建立完TCP连接,在客户端上向服务端发送消息
4.断开连接
实现的功能很简单,但是对于初来乍到的我费了不少劲,因此在此总结一下,如有错点请各位大神指点指点
, ?( x" w( r/ C# a6 l5 p9 ~3 h
什么是SOCKET(插口):
     这里不用 "套接字" 而是用 "插口" 是因为在《TCP/IP协议卷二》中,翻译时也是用 "插口" 来表示socket的。& e9 Z0 v7 x3 X- p$ \7 q5 v" ?4 x
     "套接字" 这词不知道又是哪个教授级人物造出来的,听起来总是很怪,虽然可以避免语义上的歧义,但不明显。
      对插口通俗的理解就是:它是一个可以用来输入或者输出的网络端,另一端也具有同样相对应的操作。
      具体其他高级的定义不是这里的重点。值得说的是:
      每个插口都可以标识某个程序通信的一端,通过系统调用使得程序与网络设备之间的交流连接起来。
      应用程序 -> 系统调用 -> 插口层 -> 协议层 -> 接口层  ->发送(接收的话与之相反)! @$ X% Z- m% A- I* x6 y

  s4 N( J/ C+ d3 j- d( t" @; p+ k
- c" l1 L4 i+ ?
如何标识一个SOCKET:
       如上定义所述,可以通过地址,协议,端口三要素来确定一个通信端,而在linux C程序中使用 标识符 来标识一个
       SOCKET,Unix系统对设备的读写操作等同于对描述符的读写操作,标识符可以用于:插口 管道 目录 设备 文件等等3 w, e( L0 g0 |
       描述符是个正整数,事实上他是检查表表项中的一个下标,用于指向打开文件表的结构。
       述符前三个标识符0  1  2 分别系统保留:标准输入(键盘),标准输出(屏幕),标准错误输出
       当我们使用新的描述符来创建socket时,他一般从最小未使用的数字开始分配,也就是3

$ q0 Y# @  B% {$ u! e' \& W4 r8 D1 x0 U% q% A1 c, R6 V1 z8 |) u
服务端实现的流程:
       1.服务端开启一个SOCKET(socket函数)
       2.使用SOCKET绑定一个端口号(bind函数)
       3.在这个端口号上开启监听功能(listen函数)
       4.当有对端发送连接请求,向其发送ack+syn建立连接(accept函数)
       5.接收或者回复消息(read函数 write函数)
' M- d) q) q6 R5 k

6 q! ?4 A# Q/ D0 A
客户端实现流程:
      1.打开一个SOCKET
      2.向指定的IP 和端口号发起连接(connect函数)
      3.接收或者发送消息(send函数  recv函数)
) G0 [( |7 V( J& B
0 u7 }' H6 A) z* S

- b7 V. m1 ~/ [+ s. M6 D
如何并发处理:
      如果按照以上流程实现其实并不难,但是有个缺陷,因为C语言是按顺序单一流程运行,也就是说如果
      直接在程序当中使用accept函数(建立连接)的话,那么程序会阻塞在accept这里,这是因为如果客户端
      一直没有发送connect连接,那么accept就无法得知客户端的IP和端口,也就只能一直等待(阻塞)直到
      有请求触发继续执行为止,这样就导致如果同时多个客户向服务端发送请求连接,那么服务端只能按照
      单一线程去处理第一个客户端,无法开启多个线程同时处理多个用户的请求。

7 p( C# |. P& A/ ^! T! L/ D( H# E0 v4 p, V, v! I7 N( ~! _
如何解决:
下面摘文截取网上的资料,有兴趣者可以看看
系统提供select函数来实现多路复用输入/输出模型,该函数用于在非阻塞中,当一个套接字或一组套接字有信号时通知你
  1. int select(int nfds, fd_set *readfds, fd_set *writefds, exceptfds, const struct timeval* timeout);
复制代码
所在的头文件为:
  1. #include <sys/time.h>' D! u2 L. h6 w
  2. . @% K0 Y+ b2 o& e* w
  3. #include <unistd.h>
复制代码
  功能:测试指定的fd是否可读,可写 或者 是否有异常条件待处理
! O. k: h" N9 y
    readset  用来检查可读性的一组文件描述字。
' P+ x( V; Y4 U4 m
    writeset 用来检查可写性的一组文件描述字。

6 f9 s3 Y0 j( M  \. h    exceptset用来检查是否有异常条件出现的文件描述字。(注:不包括错误)

; x# b# i( n; ^7 x) i+ P* Q+ e    timeout  用于描述一段时间长度,如果在这个时间内,需要监视的描述符没有事件发生则函数返回,返回值为0。: G$ n7 Z" |1 n8 f$ ^. f( R: a( x

- O  u& h& |3 ~8 Y( K0 F5 I+ c' C    对于select函数的功能简单的说就是对文件fd做一个测试。测试结果有三种可能:
9 u9 j# x3 y, _9 Y, q& \
% E$ C1 m! Y) ~' a- ~  K5 n5 ~, I
  1. 1.timeout=NULL                 (阻塞:select将一直被阻塞,直到某个文件描述符上发生了事件)
    . _; ~* n! \) Z' _* E; F4 ~* ]8 \

  2. $ i( M- a  j+ v- \' p/ x) M
  3.     2.timeout所指向的结构设为非零时间  (等待固定时间:如果在指定的时间段里有事件发生或者时间耗尽,函数均返回)
    & p" d; I& F1 P+ u2 f0 n
  4. 4 R6 q6 f9 H" v& ?, D2 j. x* ~+ @9 T
  5.     3.timeout所指向的结构,时间设为0   (非阻塞:仅检测描述符集合的状态,然后立即返回,并不等待外部事件的发生)
复制代码
   返回值:
    返回对应位仍然为1的fd的总数。注意啦:只有那些可读,可写以及有异常条件待处理的fd位仍然为1。
    否则为0哦。举个例子,比如recv(), 在没有数据到来调用它的时候,你的线程将被阻塞,如果数据一直不来,
   你的线程就要阻塞很久.这样显然不好。所以采用select来查看套节字是否可读(也就是是否有数据读了) 。
   现在,UNIX系统通常会在头文件<sys/select.h>中定义常量FD_SETSIZE,它是数据类型fd_set的描述字数量,
   其值通常是1024,这样就能表示<1024的fd。
3 @5 M4 T. u( A! P  V/ C) M" F% h& l1 ?0 j3 e8 F
   
% ~6 A8 J! p; C# R5 S; J1 @
fd_set结构体:
     文件描述符集合,用于存放多个fd(文件描述符,这里就是套接字)
       可以存放服务端的fd,有客户端的fd。下面是对这个文件描述符集合的操作:
  1. FD_ZERO(*fds):     将fds设为空集/ e4 U# K& G) i- }& B, T9 V
  2.    
    ) U7 S1 t3 z- d8 L3 l6 i
  3. FD_CLR(fd,*fds):   从集合fds中删除指定的fd! [5 w7 C9 m8 S$ m! M9 T$ y  R
  4. + K; a4 u9 \! u, {( O7 [
  5. FD_SET(fd,*fds):   从集合fds中添加指定的fd
    0 n* j; ~' K7 e4 V8 f8 W  I

  6. 4 [3 {* W/ I5 M
  7. FD_ISSET(fd,*fds): 判断fd是否属于fds的集合
复制代码
步骤如下
  1. socket s;% d5 J* r  A' T/ y
  2. .....% d5 J; \9 b/ z9 K4 d5 \: H" t
  3. fd_set set;+ H: r+ {% X- x+ t8 w6 W, ~
  4. while(1){
    # t9 @( p0 U+ }
  5. FD_ZERO(&set);                    //将你的套节字集合清空7 P! O' a. @4 A$ q+ z8 M) n( C
  6. FD_SET(s, &set);                 //加入你感兴趣的套节字到集合,这里是一个读数据的套节字s/ O8 b1 ~) E  q  l0 ?  }
  7. select(0,&set,NULL,NULL,NULL);   //检查套节字是否可读,8 ]7 E% L( f' [$ B2 s3 f  q4 U
  8. if(FD_ISSET(s, &set)            //检查s是否在这个集合里面,
    ' b& T6 t/ l9 M2 h9 L
  9. {                               //select将更新这个集合,把其中不可读的套节字去掉5 v. r; w+ G( R# i1 X% A; F
  10.                                 //只保留符合条件的套节字在这个集合里面
    6 g. q7 U% b: B9 n
  11. recv(s,...);
    2 N  t# p2 n" o+ \7 m
  12. }7 x8 ], @+ H  G7 T: I- f. h8 x: d
  13. //do something here5 ~6 e( j: r$ V0 O# P
  14. }
复制代码
假设fd_set长度为1字节,fd_set中的每一位可以对应一个文件描述符,那么1字节最大可以对应8个fd
  1. (1)执行fd_set set; FD_ZERO(&set);  则set用位为0000,0000。+ ?- ^3 C  j$ v! C0 s1 d

  2. 0 a+ Z/ M- b) w' z
  3.    (2)若fd=5,执行FD_SET(fd,&set);     后set变为 0001,0000(第5位置为1)) W. S: w% ~: `* l! }% a% _$ m

  4. ; r0 l0 a9 h$ |
  5.    (3)若再加入fd=2,fd=1               则set变为 0001,0011
    ' h* \2 p5 B( G  z6 R' d" t
  6. 2 ^8 ]( W7 J) {+ L1 A
  7.    (4)执行select(6,&set,0,0,0)        阻塞等待
      Y: H% }8 t# }' {2 Q* ~
  8. ' Y4 U" ]  o) b6 L
  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.具体过程看代码会好理解

* X3 H; A& L  h/ `4 z( x  e+ y8 e
使用select函数的过程一般是:

% b, _  C; x' O0 U0 c    先调用宏FD_ZERO将指定的fd_set清零,然后调用宏FD_SET将需要测试的fd加入fd_set,
    接着调用函数select测试fd_set中的所有fd,最后用宏FD_ISSET检查某个fd在函数select调用后,相应位是否仍然为1
     复制粘贴的摘文排版起来真的是痛苦,我已经尽力排版了。。。- ~6 ], L3 Q) [, c

$ Z( \4 \; s8 S, ~0 k. O: q
客户端:
  1. #include <time.h>
    0 L( r" M( [' [* s$ X( m: ]; s
  2. #include <stdio.h>* O7 [5 X  C: N6 Z" L2 i
  3. #include <stdlib.h>
    8 Z; N& x5 j' P: t
  4. #include <string.h>; Y) v' H* W7 m" j7 \: }
  5. #include <unistd.h>
    . c" F: p9 t1 t: S) h$ m$ o" O
  6. #include <arpa/inet.h>
    9 B1 a, |, _  y4 m4 F5 b0 x8 C7 A0 ?
  7. #include <netinet/in.h>
    : O/ ?0 z: V2 `7 Q5 L: M
  8. #include <fcntl.h>
    3 i9 R; ]! X% u, \. e4 r
  9. #include <sys/stat.h># |' K, h9 M% s' M$ s  y9 g
  10. #include <sys/types.h>
    % A! F% c& Y4 a& L6 M
  11. #include <sys/socket.h>
    / x7 {1 u7 T/ N' a; k2 P
  12. 3 b; R, K( v- Q/ [
  13. #define REMOTE_PORT 6666        //服务器端口! W: D/ B% t0 h2 T7 F) x+ S1 n
  14. #define REMOTE_ADDR "127.0.0.1"     //服务器地址
    2 m0 f6 m6 L3 ^5 D
  15. ! R8 D1 O, k4 u; M5 P+ e
  16. int main(){
    ( l8 X3 k& Z+ b' p
  17.   int sockfd;
    % [) a, L! ^' z9 y* @8 j
  18.   struct sockaddr_in addr;7 L5 x# V9 g; n
  19.   char msgbuffer[256];
    . `3 e" V+ ?7 l5 S. V7 ?
  20.    + z/ C8 Y( l* I  B, a! w9 O
  21.   //创建套接字1 [6 C! ?9 m9 r9 |
  22.   sockfd = socket(AF_INET,SOCK_STREAM,0);/ L3 k! `9 g5 O. e! n) Q- j# A
  23.   if(sockfd>=0)% W3 Y7 `4 ]: y4 Y. o( c$ k6 j
  24.     printf("open socket: %d\n",sockfd);2 |8 n+ \" v. M9 w" c) P

  25. + e; P. [5 T! p# m: h: {  S( U
  26.   //将服务器的地址和端口存储于套接字结构体中. N0 P" r6 E- h9 v
  27.   bzero(&addr,sizeof(addr));
    + o5 z  b8 B6 {* U/ J1 p( X
  28.   addr.sin_family=AF_INET;
    * d5 P4 N8 u1 x- ?# L4 |, i/ e" M
  29.   addr.sin_port=htons(REMOTE_PORT);
    * V1 c9 H/ Z, \
  30.   addr.sin_addr.s_addr = inet_addr(REMOTE_ADDR);
    # J3 V4 k/ B* J& ?& d
  31.   0 ?' P' N) j2 Q9 V2 E
  32.   //向服务器发送请求
    # G6 Q7 K; G( R& t; D6 e& W
  33.   if(connect(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)
    . K! }5 \" I4 l% [3 m
  34.     printf("connect successfully\n");
    : ^0 S/ l  ~3 ~  @4 w+ ~
  35.    
    / ~- d" x4 g- x8 w2 H
  36.   //接收服务器返回的消息(注意这里程序会被阻塞,也就是说只有服务器回复信息,才会继续往下执行)
    4 h: Z) }3 m+ M- q; \
  37.   recv(sockfd,msgbuffer,sizeof(msgbuffer),0);
    # \. H6 V" i; B, d% k
  38.     printf("%s\n",msgbuffer);% u3 N0 I5 V8 V+ E: O5 r
  39.   + f. U2 x8 H/ ?& C& P1 x9 [6 \
  40.   while(1){; L$ i" M, u8 N2 x
  41.     //将键盘输入的消息发送给服务器,并且从服务器中取得回复消息" [5 c( p- r! r7 C$ p2 V/ W
  42.     bzero(msgbuffer,sizeof(msgbuffer));
    7 f* D5 Q" d3 l) b) D% o! h( @1 I+ w
  43.     read(STDIN_FILENO,msgbuffer,sizeof(msgbuffer));1 Y8 z. w, Q7 [8 v& S4 ^
  44.     if(send(sockfd,msgbuffer,sizeof(msgbuffer),0)<0)
    ; Z, E! G( r1 l# z8 k9 Y
  45.       perror("ERROR");
    # K) V  [/ B, e, w# L
  46.    
    7 [' B* u' ]* G6 |1 {
  47.     bzero(msgbuffer,sizeof(msgbuffer));" V9 h4 @$ Y4 ^! d3 ?& d# i
  48.     recv(sockfd,msgbuffer,sizeof(msgbuffer),0);* {7 P5 V: _& ~  `
  49.     printf("[receive]:%s\n",msgbuffer);  ]0 I. c7 k; a$ A+ B! E
  50.    
    " E$ }# W9 }2 Q2 u
  51.     usleep(500000);
    5 U* Y6 |& T, H% m
  52.   }% y9 l. F2 E! o# s3 Z
  53. }
复制代码

  F5 ]/ _& x2 f' l6 l8 _: F
# ^; l) ^& e7 ?+ C  {, F1 g
服务端:
  1. #include <time.h>+ T2 y: i8 T" ]3 f# T
  2. #include <stdio.h>
    ; b' k! {) ]8 `0 B. x) o, w# C
  3. #include <stdlib.h>7 f% n+ a" X# X/ F
  4. #include <string.h>
    9 \# r  k% |* O; g
  5. #include <unistd.h>
    1 a7 n$ \$ w1 O7 Y. e
  6. #include <arpa/inet.h>4 m3 R7 e% y2 Y! r& O
  7. #include <netinet/in.h>
    , X# K* U1 K7 K9 V: T, @0 q7 e8 L
  8. #include <sys/types.h>
    : {" K7 m& z3 @6 o
  9. #include <sys/socket.h>
    * l7 |0 Y) v; f' _0 j* C. R+ R

  10. ( P. {* Q) P3 W. s1 d" P* {
  11. #define LOCAL_PORT 6666      //本地服务端口! c& a1 |  P; d2 Z
  12. #define MAX 5            //最大连接数量
    & K# H* n  G9 q0 @, G0 B, B" g' g

  13. 9 p, V/ z  y; n& `* J" m) `
  14. int main(){
    3 M' ]! ?+ T$ W
  15.   int sockfd,connfd,fd,is_connected[MAX];1 I/ Q/ B) E" U# l% I- f6 f) p
  16.   struct sockaddr_in addr;
    . J& B9 X6 E' Z
  17.   int addr_len = sizeof(struct sockaddr_in);5 D: Z7 g0 b5 I9 K; S# x. z1 B
  18.   char msgbuffer[256];7 w. q( Y' E0 L5 U) p' Y
  19.   char msgsend[] = "Welcome To Demon Server";, `# k6 t0 m& _; h# e
  20.   fd_set fds;- b9 D% |5 F3 f+ C$ G" I7 H
  21.    - v! y/ z0 A# t% P( j; g; r6 {: V. l* @
  22.   //创建套接字6 L$ E& x& V* v( N1 ]7 i
  23.   sockfd = socket(AF_INET,SOCK_STREAM,0);5 d# g7 Q9 l/ T+ i1 T. a( h) d+ K
  24.   if(sockfd>=0)
    ! U" y( J% Q! d$ @
  25.     printf("open socket: %d\n",sockfd);6 ?& C; [+ b6 y3 t* }" q/ A
  26. 5 I% r! j7 S6 A% e
  27.   //将本地端口和监听地址信息保存到套接字结构体中7 i6 @. Y) H  O' }: l2 d
  28.   bzero(&addr,sizeof(addr));5 B) x/ Y. V1 L" K$ h$ t7 Q5 f! U
  29.   addr.sin_family=AF_INET;
    1 _$ d# r: R/ u! L- Z
  30.   addr.sin_port=htons(LOCAL_PORT);
    % N( V# E- D& f  a, a/ Z
  31.   addr.sin_addr.s_addr = htonl(INADDR_ANY);   //INADDR_ANY表示任意地址0.0.0.0 0.0.0.08 w( a! ~0 E, W4 m5 j" \
  32.    9 r% w. S6 F/ t2 T* Z
  33.   //将套接字于端口号绑定& l0 C- E* E) S* s+ I
  34.   if(bind(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)
    $ Z9 @/ @) v1 D2 t* a  n
  35.     printf("bind the port: %d\n",LOCAL_PORT);* L# c' @' F- D
  36. & n! s2 D6 j5 G6 v, Y8 G
  37.   //开启端口监听" |) N$ i, e3 p9 `
  38.   if(listen(sockfd,3)>=0)' c$ f3 a7 Q$ `( O7 h# y3 b9 y8 `
  39.     printf("begin listenning...\n");
    , V+ R- D  x& u4 P; F* H6 ]. m

  40. 7 ?5 `1 w0 `% k( ?! z
  41.   //默认所有fd没有被打开
    ) I& ]& K/ G' R% ]  w" W/ C
  42.   for(fd=0;fd<MAX;fd++)
    2 S8 Z+ z, e: h
  43.     is_connected[fd]=0;0 ~- p  f# k- d; V+ h7 M2 k
  44. 7 p+ h' g6 R0 [
  45.   while(1){. y/ F, x  ]8 t" |
  46.     //将服务端套接字加入集合中) ^5 {, i& G$ M) U. r) ?
  47.     FD_ZERO(&fds);( W# C2 o4 T: ^7 B
  48.     FD_SET(sockfd,&fds);
    ; x- ]8 y, p0 S' I
  49.      
    7 h/ i; t4 j; U0 |) E0 g
  50.     //将活跃的套接字加入集合中( L9 ?, H, @# h+ @! r
  51.     for(fd=0;fd<MAX;fd++)
    4 |" s, k9 h7 l# g" t: D, j
  52.       if(is_connected[fd])
    & D0 f5 x) D) S/ d, u- {: U
  53.         FD_SET(fd,&fds);: ?7 g% g) @/ i2 x8 \5 M1 T4 s
  54. 1 T2 w" }8 N1 i' M) j
  55.     //监视集合中的可读信号,如果某个套接字有信号则继续执行,此时集合中只有存在信号的套接字会被置为1,其他置为0% L5 b7 S0 E% u7 Z
  56.     if(!select(MAX,&fds,NULL,NULL,NULL))0 O7 K4 Q! I1 r) n' B- i; G
  57.       continue;
    , }: m+ _3 m5 `2 r+ D0 p1 p7 _
  58. 8 F2 u  A: H- E1 f
  59.     //遍历所有套接字判断是否在属于集合中的活跃套接字
    ) t- E6 y" d7 c+ J9 r
  60.     for(fd=0;fd<MAX;fd++){
    3 q$ ~! v% g' n: S  |
  61.       if(FD_ISSET(fd,&fds)){
    3 \/ C: }& W7 E4 ]0 E2 M
  62.         if(fd==sockfd){                             //如果套接字是服务端,那么与客户端accept建立连接
      T5 v( t7 y! z8 _4 H" `
  63.           connfd = accept(sockfd,(struct sockaddr*)&addr,&addr_len);: i; B$ g" V3 P# L
  64.           write(connfd,msgsend,sizeof(msgsend));    //向其输出欢迎语8 P- d6 j' d" F' @$ A
  65.           is_connected[connfd]=1;                   //对客户端的fd对应下标将其设为活跃状态,方便下次调用
    8 l( M9 m! a9 ]
  66.           printf("connected from %s\n",inet_ntoa(addr.sin_addr));, ~/ [( }$ Y* v; N; ]7 a
  67.         }else{                                      //如果套接字是客户端,读取其信息并返回,如果读取不到信息,冻结其套接字
    ! }# f- J$ k3 h
  68.           if(read(fd,msgbuffer,sizeof(msgbuffer))>0){ ) f. X) @) |6 W4 A# X
  69.             write(fd,msgbuffer,sizeof(msgbuffer));
    9 H) f# u0 K, ^' A
  70.             printf("[read]: %s\n",msgbuffer);; J  u) i+ V' O
  71.           }else{
    + c: a. `, Y, u6 ~
  72.              is_connected[fd]=0;2 y/ }" \! E3 [1 y4 z
  73.              close(fd);
    5 l: r% r0 ~' A# f
  74.              printf("close connected\n");
    ( _& o- X* L2 ^: [3 n5 n
  75.           }
    8 T$ M& Q5 i' |2 C5 y
  76.         }" {3 ]( R& _8 b( i! k% }
  77.       }
      k6 Y! B/ [3 U" u
  78.     }
    ) D7 h# W0 V3 [* c/ f
  79.   }+ V+ e8 v- s- F; |- a
  80. }
复制代码

/ t9 H' P' h: C
4 A6 M, K" f% ]7 i$ D
3 Y4 L7 [5 a5 u! _
- A7 N' M+ d3 F  P$ m& l  b6 w4 V

; w9 h9 I; P5 R
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享分享 支持支持 反对反对
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

GMT+8, 2026-6-20 03:12 , Processed in 0.070011 second(s), 23 queries .

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