实验环境是linux系统,效果如下: 1.启动服务端程序,监听在6666端口上 2.启动客户端,与服务端建立TCP连接 3.建立完TCP连接,在客户端上向服务端发送消息 4.断开连接 实现的功能很简单,但是对于初来乍到的我费了不少劲,因此在此总结一下,如有错点请各位大神指点指点
+ v7 F/ p! J7 M: }9 G" m5 }# M6 G' @什么是SOCKET(插口): 这里不用 "套接字" 而是用 "插口" 是因为在《TCP/IP协议卷二》中,翻译时也是用 "插口" 来表示socket的。
* V) E7 \5 j, [* d, G6 E4 w "套接字" 这词不知道又是哪个教授级人物造出来的,听起来总是很怪,虽然可以避免语义上的歧义,但不明显。 对插口通俗的理解就是:它是一个可以用来输入或者输出的网络端,另一端也具有同样相对应的操作。 具体其他高级的定义不是这里的重点。值得说的是: 每个插口都可以标识某个程序通信的一端,通过系统调用使得程序与网络设备之间的交流连接起来。 应用程序 -> 系统调用 -> 插口层 -> 协议层 -> 接口层 ->发送(接收的话与之相反)* a: t( o! U5 V: Q2 s
2 t: k7 t8 M. D/ t6 B9 ~& t! m# b9 h- J- ^
如何标识一个SOCKET: 如上定义所述,可以通过地址,协议,端口三要素来确定一个通信端,而在linux C程序中使用 标识符 来标识一个 SOCKET,Unix系统对设备的读写操作等同于对描述符的读写操作,标识符可以用于:插口 管道 目录 设备 文件等等8 c; P% F' v+ M% @
描述符是个正整数,事实上他是检查表表项中的一个下标,用于指向打开文件表的结构。 述符前三个标识符0 1 2 分别系统保留:标准输入(键盘),标准输出(屏幕),标准错误输出 当我们使用新的描述符来创建socket时,他一般从最小未使用的数字开始分配,也就是3
. O" M1 E/ y6 G9 ?- v2 s
9 t+ e" Q J' U0 q服务端实现的流程: 1.服务端开启一个SOCKET(socket函数) 2.使用SOCKET绑定一个端口号(bind函数) 3.在这个端口号上开启监听功能(listen函数) 4.当有对端发送连接请求,向其发送ack+syn建立连接(accept函数) 5.接收或者回复消息(read函数 write函数)
* P4 J- a/ G& a0 v g1 [" D8 \% y) C9 ?+ t$ r9 M
客户端实现流程: 1.打开一个SOCKET 2.向指定的IP 和端口号发起连接(connect函数) 3.接收或者发送消息(send函数 recv函数)
3 `2 N1 B4 P+ j6 q' a6 s
7 c! ]* @! t/ @& ^
, P u1 c# x+ X7 m如何并发处理: 如果按照以上流程实现其实并不难,但是有个缺陷,因为C语言是按顺序单一流程运行,也就是说如果 直接在程序当中使用accept函数(建立连接)的话,那么程序会阻塞在accept这里,这是因为如果客户端 一直没有发送connect连接,那么accept就无法得知客户端的IP和端口,也就只能一直等待(阻塞)直到 有请求触发继续执行为止,这样就导致如果同时多个客户向服务端发送请求连接,那么服务端只能按照 单一线程去处理第一个客户端,无法开启多个线程同时处理多个用户的请求。
7 ^4 u; N0 f" x" f! r7 r" z6 U& ]+ E
如何解决: 下面摘文截取网上的资料,有兴趣者可以看看 系统提供select函数来实现多路复用输入/输出模型,该函数用于在非阻塞中,当一个套接字或一组套接字有信号时通知你 - int select(int nfds, fd_set *readfds, fd_set *writefds, exceptfds, const struct timeval* timeout);
复制代码所在的头文件为: - #include <sys/time.h>
" O+ G, v( w! y5 K) }+ L - 9 U6 m9 `& ]* ?( @
- #include <unistd.h>
复制代码 功能:测试指定的fd是否可读,可写 或者 是否有异常条件待处理
4 V$ U9 h/ d# J readset 用来检查可读性的一组文件描述字。
9 [' m- v; @' k% e, y: a writeset 用来检查可写性的一组文件描述字。
- C0 j8 S0 E0 x1 I: G
exceptset用来检查是否有异常条件出现的文件描述字。(注:不包括错误) 2 a1 C, V1 F X& U/ m
timeout 用于描述一段时间长度,如果在这个时间内,需要监视的描述符没有事件发生则函数返回,返回值为0。
6 k- N- I% w! V: ~ l( L" \! X6 m4 d% j
对于select函数的功能简单的说就是对文件fd做一个测试。测试结果有三种可能: @- x2 {" N0 `# {4 k# }: H
) S" X3 K/ l4 M* h. x: W8 X a9 {% c
- 1.timeout=NULL (阻塞:select将一直被阻塞,直到某个文件描述符上发生了事件)
* c# n8 r' W! g) B' W. ]' K
2 W8 B. ]$ R7 F W. M% F& d" {- z/ |' s# s- 2.timeout所指向的结构设为非零时间 (等待固定时间:如果在指定的时间段里有事件发生或者时间耗尽,函数均返回)
7 u6 G4 |6 n2 A
. i6 M! A" O& C, p6 t/ f6 I- 3.timeout所指向的结构,时间设为0 (非阻塞:仅检测描述符集合的状态,然后立即返回,并不等待外部事件的发生)
复制代码 返回值: 返回对应位仍然为1的fd的总数。注意啦:只有那些可读,可写以及有异常条件待处理的fd位仍然为1。 否则为0哦。举个例子,比如recv(), 在没有数据到来调用它的时候,你的线程将被阻塞,如果数据一直不来, 你的线程就要阻塞很久.这样显然不好。所以采用select来查看套节字是否可读(也就是是否有数据读了) 。 现在,UNIX系统通常会在头文件<sys/select.h>中定义常量FD_SETSIZE,它是数据类型fd_set的描述字数量, 其值通常是1024,这样就能表示<1024的fd。# A u! z9 x# U' T ^
9 P8 ~; C1 k4 H1 P 0 K# B2 n( A# e: X: y4 B
fd_set结构体: 文件描述符集合,用于存放多个fd(文件描述符,这里就是套接字) 可以存放服务端的fd,有客户端的fd。下面是对这个文件描述符集合的操作: - FD_ZERO(*fds): 将fds设为空集1 {( I+ j7 ~* E" q8 N9 e8 ]/ t
-
) H; Y* Z' X: @: R, i - FD_CLR(fd,*fds): 从集合fds中删除指定的fd
+ b, Q& Q- {/ S7 y6 ^ - " Q8 |# Y5 a' l1 s6 l
- FD_SET(fd,*fds): 从集合fds中添加指定的fd
( B4 k' V) p1 K1 M+ L: M - $ d: T2 x4 {- H; ~3 C% H
- FD_ISSET(fd,*fds): 判断fd是否属于fds的集合
复制代码步骤如下 - socket s;; h3 g, @4 |& s# t* |! H
- .....
8 P/ R% S5 H9 j" O0 ~* c - fd_set set;/ ]% u& n3 n# ~4 j6 K
- while(1){, i+ j5 x( n; K5 W( n0 o/ O6 v- m( e) @
- FD_ZERO(&set); //将你的套节字集合清空
( {# {; u4 W9 s - FD_SET(s, &set); //加入你感兴趣的套节字到集合,这里是一个读数据的套节字s
, c% [# U. i y+ D* C0 V* N! S- s% | - select(0,&set,NULL,NULL,NULL); //检查套节字是否可读,6 ^% N: ^5 \2 P+ m- y( S9 m
- if(FD_ISSET(s, &set) //检查s是否在这个集合里面,) X5 h9 `$ J+ @
- { //select将更新这个集合,把其中不可读的套节字去掉# h8 ^' \) _5 A# \5 [
- //只保留符合条件的套节字在这个集合里面& y: A9 O# W7 [$ t
- recv(s,...);8 `) _7 P0 w% X, x3 U" a
- } v" _0 ^9 Y4 t3 g. u& D, z! G+ I
- //do something here8 D) o1 U: v0 L1 R
- }
复制代码假设fd_set长度为1字节,fd_set中的每一位可以对应一个文件描述符,那么1字节最大可以对应8个fd - (1)执行fd_set set; FD_ZERO(&set); 则set用位为0000,0000。
0 b% s; ?& i1 ^ - 7 a0 F8 e9 W) b. D4 Z
- (2)若fd=5,执行FD_SET(fd,&set); 后set变为 0001,0000(第5位置为1)
) n) ]; ^2 ]7 e; U# o$ B( S# _
8 P3 H3 |$ x4 y( m, f3 R% h- (3)若再加入fd=2,fd=1 则set变为 0001,0011. w+ `5 s: @! f0 Q; q6 L( W- x
* o$ t7 X+ d4 ~1 d) ?- (4)执行select(6,&set,0,0,0) 阻塞等待
% l. t- y3 `' s - ! h0 f9 b% V# i
- (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.具体过程看代码会好理解 ' C/ w) o9 m5 G! F" x
( z9 [6 J8 X4 s' |5 K1 t# y使用select函数的过程一般是: + {! ?4 X8 r; s0 {( O) u
先调用宏FD_ZERO将指定的fd_set清零,然后调用宏FD_SET将需要测试的fd加入fd_set, 接着调用函数select测试fd_set中的所有fd,最后用宏FD_ISSET检查某个fd在函数select调用后,相应位是否仍然为1 复制粘贴的摘文排版起来真的是痛苦,我已经尽力排版了。。。1 j/ F" G0 \5 b) ~. ~% N% |! \' g8 T
+ z! Q3 S! [9 I9 H/ q/ t
客户端: - #include <time.h>. j% N+ D& O" y/ |$ X9 ?$ A
- #include <stdio.h>
! |+ O) l0 J3 S* K - #include <stdlib.h>
0 Y( f. q5 k3 }1 W - #include <string.h>/ X( Y1 ?" m' V/ m0 x
- #include <unistd.h>
# W8 p7 W& P. c' a' ]8 O8 f - #include <arpa/inet.h>7 ^5 f0 k' t; I; U( x
- #include <netinet/in.h>0 B. M% E! h* ?3 c
- #include <fcntl.h>; q7 Y- y0 t9 f# Q3 x
- #include <sys/stat.h>$ v! y' E b0 S+ w: V% M9 i' X$ `
- #include <sys/types.h>7 {5 Q; ^3 l6 l( M# |; n+ j7 \
- #include <sys/socket.h>3 {* _! K% s6 a, T) n
-
. J. X9 B! w2 U! L: ]+ a1 ] - #define REMOTE_PORT 6666 //服务器端口
) A# d. e; q; Z, | - #define REMOTE_ADDR "127.0.0.1" //服务器地址# H5 P: w' P: M! c. J4 l1 V6 W
-
* w% x. y2 c# F9 A7 P2 I- O$ P4 `3 c( d - int main(){
7 ^$ ^, W, H6 ` C2 E0 A7 |9 a - int sockfd;
; d" ~+ j, t, ^( Y - struct sockaddr_in addr;
4 o7 z0 o6 B% H& h3 x1 { - char msgbuffer[256];
3 m9 X/ \, {! l* o5 x - 6 V* P+ e# p3 U2 C5 t! L( Z
- //创建套接字
9 H* |& C1 _. z2 }6 X1 x, p: ?/ x4 ` - sockfd = socket(AF_INET,SOCK_STREAM,0);
( k8 I- O7 g0 g- C5 v6 r# c - if(sockfd>=0)
- w! Q8 V- B& v - printf("open socket: %d\n",sockfd);
; b, g! m' s3 m5 f4 d -
4 n) |8 A* v9 @; A - //将服务器的地址和端口存储于套接字结构体中' P/ P9 U; j. p& ^: ?
- bzero(&addr,sizeof(addr));
1 c$ C4 a* P' M0 p - addr.sin_family=AF_INET;
( |4 l# {, y% H+ h6 y% P( x8 \- z - addr.sin_port=htons(REMOTE_PORT);
- U- {& ^* _: e i7 ^ - addr.sin_addr.s_addr = inet_addr(REMOTE_ADDR);
% Z* L* w$ U7 j, @1 B, z* r - 3 r( S# h0 s+ H5 Q- [2 A
- //向服务器发送请求
& N: n+ I2 _8 |' Y: R+ u2 @) h7 r - if(connect(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0): q" V# f* W4 p- D
- printf("connect successfully\n");
: x" z$ K) j; b- @: K* x+ @ -
9 Y3 i8 t0 X) U8 j4 x - //接收服务器返回的消息(注意这里程序会被阻塞,也就是说只有服务器回复信息,才会继续往下执行)
; N! F$ c" t3 \* p$ {% O3 b - recv(sockfd,msgbuffer,sizeof(msgbuffer),0);
3 z( Y V7 `/ Q) d - printf("%s\n",msgbuffer);
; R0 C3 d. t* m% `7 R* Q -
7 E& h, T6 _" E# e) A4 T6 K - while(1){
- b# W, S% l1 O7 p" \1 F, j - //将键盘输入的消息发送给服务器,并且从服务器中取得回复消息
9 v/ ~9 Z- a2 f( b9 ] - bzero(msgbuffer,sizeof(msgbuffer));8 Q2 a1 ~ `- Z0 |' k0 y9 n/ g) V
- read(STDIN_FILENO,msgbuffer,sizeof(msgbuffer));
, Q( n, H" C' F8 t2 ^ R - if(send(sockfd,msgbuffer,sizeof(msgbuffer),0)<0)
4 B) e" {5 A6 c7 |7 m. k - perror("ERROR");/ H" N5 d" {0 E5 ?" h
- ( j" n0 @5 o9 d8 {% B
- bzero(msgbuffer,sizeof(msgbuffer));* Z6 B0 J" y' U# A; m. v
- recv(sockfd,msgbuffer,sizeof(msgbuffer),0);# s) I/ h8 a0 g! Y+ \9 u$ m
- printf("[receive]:%s\n",msgbuffer);
# v$ ]! c& p% c. Q& b* q -
0 R+ h+ g$ }5 A5 t: J- D' M - usleep(500000);
3 p; f( q2 E" c2 D3 Z& E - }3 R0 z0 A" s& C' r; Q* M
- }
复制代码 - Z- w' U3 e( i1 x1 j6 ?& M
; v$ v$ p m5 Y8 I4 l. i
服务端: - #include <time.h>" A* Y8 U' u# m
- #include <stdio.h>
) ^ Q, H& \1 j" R U6 V - #include <stdlib.h>2 B7 M" a8 ] C% s# o9 N
- #include <string.h>
+ g* a4 f/ a5 { - #include <unistd.h>
: s5 h( ]; A& f/ a1 W - #include <arpa/inet.h>4 j; N( C& R4 W4 v+ ~. O2 o! `
- #include <netinet/in.h>& U2 S* e c7 g* L# Q
- #include <sys/types.h>
! J) N- L8 ?# q" ?5 L - #include <sys/socket.h>) ] N; }6 b$ |
-
+ z+ w9 i2 J% H9 H' \0 `1 }6 q - #define LOCAL_PORT 6666 //本地服务端口! N$ \! k) ~. Y. l% w* E
- #define MAX 5 //最大连接数量9 p9 S, h+ S# F" O
-
. N: _5 o6 J+ R& r - int main(){
7 k( Z9 d) \+ |. j& F3 q - int sockfd,connfd,fd,is_connected[MAX];
1 X: q- p# |/ P4 f: O - struct sockaddr_in addr;
6 y, i5 O" O8 M [$ S - int addr_len = sizeof(struct sockaddr_in); `' r0 E% D$ N+ {3 y+ z1 p1 m& d
- char msgbuffer[256]; I. [& ]5 o# x. O
- char msgsend[] = "Welcome To Demon Server";4 f% g7 |; Z, d% `% R/ e" E
- fd_set fds;. N. {. M* G* F$ S0 b9 H3 c
- / b, e7 H$ C+ l4 {! `- ]
- //创建套接字
& ]$ ?7 l( g" ` - sockfd = socket(AF_INET,SOCK_STREAM,0);: l) g! g i+ l, `
- if(sockfd>=0)
! Z2 {7 Y5 z+ n7 L0 w$ E$ B* W - printf("open socket: %d\n",sockfd);
4 G0 V5 h* k e0 Y$ f& B; W0 q- Z - % e1 Q- @' s% v
- //将本地端口和监听地址信息保存到套接字结构体中
`: v, [4 m4 c/ i - bzero(&addr,sizeof(addr));
" Z, V$ x* a0 N) f5 ^" p$ J$ \2 T - addr.sin_family=AF_INET;
8 O, F3 t+ U4 h+ U+ i( u, e - addr.sin_port=htons(LOCAL_PORT);
' n6 R. q% L! ?" P5 g - addr.sin_addr.s_addr = htonl(INADDR_ANY); //INADDR_ANY表示任意地址0.0.0.0 0.0.0.01 u/ i+ z. j8 E% X# S
- 8 Z" J0 S/ H" {0 o
- //将套接字于端口号绑定
7 K) y2 ]8 P/ Y7 E5 G2 K - if(bind(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)
. ~' B1 a9 n% X, S5 R" x - printf("bind the port: %d\n",LOCAL_PORT);
8 _3 q* i k! h9 `1 y* H) G -
% N* O# K6 t( V% v" y7 d2 o2 A% C4 T - //开启端口监听
# i" R+ @: p; M/ l3 r - if(listen(sockfd,3)>=0)! z! `; M* t' P9 p! B) N1 d: j0 }
- printf("begin listenning...\n");
( \- Q& U) d5 W4 n7 [+ S -
4 }+ T, x: V. | - //默认所有fd没有被打开: u |; V5 T% M& Y! s# \3 x# H7 C
- for(fd=0;fd<MAX;fd++)" p+ ~. F3 F- B
- is_connected[fd]=0;
( s! Q) a2 M7 X; n* k+ U' l - ( }8 h- @' F1 q _2 g
- while(1){
) @% P- Q0 x( G; t& J6 N. U - //将服务端套接字加入集合中. X- h# F- l7 ]4 Z+ \# V
- FD_ZERO(&fds);# Z) m7 f1 `8 j7 x
- FD_SET(sockfd,&fds);
. E4 G8 i9 M4 r K3 K5 L: R -
( z& a& N# ~# U, T+ J - //将活跃的套接字加入集合中
3 g1 Y( l6 N3 L( a - for(fd=0;fd<MAX;fd++)
8 R1 d$ h3 U3 R3 }0 `) T4 o - if(is_connected[fd])
3 s0 S Q# _$ N; y" w) W8 S - FD_SET(fd,&fds);& Y4 V C$ {8 n3 t- T. Z
- ! {6 S- g- y( g" w
- //监视集合中的可读信号,如果某个套接字有信号则继续执行,此时集合中只有存在信号的套接字会被置为1,其他置为06 s9 { D& v0 I& @# N/ \+ \, [; |& z
- if(!select(MAX,&fds,NULL,NULL,NULL))7 L y4 ]" R9 ]6 X
- continue;4 I3 b$ [: [, M$ @% W# K- C; v
- 9 a) f. L2 ?( f( \# O! Q3 T M; t
- //遍历所有套接字判断是否在属于集合中的活跃套接字
0 e+ l5 T4 c0 i- @, a4 \+ Z - for(fd=0;fd<MAX;fd++){2 h( D7 J4 O& M8 ~9 }
- if(FD_ISSET(fd,&fds)){4 X c. t5 W% K7 G
- if(fd==sockfd){ //如果套接字是服务端,那么与客户端accept建立连接
" P/ f& z% j9 z8 N - connfd = accept(sockfd,(struct sockaddr*)&addr,&addr_len); U9 a' S- ^2 k& H0 z" f3 I
- write(connfd,msgsend,sizeof(msgsend)); //向其输出欢迎语1 l4 l9 Y `" m* R+ V
- is_connected[connfd]=1; //对客户端的fd对应下标将其设为活跃状态,方便下次调用+ s3 b3 F' I3 R
- printf("connected from %s\n",inet_ntoa(addr.sin_addr));! V& A( I/ }. D' z' u0 O1 l: E2 Q
- }else{ //如果套接字是客户端,读取其信息并返回,如果读取不到信息,冻结其套接字
! Q7 i9 K; D# Q9 ^ - if(read(fd,msgbuffer,sizeof(msgbuffer))>0){ # ?) s$ g9 Q f. m. i" K
- write(fd,msgbuffer,sizeof(msgbuffer));# ]/ k! y1 S r1 k) O
- printf("[read]: %s\n",msgbuffer);% K8 k5 g& W) Q
- }else{
, {% E" }# t7 ?0 j - is_connected[fd]=0;* y0 \% U: w2 \( ]3 f2 y
- close(fd);
. w* ?; P8 i0 |& o- s - printf("close connected\n");
- X; k2 o1 k- F0 }7 }7 w - }
- F, n) q- D" _+ ] - }$ w" ~6 V9 y$ i2 K6 e A8 `7 |# |5 d
- }! k. h+ f# ^% ^ g
- }
5 z+ v T6 r9 J( N - }
. ^7 j( g) q7 ]3 D - }
复制代码
' N, t& f- m0 u* {" N
9 U- y5 t; d/ P: Z' F& _
$ W& I0 J1 i7 G8 y {" k0 ?- P0 ]: d
: R% K. H5 C. ~( R
3 |0 M3 \6 k: D! o$ t6 R4 e |