实验环境是linux系统,效果如下: 1.启动服务端程序,监听在6666端口上 2.启动客户端,与服务端建立TCP连接 3.建立完TCP连接,在客户端上向服务端发送消息 4.断开连接 实现的功能很简单,但是对于初来乍到的我费了不少劲,因此在此总结一下,如有错点请各位大神指点指点 2 d2 X5 [, V' F* t; m, S
什么是SOCKET(插口): 这里不用 "套接字" 而是用 "插口" 是因为在《TCP/IP协议卷二》中,翻译时也是用 "插口" 来表示socket的。# u- a- s( N2 r0 m
"套接字" 这词不知道又是哪个教授级人物造出来的,听起来总是很怪,虽然可以避免语义上的歧义,但不明显。 对插口通俗的理解就是:它是一个可以用来输入或者输出的网络端,另一端也具有同样相对应的操作。 具体其他高级的定义不是这里的重点。值得说的是: 每个插口都可以标识某个程序通信的一端,通过系统调用使得程序与网络设备之间的交流连接起来。 应用程序 -> 系统调用 -> 插口层 -> 协议层 -> 接口层 ->发送(接收的话与之相反)4 j7 z: [- p0 W8 x
! L- K* J2 l6 C
; X4 d. M+ @" m如何标识一个SOCKET: 如上定义所述,可以通过地址,协议,端口三要素来确定一个通信端,而在linux C程序中使用 标识符 来标识一个 SOCKET,Unix系统对设备的读写操作等同于对描述符的读写操作,标识符可以用于:插口 管道 目录 设备 文件等等
7 j% I' w. f; D; Y; e 描述符是个正整数,事实上他是检查表表项中的一个下标,用于指向打开文件表的结构。 述符前三个标识符0 1 2 分别系统保留:标准输入(键盘),标准输出(屏幕),标准错误输出 当我们使用新的描述符来创建socket时,他一般从最小未使用的数字开始分配,也就是3
9 V1 p3 R3 m% ]
$ E: n9 Y7 c5 G. `+ r服务端实现的流程: 1.服务端开启一个SOCKET(socket函数) 2.使用SOCKET绑定一个端口号(bind函数) 3.在这个端口号上开启监听功能(listen函数) 4.当有对端发送连接请求,向其发送ack+syn建立连接(accept函数) 5.接收或者回复消息(read函数 write函数) " I3 `( E/ Q- D" h# s2 K+ G
4 o- d* @6 w& `8 E. X0 m客户端实现流程: 1.打开一个SOCKET 2.向指定的IP 和端口号发起连接(connect函数) 3.接收或者发送消息(send函数 recv函数)
, R( i2 v6 D' K% ] f
( ]: I& x$ A+ X, E5 o- F) M$ t: b! |7 R# x9 l- V7 r0 f
如何并发处理: 如果按照以上流程实现其实并不难,但是有个缺陷,因为C语言是按顺序单一流程运行,也就是说如果 直接在程序当中使用accept函数(建立连接)的话,那么程序会阻塞在accept这里,这是因为如果客户端 一直没有发送connect连接,那么accept就无法得知客户端的IP和端口,也就只能一直等待(阻塞)直到 有请求触发继续执行为止,这样就导致如果同时多个客户向服务端发送请求连接,那么服务端只能按照 单一线程去处理第一个客户端,无法开启多个线程同时处理多个用户的请求。 9 m! j) [9 Q; I) _4 l9 \( `1 C3 t0 B
* }4 M/ x3 l3 p如何解决: 下面摘文截取网上的资料,有兴趣者可以看看 系统提供select函数来实现多路复用输入/输出模型,该函数用于在非阻塞中,当一个套接字或一组套接字有信号时通知你 - int select(int nfds, fd_set *readfds, fd_set *writefds, exceptfds, const struct timeval* timeout);
复制代码所在的头文件为: - #include <sys/time.h>( u4 `* R, `8 L/ Z/ }7 P" H
+ T, L& P$ \0 r9 q7 l4 o/ U: a( j- #include <unistd.h>
复制代码 功能:测试指定的fd是否可读,可写 或者 是否有异常条件待处理 , { a9 s. j0 e) J; Y+ |
readset 用来检查可读性的一组文件描述字。 3 I+ |4 \1 O- d4 m5 N: _- u
writeset 用来检查可写性的一组文件描述字。 . g2 H9 D, G$ ?! t0 v2 H f z y
exceptset用来检查是否有异常条件出现的文件描述字。(注:不包括错误)
, C1 @3 I0 |: l timeout 用于描述一段时间长度,如果在这个时间内,需要监视的描述符没有事件发生则函数返回,返回值为0。
8 @; J6 Q# ]- j, U
. w* A+ f# n! q5 Q, n0 ], K 对于select函数的功能简单的说就是对文件fd做一个测试。测试结果有三种可能:8 K2 C1 b4 |8 i# g _ h3 Z
& m- b# {; ^3 p. L3 @- 1.timeout=NULL (阻塞:select将一直被阻塞,直到某个文件描述符上发生了事件)
2 t" \( D3 B4 [ - * F( i7 E; ?# B# O! P4 \* V+ H3 @0 z
- 2.timeout所指向的结构设为非零时间 (等待固定时间:如果在指定的时间段里有事件发生或者时间耗尽,函数均返回)9 ]2 Y+ z. F5 K2 O9 `) J
- 2 t) b0 T' @; S% n$ s' m/ R
- 3.timeout所指向的结构,时间设为0 (非阻塞:仅检测描述符集合的状态,然后立即返回,并不等待外部事件的发生)
复制代码 返回值: 返回对应位仍然为1的fd的总数。注意啦:只有那些可读,可写以及有异常条件待处理的fd位仍然为1。 否则为0哦。举个例子,比如recv(), 在没有数据到来调用它的时候,你的线程将被阻塞,如果数据一直不来, 你的线程就要阻塞很久.这样显然不好。所以采用select来查看套节字是否可读(也就是是否有数据读了) 。 现在,UNIX系统通常会在头文件<sys/select.h>中定义常量FD_SETSIZE,它是数据类型fd_set的描述字数量, 其值通常是1024,这样就能表示<1024的fd。( M8 M6 p# N# e4 {
% x Q( W* k4 C4 D0 F
6 e4 {* C. S9 s& D
fd_set结构体: 文件描述符集合,用于存放多个fd(文件描述符,这里就是套接字) 可以存放服务端的fd,有客户端的fd。下面是对这个文件描述符集合的操作: - FD_ZERO(*fds): 将fds设为空集
" G4 b7 C. @0 W: ?6 U$ S( h - ; T9 ~ L6 t7 N. J
- FD_CLR(fd,*fds): 从集合fds中删除指定的fd, e4 w; i+ P+ F+ n4 s
5 M# ~, \2 W8 H( [' s- FD_SET(fd,*fds): 从集合fds中添加指定的fd" m H8 D: S4 b- l; V, @, ~' S
2 m+ T* I1 X7 a/ {" f' T- FD_ISSET(fd,*fds): 判断fd是否属于fds的集合
复制代码步骤如下 - socket s;
; @1 ~( C Z% x) \. n+ Y1 j2 H: P - .....
# Q3 w8 t5 Y9 ^% o; |+ O - fd_set set;
$ n( y) m! D' C" q! T& X: q - while(1){9 y3 s" ? W+ C- e1 v$ A6 Q& T: h
- FD_ZERO(&set); //将你的套节字集合清空
$ h3 p) j/ Q- U, ^' p - FD_SET(s, &set); //加入你感兴趣的套节字到集合,这里是一个读数据的套节字s
. L+ X% L( {, x. P0 ~ - select(0,&set,NULL,NULL,NULL); //检查套节字是否可读,; p' L5 t( b( r7 N$ O1 i
- if(FD_ISSET(s, &set) //检查s是否在这个集合里面,
+ `, Q7 ?9 j! t) [ - { //select将更新这个集合,把其中不可读的套节字去掉
3 U/ U3 a# p' N) k" J) |& ? - //只保留符合条件的套节字在这个集合里面' }, b- H |% ^. s
- recv(s,...);8 U8 A* ?& w, i( X* m
- }
$ l7 }# Y! ^8 |/ N( b( A - //do something here
' I5 T% v; t( Q: d - }
复制代码假设fd_set长度为1字节,fd_set中的每一位可以对应一个文件描述符,那么1字节最大可以对应8个fd - (1)执行fd_set set; FD_ZERO(&set); 则set用位为0000,0000。
8 c( v4 \% L+ I, x
- I/ K# N! U: ]1 O0 E- (2)若fd=5,执行FD_SET(fd,&set); 后set变为 0001,0000(第5位置为1)
, X. R: \1 T/ \6 R! t! b8 }, }/ r3 K
7 W3 q( Q7 I# V- `5 B- (3)若再加入fd=2,fd=1 则set变为 0001,0011
3 N! t5 Z* z! l7 G# s7 ^" ^
, {1 i+ g4 `# x5 U( E1 H. c- (4)执行select(6,&set,0,0,0) 阻塞等待* h- D; F' m4 b
. n6 j5 U4 T- P k1 V- (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.具体过程看代码会好理解 8 a) l2 ]/ [% n% `$ ]( G; R+ t
* l" p( N$ @6 u& x) i6 s$ u使用select函数的过程一般是:
' b2 T: u+ W8 a. ~6 b0 O 先调用宏FD_ZERO将指定的fd_set清零,然后调用宏FD_SET将需要测试的fd加入fd_set,
接着调用函数select测试fd_set中的所有fd,最后用宏FD_ISSET检查某个fd在函数select调用后,相应位是否仍然为1 复制粘贴的摘文排版起来真的是痛苦,我已经尽力排版了。。。
# k, j$ F* ]5 E* ^$ J& Q: V
) m! b5 Z" n5 K1 o6 v+ Z! Z客户端: - #include <time.h>7 c* [( [0 Y. C/ L+ t0 p
- #include <stdio.h>
2 C8 O `& z p- Q0 x - #include <stdlib.h>1 o0 w. c$ B4 l% A
- #include <string.h>
7 D2 \4 ?3 H( B# r& A* P - #include <unistd.h>
7 I; o' k U5 z* [& O% c W - #include <arpa/inet.h>
1 b, h+ O$ O" p4 M* p+ h - #include <netinet/in.h>
! t3 A5 V' d* a0 ?$ o x - #include <fcntl.h>2 a1 L: E$ K1 K: Y' q2 E* h
- #include <sys/stat.h>
$ R+ u6 n. j. X1 ] - #include <sys/types.h>, t+ s5 V" u3 Y D0 h
- #include <sys/socket.h>" {$ r/ j0 A6 V" h X4 e) X- r
-
) w! c4 X1 O! p' t& L - #define REMOTE_PORT 6666 //服务器端口
: X3 f, S g0 C Q - #define REMOTE_ADDR "127.0.0.1" //服务器地址9 P% j9 W8 G3 f6 P- D
- * M3 L, X7 |8 k% Z1 ]! Z
- int main(){
( U6 ], Z1 [% G' \ - int sockfd;
+ {1 Q# O. d. K% n5 X - struct sockaddr_in addr;3 F/ j; l1 ]- P% R+ X
- char msgbuffer[256];4 S; _% }, _. f: R
-
7 N. {3 g+ E( |- z - //创建套接字
9 H9 }$ K; P, { - sockfd = socket(AF_INET,SOCK_STREAM,0);9 r$ `8 N7 k" ^" \5 b
- if(sockfd>=0)2 n, Q' d a. O# M: y- p
- printf("open socket: %d\n",sockfd);- X1 T6 R- k( ]# N' j" d' m) @
- * B: ]7 ]& L, P' q
- //将服务器的地址和端口存储于套接字结构体中3 n2 `4 Y8 Q4 V0 t
- bzero(&addr,sizeof(addr));
/ D5 t* O8 b1 d" M" }5 F - addr.sin_family=AF_INET;
" J( Y' [1 u6 l2 }, e! q& ` - addr.sin_port=htons(REMOTE_PORT);
' i: n5 f! w' n; o( L - addr.sin_addr.s_addr = inet_addr(REMOTE_ADDR); b7 ^9 A7 w4 T1 [9 {
- , ]% L" p4 N( W1 o. K6 i5 g
- //向服务器发送请求
: ?- q( |+ ?6 V) |5 a - if(connect(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)' }3 L. ~* X+ E4 k; P
- printf("connect successfully\n");# B5 b7 [0 K( m( e( C
- " A/ Y0 m8 ~5 \! @3 |
- //接收服务器返回的消息(注意这里程序会被阻塞,也就是说只有服务器回复信息,才会继续往下执行). T- l; {+ W5 _! X- |1 e
- recv(sockfd,msgbuffer,sizeof(msgbuffer),0);
2 p% ?0 [ d% L - printf("%s\n",msgbuffer);& ]# e% ~- |, y9 [, h
-
1 _, |1 y; m4 R0 ~2 ] - while(1){& x4 d& m4 g# Z+ u! l
- //将键盘输入的消息发送给服务器,并且从服务器中取得回复消息
7 E( e3 C+ {) c4 o4 r, a - bzero(msgbuffer,sizeof(msgbuffer));2 I' O% @! q$ N
- read(STDIN_FILENO,msgbuffer,sizeof(msgbuffer));
$ ^7 ` {) Y# G+ i8 v7 T l - if(send(sockfd,msgbuffer,sizeof(msgbuffer),0)<0)& b# @" |& H, b$ W, z! B+ H/ }
- perror("ERROR");$ F5 B% u1 S+ a, ^2 q$ w0 v6 L7 d
-
7 ^: a0 E$ R8 B/ v { - bzero(msgbuffer,sizeof(msgbuffer));
- @/ o% H4 R& F9 b - recv(sockfd,msgbuffer,sizeof(msgbuffer),0);, @/ i% e: K; B9 M3 F1 W+ h0 n
- printf("[receive]:%s\n",msgbuffer);' C+ ?( g' l, v! {# r2 ^
- - I. U, o! ]$ M, A8 l
- usleep(500000);0 K( s% N9 I6 Q- K/ `2 E
- }5 ?0 F4 n! ?4 d: \, ]" q
- }
复制代码
: l; M# w* R6 @. ]% M0 r+ W. I0 O* u+ B; M
服务端: - #include <time.h>
5 [+ x+ O6 V: D/ F2 X - #include <stdio.h>
% G3 V* [' g8 n3 h: y- T% u - #include <stdlib.h>, `9 e/ z1 g7 G% y% z6 q
- #include <string.h>
* W0 h! f1 Z6 r% d4 k$ g - #include <unistd.h>
: n ^* Z; E' @ - #include <arpa/inet.h>
3 m: f! O) M& i2 L( a; z7 t) } - #include <netinet/in.h>
5 E W4 ~9 l3 ?- O - #include <sys/types.h>1 \/ a4 w7 i" ^7 Y3 R* C- u
- #include <sys/socket.h>
8 C$ e, t s/ i% V* C( i -
% H/ r* |/ g: N. j - #define LOCAL_PORT 6666 //本地服务端口
) R; V3 e1 e7 x3 E! \5 R+ N - #define MAX 5 //最大连接数量
/ A6 I7 S) @4 [1 I) f+ |8 I -
# u. {/ L2 W7 ?. ]9 m - int main(){: y/ }6 n& y" I4 g# o; `
- int sockfd,connfd,fd,is_connected[MAX];& E6 o1 \# }6 l, D; E" Z' C
- struct sockaddr_in addr;
+ `. c( y+ T; _8 A2 _2 i0 x - int addr_len = sizeof(struct sockaddr_in);
' ^' e* `2 e$ S6 {4 j- v - char msgbuffer[256];
4 ~9 V( a# i" ?! q - char msgsend[] = "Welcome To Demon Server";
5 G; W- M/ [1 A, e7 R; G9 t - fd_set fds;
# G, h8 b! Y! ^5 w) \ - $ X- Z3 r$ ]9 q% Z
- //创建套接字
6 f) Z/ d9 X" Q - sockfd = socket(AF_INET,SOCK_STREAM,0);
~- l' _6 q/ \) }4 a. z+ [& h5 O - if(sockfd>=0)
; [# l6 ^3 c2 S5 ~) L: F+ x) { - printf("open socket: %d\n",sockfd);
* U" R. }* a) J/ s | - ; T4 m9 V/ `$ a" W
- //将本地端口和监听地址信息保存到套接字结构体中
& H* \ q. U& G: i - bzero(&addr,sizeof(addr));! K+ _, v2 n) W: d4 z+ u( E
- addr.sin_family=AF_INET;/ _4 e* {9 I$ ^) \0 n
- addr.sin_port=htons(LOCAL_PORT);
: @1 p; n4 e- K; y7 k4 [7 d - addr.sin_addr.s_addr = htonl(INADDR_ANY); //INADDR_ANY表示任意地址0.0.0.0 0.0.0.07 \! j: g9 G. O9 O7 w- E
-
/ C$ p7 p2 G1 ^; {: C - //将套接字于端口号绑定
5 r; T2 u5 s0 P `% t0 f - if(bind(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)( x2 D# M$ X1 W0 F5 r6 @
- printf("bind the port: %d\n",LOCAL_PORT);) q+ E2 q" Z& e T. M6 d# O
-
- S5 ^" ~6 ~* S2 b! Z& [ - //开启端口监听
* |' \* j T7 Z7 C+ X - if(listen(sockfd,3)>=0)
; m$ `. ~9 t3 U- n9 r' a - printf("begin listenning...\n");- o3 {) V' O5 s- Y
- : T; h5 L7 q# G5 B
- //默认所有fd没有被打开
. J0 V8 M9 g2 m3 ~2 h) v: s - for(fd=0;fd<MAX;fd++)
, ?; P9 Q7 m8 w" G7 `$ B - is_connected[fd]=0;$ \5 G& \; |" S% c- u/ K) L- Z! x
-
' i1 K) X. S6 Y+ Y+ Q7 H - while(1){
! s8 m# j1 ~; X4 e+ E1 K: ]* `" q1 E - //将服务端套接字加入集合中3 J( Q6 S& h; Y0 E+ V) @
- FD_ZERO(&fds);0 Z' b7 S P5 d0 u6 i; I6 _
- FD_SET(sockfd,&fds);: G3 D" h. E+ ]
-
& G. L6 w2 Z" v1 u {! y- S - //将活跃的套接字加入集合中
f) @( r; F5 e4 w( |& v8 P - for(fd=0;fd<MAX;fd++)
+ S8 B% `& W- |; ]% g9 m/ ` - if(is_connected[fd])
9 Y2 i3 S5 g1 m) X, t& } - FD_SET(fd,&fds);. y) j$ k$ Z, z. V6 I
-
$ g! }! w( _% \6 y- k) j - //监视集合中的可读信号,如果某个套接字有信号则继续执行,此时集合中只有存在信号的套接字会被置为1,其他置为09 j- t# p! G( Y
- if(!select(MAX,&fds,NULL,NULL,NULL))# \4 J2 B- d6 x. M# q, V
- continue;
+ r# ~6 z: x' D -
2 C4 l5 L c% e8 Y y% [ - //遍历所有套接字判断是否在属于集合中的活跃套接字" ?: m/ ~. Q+ e' R% z+ F* v
- for(fd=0;fd<MAX;fd++){- N# _- B$ w$ p8 Y N9 x, Q
- if(FD_ISSET(fd,&fds)){
* F9 B8 N* G7 B8 v - if(fd==sockfd){ //如果套接字是服务端,那么与客户端accept建立连接; \3 @7 B: l( N; E
- connfd = accept(sockfd,(struct sockaddr*)&addr,&addr_len);( ^: J. g4 \- t& z$ M1 T% Z) q
- write(connfd,msgsend,sizeof(msgsend)); //向其输出欢迎语
& p" u! t" s: [7 G& Y) `* x; b - is_connected[connfd]=1; //对客户端的fd对应下标将其设为活跃状态,方便下次调用& h5 k& `, Z3 x
- printf("connected from %s\n",inet_ntoa(addr.sin_addr));
( A' Z+ d! E) e* k( R - }else{ //如果套接字是客户端,读取其信息并返回,如果读取不到信息,冻结其套接字
" @1 U$ x6 @4 h& i2 { - if(read(fd,msgbuffer,sizeof(msgbuffer))>0){
: }) N4 m3 M* }) p9 U' r$ W) R - write(fd,msgbuffer,sizeof(msgbuffer));! c. ~. q8 @6 u ]
- printf("[read]: %s\n",msgbuffer);3 W, ~; H% l3 H; E
- }else{
. X' E" u6 t9 D+ c' V0 N7 ] - is_connected[fd]=0;1 m: T2 Q2 Z0 v5 }
- close(fd);
( Y8 a+ U& g2 S5 l/ B - printf("close connected\n");4 A7 Y, _; y' Z; d& x) U+ D
- }
3 e9 Q9 A$ [* m9 F - }0 L' `% O/ M% f' O
- } I! g, T& [4 T2 e4 k1 ^: y% g
- }
6 S9 }; b$ @3 z# H4 [% I: ^ - }
/ p$ j6 |+ x1 o+ _. f* g - }
复制代码
n& y0 o$ d1 X. I8 p( B+ F* U" h r: J) F$ L
8 h' T% M+ p( z: Y) G
" g9 ]6 h8 [. M( n( c- P3 u! s6 e, n! A- e1 A j. j5 h; d
( f" j( y7 P' z' ]7 L |