实验环境是linux系统,效果如下: 1.启动服务端程序,监听在6666端口上 2.启动客户端,与服务端建立TCP连接 3.建立完TCP连接,在客户端上向服务端发送消息 4.断开连接 实现的功能很简单,但是对于初来乍到的我费了不少劲,因此在此总结一下,如有错点请各位大神指点指点
* S6 K# [1 i$ h8 h7 `$ X什么是SOCKET(插口): 这里不用 "套接字" 而是用 "插口" 是因为在《TCP/IP协议卷二》中,翻译时也是用 "插口" 来表示socket的。
+ b% J# u6 Q o" n, T E "套接字" 这词不知道又是哪个教授级人物造出来的,听起来总是很怪,虽然可以避免语义上的歧义,但不明显。 对插口通俗的理解就是:它是一个可以用来输入或者输出的网络端,另一端也具有同样相对应的操作。 具体其他高级的定义不是这里的重点。值得说的是: 每个插口都可以标识某个程序通信的一端,通过系统调用使得程序与网络设备之间的交流连接起来。 应用程序 -> 系统调用 -> 插口层 -> 协议层 -> 接口层 ->发送(接收的话与之相反)% H8 W6 E0 c, R; W. ~( B+ o
! t* T+ H7 _$ \
P; @" s& Y& R. \% t, L" V7 o如何标识一个SOCKET: 如上定义所述,可以通过地址,协议,端口三要素来确定一个通信端,而在linux C程序中使用 标识符 来标识一个 SOCKET,Unix系统对设备的读写操作等同于对描述符的读写操作,标识符可以用于:插口 管道 目录 设备 文件等等
3 ^6 ~ |6 B3 N3 y. z9 m/ t 描述符是个正整数,事实上他是检查表表项中的一个下标,用于指向打开文件表的结构。 述符前三个标识符0 1 2 分别系统保留:标准输入(键盘),标准输出(屏幕),标准错误输出 当我们使用新的描述符来创建socket时,他一般从最小未使用的数字开始分配,也就是3 " d' M6 D/ C9 V
( P& `! N9 U4 }) C6 [; r& X
服务端实现的流程: 1.服务端开启一个SOCKET(socket函数) 2.使用SOCKET绑定一个端口号(bind函数) 3.在这个端口号上开启监听功能(listen函数) 4.当有对端发送连接请求,向其发送ack+syn建立连接(accept函数) 5.接收或者回复消息(read函数 write函数) [: S6 m; A" }/ W! M& V5 r/ B# E
( t$ {- u6 [- Z" z客户端实现流程: 1.打开一个SOCKET 2.向指定的IP 和端口号发起连接(connect函数) 3.接收或者发送消息(send函数 recv函数)
( V( {& f1 F7 Q+ ~8 n* b6 ~3 @+ Z E/ o& u( r3 e$ |) k
7 T! a$ F# e' Y如何并发处理: 如果按照以上流程实现其实并不难,但是有个缺陷,因为C语言是按顺序单一流程运行,也就是说如果 直接在程序当中使用accept函数(建立连接)的话,那么程序会阻塞在accept这里,这是因为如果客户端 一直没有发送connect连接,那么accept就无法得知客户端的IP和端口,也就只能一直等待(阻塞)直到 有请求触发继续执行为止,这样就导致如果同时多个客户向服务端发送请求连接,那么服务端只能按照 单一线程去处理第一个客户端,无法开启多个线程同时处理多个用户的请求。 + @9 B G" a3 D4 {8 h% K
/ @3 z! V- _9 T+ q$ u2 c
如何解决: 下面摘文截取网上的资料,有兴趣者可以看看 系统提供select函数来实现多路复用输入/输出模型,该函数用于在非阻塞中,当一个套接字或一组套接字有信号时通知你 - int select(int nfds, fd_set *readfds, fd_set *writefds, exceptfds, const struct timeval* timeout);
复制代码所在的头文件为: - #include <sys/time.h>
. @, O/ y3 c7 S2 H1 c - % m [9 w" `; D: m d) {
- #include <unistd.h>
复制代码 功能:测试指定的fd是否可读,可写 或者 是否有异常条件待处理 3 ]8 u3 i9 E4 p5 p7 U
readset 用来检查可读性的一组文件描述字。 4 B8 `& h+ M( X3 g0 I
writeset 用来检查可写性的一组文件描述字。 " G& g8 Q9 Y$ C3 x0 D. W# q: [
exceptset用来检查是否有异常条件出现的文件描述字。(注:不包括错误) 2 B& p9 [4 x1 n- g i& r
timeout 用于描述一段时间长度,如果在这个时间内,需要监视的描述符没有事件发生则函数返回,返回值为0。
0 u0 o7 U. y( c( `4 V. E$ v" K6 m* D
对于select函数的功能简单的说就是对文件fd做一个测试。测试结果有三种可能:* g6 c* C$ t7 ^, y2 j4 i: a
6 D& Z. {# o+ D% U: q- 1.timeout=NULL (阻塞:select将一直被阻塞,直到某个文件描述符上发生了事件)& ]+ X7 w& \- o1 N5 j* N a4 N
- * b! V* W- C" C# e: v
- 2.timeout所指向的结构设为非零时间 (等待固定时间:如果在指定的时间段里有事件发生或者时间耗尽,函数均返回)
, e5 q' E' Z4 Z - 0 a5 s$ Q# v; w4 P7 [5 z% _% I
- 3.timeout所指向的结构,时间设为0 (非阻塞:仅检测描述符集合的状态,然后立即返回,并不等待外部事件的发生)
复制代码 返回值: 返回对应位仍然为1的fd的总数。注意啦:只有那些可读,可写以及有异常条件待处理的fd位仍然为1。 否则为0哦。举个例子,比如recv(), 在没有数据到来调用它的时候,你的线程将被阻塞,如果数据一直不来, 你的线程就要阻塞很久.这样显然不好。所以采用select来查看套节字是否可读(也就是是否有数据读了) 。 现在,UNIX系统通常会在头文件<sys/select.h>中定义常量FD_SETSIZE,它是数据类型fd_set的描述字数量, 其值通常是1024,这样就能表示<1024的fd。* }4 ?! t5 f1 ~2 T; L$ x R
! r; u$ {: U H) u* @) S
6 I% r; D( x. r& \) w$ B. E fd_set结构体: 文件描述符集合,用于存放多个fd(文件描述符,这里就是套接字) 可以存放服务端的fd,有客户端的fd。下面是对这个文件描述符集合的操作: - FD_ZERO(*fds): 将fds设为空集3 v- y; A% z& F+ K) Z& `
- 0 @: ^. T9 o/ w. X; y
- FD_CLR(fd,*fds): 从集合fds中删除指定的fd
2 _! c; K4 T5 _! }$ f' S Y - 4 j2 ^/ l% {$ `5 R( Y& Z
- FD_SET(fd,*fds): 从集合fds中添加指定的fd
! K! D: {+ a2 O - ( G9 V( k( \8 G( |
- FD_ISSET(fd,*fds): 判断fd是否属于fds的集合
复制代码步骤如下 - socket s;
: A) ?0 Q/ j2 h0 q1 B w$ X5 c% k( w - ....." P L6 n: g- `% i
- fd_set set;
: J: M7 s2 a; }4 J - while(1){/ f, I+ Z0 l2 ]
- FD_ZERO(&set); //将你的套节字集合清空
% i% m" m! H$ O8 P - FD_SET(s, &set); //加入你感兴趣的套节字到集合,这里是一个读数据的套节字s8 A/ a8 g6 i( O2 k
- select(0,&set,NULL,NULL,NULL); //检查套节字是否可读,+ G4 V6 K" a0 s; V6 R
- if(FD_ISSET(s, &set) //检查s是否在这个集合里面,5 w0 w u9 _0 a" U' t/ o* I' w
- { //select将更新这个集合,把其中不可读的套节字去掉
' ?6 o. }, T: H, f - //只保留符合条件的套节字在这个集合里面. b( c7 J' K a# k
- recv(s,...);
9 L2 |) z! _3 V* Q7 m- H" H - }
6 g2 z. D& X- m - //do something here' N7 w5 |# f8 w! A8 v4 S
- }
复制代码假设fd_set长度为1字节,fd_set中的每一位可以对应一个文件描述符,那么1字节最大可以对应8个fd - (1)执行fd_set set; FD_ZERO(&set); 则set用位为0000,0000。
9 ]( S% G1 r* o/ b1 B% S
: ?6 @( L* C/ m1 Q, O+ Z- (2)若fd=5,执行FD_SET(fd,&set); 后set变为 0001,0000(第5位置为1)8 `& c" d. \/ N8 n. n
- 2 F* d0 s5 T2 @
- (3)若再加入fd=2,fd=1 则set变为 0001,0011. X* o% A9 V' n( s5 V4 @
- ) ?/ o6 a* E8 d1 ?, p; B6 r, M
- (4)执行select(6,&set,0,0,0) 阻塞等待
/ g0 _! p. D- y/ `. F8 _. B, r. R - - w3 f* f; m" e$ K, }$ _* 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.具体过程看代码会好理解 ) @+ f6 ]8 \) u: u l/ V2 I% |; \
$ j2 j, C1 h; Z7 P0 \8 B6 a
使用select函数的过程一般是:
2 B* O; c' B$ ]0 ^/ W5 l6 { 先调用宏FD_ZERO将指定的fd_set清零,然后调用宏FD_SET将需要测试的fd加入fd_set,
接着调用函数select测试fd_set中的所有fd,最后用宏FD_ISSET检查某个fd在函数select调用后,相应位是否仍然为1 复制粘贴的摘文排版起来真的是痛苦,我已经尽力排版了。。。5 l* o+ w& K, E% M
- X& m& P# o0 b客户端: - #include <time.h>
& n; |7 L# @' V5 [6 h; m0 f - #include <stdio.h>& Q: `- h& t) ]. ]" }
- #include <stdlib.h>. ]& y% Q5 E3 }! f: E# i" }6 A+ _
- #include <string.h>5 l# u9 w# d) p
- #include <unistd.h>
) w9 T2 X8 z( Z9 A' G' J2 d; J - #include <arpa/inet.h>
& Z' v, _8 T3 k7 I" L# \$ N' W: k - #include <netinet/in.h>( g+ Z! c7 J" c# z2 z- i) l
- #include <fcntl.h>, J' P$ D; h1 q
- #include <sys/stat.h>
$ A2 m( |5 U9 V - #include <sys/types.h>
/ I0 R& J/ O! V# p1 i" k - #include <sys/socket.h>0 z# b" A' C( S" L) k4 z
- 6 _: k! y, H. @8 } s
- #define REMOTE_PORT 6666 //服务器端口" c5 M O! ^/ U: L
- #define REMOTE_ADDR "127.0.0.1" //服务器地址, g% s- |3 B1 o
-
: m2 I/ H; ^' M* X2 z+ ] - int main(){+ D/ l: D* T1 s4 k1 W6 @
- int sockfd;
5 Y; \7 ]; Q# b. t1 p& E/ K - struct sockaddr_in addr;$ r" L# s: B1 |% ~) Z( V2 B( r
- char msgbuffer[256];) Z: L8 H5 t! I9 }, D8 f
- 8 x2 {/ _% e( u5 G
- //创建套接字* |( D0 [, s1 `, O# Z. m# M
- sockfd = socket(AF_INET,SOCK_STREAM,0);% S+ |7 @0 N$ q
- if(sockfd>=0)
7 x7 K" t' m& |1 B; V) K' N2 g - printf("open socket: %d\n",sockfd);/ i1 ]8 n y, i+ H5 h
-
6 _; U: L' r" x' v$ F* b - //将服务器的地址和端口存储于套接字结构体中- S7 X) k+ L, c% u5 P% T4 h
- bzero(&addr,sizeof(addr));6 [, H g& a$ ^8 Y5 P- m9 ~
- addr.sin_family=AF_INET;
( ]3 _4 ?' a A( h' m K" o - addr.sin_port=htons(REMOTE_PORT);
1 ]- ?- V) d5 G5 M1 k, X4 i2 O9 Q1 X- W& L - addr.sin_addr.s_addr = inet_addr(REMOTE_ADDR);
8 e: Y3 |1 C7 ?* A8 M) L! R - ' H' e# O( D/ g% D
- //向服务器发送请求
' w, P. h9 O( M# P - if(connect(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)
, ~9 @! {! I( b! \# C - printf("connect successfully\n");
' F7 e0 M& K' o) R; b -
# l: {2 B" `- A3 z - //接收服务器返回的消息(注意这里程序会被阻塞,也就是说只有服务器回复信息,才会继续往下执行)
2 A1 o- G) [# q1 p- M: V - recv(sockfd,msgbuffer,sizeof(msgbuffer),0);
9 O. F' [1 { _; Q$ e9 `7 E' g - printf("%s\n",msgbuffer);
9 G- J8 Z- z9 U' k% e- e - + f2 D% z+ E) r0 J! X6 f- a4 s
- while(1){
0 G' O* r; q; p - //将键盘输入的消息发送给服务器,并且从服务器中取得回复消息4 a$ k& M/ U# j+ V% K
- bzero(msgbuffer,sizeof(msgbuffer));& _) e6 ]0 q. Q `* P/ G6 \( M
- read(STDIN_FILENO,msgbuffer,sizeof(msgbuffer));
+ z" g* ? q. g# T, {6 P3 P - if(send(sockfd,msgbuffer,sizeof(msgbuffer),0)<0)" b/ T. i: A" H8 J" Q. H
- perror("ERROR");
* U1 k! I D% R" ` -
3 t' W6 c4 t, h8 M# N - bzero(msgbuffer,sizeof(msgbuffer));$ g3 @* N/ D& T. E; q
- recv(sockfd,msgbuffer,sizeof(msgbuffer),0);; ]' u! g8 }+ x% g6 p0 k5 l6 Q
- printf("[receive]:%s\n",msgbuffer);% |% t. }; @6 I! P2 v- j/ Q$ `' Q
-
4 s0 y% f) x. _6 m+ [$ l! w - usleep(500000);+ N/ W o3 {, N( A3 A
- }' S& E3 D' O3 i8 Y) m( y" j9 W0 s
- }
复制代码
/ L+ E& x @5 P$ x: m: v) b
- C: I6 o: i* p服务端: - #include <time.h>+ p0 g" l) | S, J
- #include <stdio.h>
2 N* O/ C0 P0 _: u6 N - #include <stdlib.h>" K' J5 K4 G/ X" E+ K
- #include <string.h>, Q6 A- |1 F |/ @
- #include <unistd.h>
* P: r/ a0 Q: E0 b7 e7 \* B% C/ Q8 h - #include <arpa/inet.h>
" J2 f; a) \1 ^ - #include <netinet/in.h>& ?% l# |- {0 M8 ^4 p
- #include <sys/types.h>
7 q4 f1 ~) z. M/ n* o+ [ - #include <sys/socket.h>
* @3 l8 }# z4 d$ Z; Q -
+ @4 O8 d4 m& r0 B E. e, T - #define LOCAL_PORT 6666 //本地服务端口0 A5 I1 v& G5 d- l- [
- #define MAX 5 //最大连接数量
- }" c5 P" ]. G, I -
- Y2 i3 d ^) C" p; X- h - int main(){
& _9 _, N5 m" X0 f5 i* s - int sockfd,connfd,fd,is_connected[MAX];7 ^) k* x) W2 `* Z" s b
- struct sockaddr_in addr;
( c/ i! o5 L/ e - int addr_len = sizeof(struct sockaddr_in);
: q5 H9 F' d$ r) {' O% X* F - char msgbuffer[256];
3 d1 Q' n8 K3 y& L/ ^* [ - char msgsend[] = "Welcome To Demon Server";) E( o$ |: x& {/ o5 F& ~
- fd_set fds;" C" g6 Z. }' K* v
- 5 Q5 j& U& S; M" H% D! n' I
- //创建套接字. \8 F* u) G, {. @* [# w
- sockfd = socket(AF_INET,SOCK_STREAM,0);
0 Y5 D7 h9 X$ _. T v - if(sockfd>=0): Y3 z) T( F- U9 Q2 N
- printf("open socket: %d\n",sockfd);5 E. I9 K q+ A$ \: W
-
* \- m7 e0 W5 z - //将本地端口和监听地址信息保存到套接字结构体中
% S4 z) f! ^, n8 v - bzero(&addr,sizeof(addr));
- y$ z( b b8 o: ?8 ~1 H - addr.sin_family=AF_INET;2 X( `4 w5 u8 |- m) u) N; D# @
- addr.sin_port=htons(LOCAL_PORT);+ P; A2 Z4 k0 A t P; p
- addr.sin_addr.s_addr = htonl(INADDR_ANY); //INADDR_ANY表示任意地址0.0.0.0 0.0.0.0, E1 K Q1 f% A4 j1 v
- 7 c* N7 @9 m3 y5 U
- //将套接字于端口号绑定
, J; x7 J; e+ ?; b& w - if(bind(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)
' y1 h, c- X& {; |! X - printf("bind the port: %d\n",LOCAL_PORT);
6 W8 m# W$ ]1 T$ S2 Y, C* g -
R: W( h1 S: K. P8 v - //开启端口监听1 ^8 J$ F5 C, J/ _# n
- if(listen(sockfd,3)>=0)
4 X+ @1 Z3 C( Q0 t - printf("begin listenning...\n");! N1 ]6 j0 w7 f( `& n$ ?0 c) k( `; U" `
- # r& Y9 i! x; C$ o7 a: f6 U' o
- //默认所有fd没有被打开) h# D1 W+ @3 [7 ?* \7 I0 Y2 s
- for(fd=0;fd<MAX;fd++)
" W, d, d8 i3 ?3 \" |/ x5 H u - is_connected[fd]=0;
4 { U) V" f8 ~( A7 ~" p' H - ) E. y+ L9 h- H
- while(1){6 A# Q5 J. I7 z8 w
- //将服务端套接字加入集合中
/ |6 \& n6 {" i z* s9 M - FD_ZERO(&fds);. `, ]. ^* B" ^* x# o/ N* `) P
- FD_SET(sockfd,&fds);
9 l6 ?9 Z( A- G0 `% u& u - ( Q& E1 ^3 E$ s. _# M" i$ Y P( _
- //将活跃的套接字加入集合中
3 ] t4 y8 p" n) Q. J; c - for(fd=0;fd<MAX;fd++)
6 ?* g/ g( ]8 Q/ p/ `! j - if(is_connected[fd])
" w b! C1 B Q; j - FD_SET(fd,&fds);
* o( b& G% I6 N Z$ X -
% ~) [9 G" ~) g* Z - //监视集合中的可读信号,如果某个套接字有信号则继续执行,此时集合中只有存在信号的套接字会被置为1,其他置为0" u# I3 z0 p P) X7 Z
- if(!select(MAX,&fds,NULL,NULL,NULL))4 d: l9 u' P, y' T5 v* C0 D+ |
- continue;# @" L8 A2 H7 W( `
-
, G3 N9 q+ I1 x - //遍历所有套接字判断是否在属于集合中的活跃套接字
7 F7 J! q9 V* U, T4 j1 o/ h) N. H - for(fd=0;fd<MAX;fd++){
8 P$ F+ ]7 S, A+ [+ L - if(FD_ISSET(fd,&fds)){
, D L( r: S3 [0 V - if(fd==sockfd){ //如果套接字是服务端,那么与客户端accept建立连接
9 Y O* r2 P$ `. p/ y3 D6 @- W - connfd = accept(sockfd,(struct sockaddr*)&addr,&addr_len);* ]8 X8 I( Y& [# U
- write(connfd,msgsend,sizeof(msgsend)); //向其输出欢迎语) w; [; }" R* _5 A5 Q" q; m! o+ Y& [
- is_connected[connfd]=1; //对客户端的fd对应下标将其设为活跃状态,方便下次调用* e. I a/ k2 U3 G- x+ |
- printf("connected from %s\n",inet_ntoa(addr.sin_addr));
f& A# I+ \6 L - }else{ //如果套接字是客户端,读取其信息并返回,如果读取不到信息,冻结其套接字
* w- a1 o$ |! ?$ _) v - if(read(fd,msgbuffer,sizeof(msgbuffer))>0){ % h$ l& e( Z/ Y ~' U8 `6 p
- write(fd,msgbuffer,sizeof(msgbuffer));7 c. i( m, `( t
- printf("[read]: %s\n",msgbuffer);3 c E+ d' _* q+ o& I6 g9 W
- }else{
: D- }9 ^; ?5 ^; C3 p1 P a4 s - is_connected[fd]=0;
; _# ~4 C+ |4 B7 @ - close(fd);8 A# g. n* T$ U# q" [" H
- printf("close connected\n");3 B* X, ?$ o# |) `# P! v$ S4 P
- }
) x9 O! W) g1 T - }' t0 e' a! X, ^, K/ ~# T; ~2 P0 Q ^
- }
2 A: j* }! D4 j k1 L* F - }. G3 A% g7 Y0 K2 }( S5 s6 E& z
- }# F7 B. f# @/ M
- }
复制代码 2 f0 ~3 e$ W1 I# ?7 R( G
& W" J1 }$ [/ b9 W/ J2 m
- p) J8 e1 i( j4 ]1 H7 z+ g9 r5 q- Q+ P% M( L6 P
+ A) Y- d! ]5 t) Z7 q* h+ E
$ f) G9 R, v6 x2 b* { |