实验环境是linux系统,效果如下: 1.启动服务端程序,监听在6666端口上 2.启动客户端,与服务端建立TCP连接 3.建立完TCP连接,在客户端上向服务端发送消息 4.断开连接 实现的功能很简单,但是对于初来乍到的我费了不少劲,因此在此总结一下,如有错点请各位大神指点指点
5 ]1 Z2 P: B: N! u; ?* y什么是SOCKET(插口): 这里不用 "套接字" 而是用 "插口" 是因为在《TCP/IP协议卷二》中,翻译时也是用 "插口" 来表示socket的。& K3 P+ l' v7 a$ U% }- t% G: `
"套接字" 这词不知道又是哪个教授级人物造出来的,听起来总是很怪,虽然可以避免语义上的歧义,但不明显。 对插口通俗的理解就是:它是一个可以用来输入或者输出的网络端,另一端也具有同样相对应的操作。 具体其他高级的定义不是这里的重点。值得说的是: 每个插口都可以标识某个程序通信的一端,通过系统调用使得程序与网络设备之间的交流连接起来。 应用程序 -> 系统调用 -> 插口层 -> 协议层 -> 接口层 ->发送(接收的话与之相反)
. a: [; P0 c& f" P2 f/ r" Y
: E" z& V: v8 L, R5 `3 d' `9 c+ l/ Y3 Z8 y4 [6 |1 t$ w
如何标识一个SOCKET: 如上定义所述,可以通过地址,协议,端口三要素来确定一个通信端,而在linux C程序中使用 标识符 来标识一个 SOCKET,Unix系统对设备的读写操作等同于对描述符的读写操作,标识符可以用于:插口 管道 目录 设备 文件等等0 e1 C0 A$ t( y3 _
描述符是个正整数,事实上他是检查表表项中的一个下标,用于指向打开文件表的结构。 述符前三个标识符0 1 2 分别系统保留:标准输入(键盘),标准输出(屏幕),标准错误输出 当我们使用新的描述符来创建socket时,他一般从最小未使用的数字开始分配,也就是3 / k9 z$ }8 r, t `* i+ E5 ^
6 I/ y- P, j, u; a3 W. E6 A4 j0 ?服务端实现的流程: 1.服务端开启一个SOCKET(socket函数) 2.使用SOCKET绑定一个端口号(bind函数) 3.在这个端口号上开启监听功能(listen函数) 4.当有对端发送连接请求,向其发送ack+syn建立连接(accept函数) 5.接收或者回复消息(read函数 write函数)
" d( A! Y/ P" m$ u+ H5 Z9 r0 b! {% s8 y9 a2 [7 w; K2 U. k7 L; o
客户端实现流程: 1.打开一个SOCKET 2.向指定的IP 和端口号发起连接(connect函数) 3.接收或者发送消息(send函数 recv函数)
8 ^: @# M; I: l4 z
2 B6 |- E5 |" \( n) j6 L8 Z' n7 f8 B2 h3 Z7 o( N2 G
如何并发处理: 如果按照以上流程实现其实并不难,但是有个缺陷,因为C语言是按顺序单一流程运行,也就是说如果 直接在程序当中使用accept函数(建立连接)的话,那么程序会阻塞在accept这里,这是因为如果客户端 一直没有发送connect连接,那么accept就无法得知客户端的IP和端口,也就只能一直等待(阻塞)直到 有请求触发继续执行为止,这样就导致如果同时多个客户向服务端发送请求连接,那么服务端只能按照 单一线程去处理第一个客户端,无法开启多个线程同时处理多个用户的请求。 . I5 i7 v/ P! B" t$ F, b* Z+ {
0 W* J, W8 L( W0 H3 n+ L如何解决: 下面摘文截取网上的资料,有兴趣者可以看看 系统提供select函数来实现多路复用输入/输出模型,该函数用于在非阻塞中,当一个套接字或一组套接字有信号时通知你 - int select(int nfds, fd_set *readfds, fd_set *writefds, exceptfds, const struct timeval* timeout);
复制代码所在的头文件为: - #include <sys/time.h>
* v, P( T* P; R) S6 J
6 L5 y7 w. m' H4 c$ A- #include <unistd.h>
复制代码 功能:测试指定的fd是否可读,可写 或者 是否有异常条件待处理
* c9 f3 O8 c, y3 `; H readset 用来检查可读性的一组文件描述字。
6 o+ [6 N; ?; z& d, n) G8 K8 y0 K writeset 用来检查可写性的一组文件描述字。
E) u' I/ x1 Z) D2 { exceptset用来检查是否有异常条件出现的文件描述字。(注:不包括错误)
8 O1 e x! D9 P7 {3 y
timeout 用于描述一段时间长度,如果在这个时间内,需要监视的描述符没有事件发生则函数返回,返回值为0。
4 B# n4 E ~- a. a* V7 A
; y0 O6 ~. J% J8 U$ h# W 对于select函数的功能简单的说就是对文件fd做一个测试。测试结果有三种可能:2 u, X0 H7 D( A8 d' S8 f9 o: h
2 u. g7 y3 n/ w4 N- 1.timeout=NULL (阻塞:select将一直被阻塞,直到某个文件描述符上发生了事件)
( H; ~2 b0 {( G: k
- J7 M+ Y6 T( Y# ~& \: h/ K4 E- 2.timeout所指向的结构设为非零时间 (等待固定时间:如果在指定的时间段里有事件发生或者时间耗尽,函数均返回)% L3 x z) }1 W" c
- z8 S+ n/ L% W d1 z- 3.timeout所指向的结构,时间设为0 (非阻塞:仅检测描述符集合的状态,然后立即返回,并不等待外部事件的发生)
复制代码 返回值: 返回对应位仍然为1的fd的总数。注意啦:只有那些可读,可写以及有异常条件待处理的fd位仍然为1。 否则为0哦。举个例子,比如recv(), 在没有数据到来调用它的时候,你的线程将被阻塞,如果数据一直不来, 你的线程就要阻塞很久.这样显然不好。所以采用select来查看套节字是否可读(也就是是否有数据读了) 。 现在,UNIX系统通常会在头文件<sys/select.h>中定义常量FD_SETSIZE,它是数据类型fd_set的描述字数量, 其值通常是1024,这样就能表示<1024的fd。' E0 \) a* y$ ^
) B E: }4 v1 c( O2 Y! H
* D1 A1 ]+ R8 p4 W5 b! V
fd_set结构体: 文件描述符集合,用于存放多个fd(文件描述符,这里就是套接字) 可以存放服务端的fd,有客户端的fd。下面是对这个文件描述符集合的操作: - FD_ZERO(*fds): 将fds设为空集0 q, O8 u1 o/ i9 ^& F! p8 S, c
- 1 }" I* A- |* }+ ^% U
- FD_CLR(fd,*fds): 从集合fds中删除指定的fd
. c. t3 l _, K9 B/ R' h - % u1 ^1 y" G5 G& D/ I
- FD_SET(fd,*fds): 从集合fds中添加指定的fd
( n% @" v9 J/ X" z) r3 u* h - 9 m, x, S" x, n9 S4 Q
- FD_ISSET(fd,*fds): 判断fd是否属于fds的集合
复制代码步骤如下 - socket s;
1 Y# R3 v+ G. ?4 D! D3 O - .....
6 a3 k( l1 P- @ - fd_set set;% M' r; L7 ~/ Q2 N
- while(1){
9 X+ g7 E0 R7 x) e - FD_ZERO(&set); //将你的套节字集合清空
* Q) v& l9 y" t1 s, S - FD_SET(s, &set); //加入你感兴趣的套节字到集合,这里是一个读数据的套节字s
+ d5 @; e/ r7 y6 I" R* J- I1 `& ] - select(0,&set,NULL,NULL,NULL); //检查套节字是否可读,1 x3 a, w/ l. w& J5 y& ^
- if(FD_ISSET(s, &set) //检查s是否在这个集合里面,
3 T; w$ [( ?9 s$ { |- y) L - { //select将更新这个集合,把其中不可读的套节字去掉$ r% K1 H, C, H( C" Z. `, i a
- //只保留符合条件的套节字在这个集合里面
3 |! Q$ A5 y! f2 J2 N" C - recv(s,...);7 q( q" K6 u2 G. G* x e! @/ N
- }2 A9 Q5 e: I' z* I7 k
- //do something here- p2 W- w) G- M+ t
- }
复制代码假设fd_set长度为1字节,fd_set中的每一位可以对应一个文件描述符,那么1字节最大可以对应8个fd - (1)执行fd_set set; FD_ZERO(&set); 则set用位为0000,0000。
" `7 C6 D' w* }# r( L* x l
9 j: ^8 [2 F' n& C4 _5 @- (2)若fd=5,执行FD_SET(fd,&set); 后set变为 0001,0000(第5位置为1)6 V9 q/ g, o6 l: G O( L
" w. q1 I! Z. E. n9 b- x. _' _- (3)若再加入fd=2,fd=1 则set变为 0001,00113 J( ]0 i i# i% f3 j" K0 M
( r; }- h. p8 D! p2 O4 t- (4)执行select(6,&set,0,0,0) 阻塞等待" @; Z+ v; y1 l8 l, N4 {
- 5 x: T$ s) L- V6 H8 Q3 N
- (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.具体过程看代码会好理解 $ N5 Y Z! [0 g, {
) t5 ~5 b8 z$ c$ A6 u4 P, k8 q使用select函数的过程一般是:
4 y! t V2 ~! P! i" G. y 先调用宏FD_ZERO将指定的fd_set清零,然后调用宏FD_SET将需要测试的fd加入fd_set,
接着调用函数select测试fd_set中的所有fd,最后用宏FD_ISSET检查某个fd在函数select调用后,相应位是否仍然为1 复制粘贴的摘文排版起来真的是痛苦,我已经尽力排版了。。。
1 R: X: o* G7 f) w8 t( ] 7 l1 E2 I/ S5 q
客户端: - #include <time.h>1 J6 B5 z: P/ k! P
- #include <stdio.h>
9 j# B; L1 T2 S+ v - #include <stdlib.h>
) x z D4 i3 A5 N) E9 g1 I; K - #include <string.h>% |6 C Y4 k& p" v) Q2 B6 D
- #include <unistd.h>- _6 X1 o' a* c# n3 x. u
- #include <arpa/inet.h>; J3 @, t5 O' T$ q+ w
- #include <netinet/in.h># f: v( t9 ~- D( y; e# L
- #include <fcntl.h>" m2 @2 N4 D4 @& _+ v# o% T' ?* {
- #include <sys/stat.h>
% c0 G7 o3 [* Q1 n" n3 M8 `0 u - #include <sys/types.h>
9 c* I9 ?* { r- K - #include <sys/socket.h>5 V. G8 e/ S8 C, h
- ' X$ b% W. u+ D
- #define REMOTE_PORT 6666 //服务器端口9 s) f# l0 o( _1 D* x5 y
- #define REMOTE_ADDR "127.0.0.1" //服务器地址: C4 i) b# i9 L* F9 }
-
( \% S4 ~* w8 N' y w8 k3 f - int main(){# @3 v4 g6 P5 l/ D& T& }
- int sockfd;* r% m0 i5 G- |& f9 E
- struct sockaddr_in addr;
# w* Q2 o/ a+ f! m7 d& J - char msgbuffer[256];$ n. \: l/ t) F. G" ^- w
-
6 x# v$ n4 n. G* { - //创建套接字/ P% E3 @9 Y: l: P& ~- a
- sockfd = socket(AF_INET,SOCK_STREAM,0);8 y1 O+ M$ N+ D5 J
- if(sockfd>=0), B4 G$ n% `# w3 e6 d/ H# I; e3 x
- printf("open socket: %d\n",sockfd);% u% `. D: l. m( u2 o& n
-
* v. D. _1 n) K1 I - //将服务器的地址和端口存储于套接字结构体中
+ f! g) u3 k0 J - bzero(&addr,sizeof(addr));: w0 p) ^4 Z# Z. K7 z+ m' s0 o
- addr.sin_family=AF_INET;6 K! a2 p2 i: |$ C
- addr.sin_port=htons(REMOTE_PORT);8 Y% |( W% ^1 `: Y4 P( u
- addr.sin_addr.s_addr = inet_addr(REMOTE_ADDR);( c5 \$ l9 |( a; y
-
3 g$ ] Y" o: ? - //向服务器发送请求
* V& d! H! w2 @% ^ - if(connect(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)+ o0 m3 ?5 a, }2 j/ J, ~; }1 n
- printf("connect successfully\n");
4 n1 v. A- s$ B8 P - . p: S7 _' N) U2 m2 L
- //接收服务器返回的消息(注意这里程序会被阻塞,也就是说只有服务器回复信息,才会继续往下执行)
+ a; P# o# Q [ s* x" k) C/ W - recv(sockfd,msgbuffer,sizeof(msgbuffer),0);/ v3 o+ Y1 H! ~& g) y a; m4 J; ?7 A J
- printf("%s\n",msgbuffer);
4 e0 X" x+ h! n( M - ; F) L3 O* U/ E( Z9 Y7 N7 O; e
- while(1){9 n; b. k( n* v$ R5 L
- //将键盘输入的消息发送给服务器,并且从服务器中取得回复消息
2 E+ K# @" K% {6 R - bzero(msgbuffer,sizeof(msgbuffer));4 C" }8 U2 u/ G% h G$ c0 }
- read(STDIN_FILENO,msgbuffer,sizeof(msgbuffer));0 H3 w$ @' A$ I! j" O
- if(send(sockfd,msgbuffer,sizeof(msgbuffer),0)<0) x$ K* q) D) ]* X" b9 I
- perror("ERROR");
& ?1 ^' N7 R% @# r -
9 k* f8 R: M0 K. A# e, h - bzero(msgbuffer,sizeof(msgbuffer));; R7 V0 ]2 h# r8 |( j4 X
- recv(sockfd,msgbuffer,sizeof(msgbuffer),0);
; y3 y( c1 Z, e+ e1 V' C4 y9 Z - printf("[receive]:%s\n",msgbuffer); J7 G4 ~1 z* E D4 l6 c$ z
-
- L& Q3 \! i5 B' D1 T' g [/ u - usleep(500000);" P( g2 i: G, E7 ~0 Z2 [) b
- }) [4 p5 C% s. u4 |% I
- }
复制代码
! ]; P v5 I: a4 z K. ~4 [' ?# g8 L B
服务端: - #include <time.h>' m+ h1 x( Y3 b0 B9 R8 Y' l$ o/ U
- #include <stdio.h>
" T3 g) C* k6 Z- v* z8 m& [1 y - #include <stdlib.h>
7 e2 d- W6 f+ Q# K8 b7 R" t - #include <string.h>+ w- ~* f! T2 g: i5 t0 V) @& V
- #include <unistd.h>, y! ?; Z1 l1 R2 A0 l3 x
- #include <arpa/inet.h>
% Q5 t+ [# |& B: g7 v - #include <netinet/in.h>
+ j7 \: t+ J2 [) r9 E, |8 [ - #include <sys/types.h>- D3 p# f9 i2 J$ e2 B8 L2 T
- #include <sys/socket.h>
" ]0 ~1 E. V+ R" F -
* Y$ r* K4 K- j! e$ W4 R' b - #define LOCAL_PORT 6666 //本地服务端口* c; c% O4 ~7 z1 V
- #define MAX 5 //最大连接数量* M3 F {6 |2 ^6 t( U* P" I
-
0 s2 L* ?- y1 Q - int main(){0 Q5 Z# Q7 _( f* J/ ~/ P# K
- int sockfd,connfd,fd,is_connected[MAX];
$ r6 E/ n9 e# o# o( x- m0 U - struct sockaddr_in addr;
" p* _6 P0 M) W3 } i' v2 X% o% J. T0 F - int addr_len = sizeof(struct sockaddr_in);
. P( g3 F2 z; C' \4 m - char msgbuffer[256];8 d6 m( {$ y1 c# k
- char msgsend[] = "Welcome To Demon Server";* B2 b! s3 h2 Y, x, x# Q
- fd_set fds;
& E& S8 [5 C0 }8 _, Q1 z8 p& x+ i - # H( ~: m1 ]8 v' F2 t: i1 U
- //创建套接字, _; Z- G8 Q4 ~
- sockfd = socket(AF_INET,SOCK_STREAM,0);' P H% `) m ]) P
- if(sockfd>=0)
9 m9 T# C- ~/ p4 f' } - printf("open socket: %d\n",sockfd);
% a, P6 J# b9 L4 K, v - " h) e* z$ ?2 t" R( ?& T5 }
- //将本地端口和监听地址信息保存到套接字结构体中
6 V7 V5 T. ^, `$ b* j% |1 a( B) v - bzero(&addr,sizeof(addr));( z! m# A! L0 |# B- ~
- addr.sin_family=AF_INET;
4 p4 u9 U, Y. }: e, a( I - addr.sin_port=htons(LOCAL_PORT);
1 l& p3 }. q6 T - addr.sin_addr.s_addr = htonl(INADDR_ANY); //INADDR_ANY表示任意地址0.0.0.0 0.0.0.0
; \* q6 `: R5 e, ~1 h+ B2 m - ( |% }$ {, g4 N5 n: p, P
- //将套接字于端口号绑定
r$ z1 B& r7 V) }. K4 Z a - if(bind(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)
7 T. Z) E4 W7 A. r# v. B* I' Z - printf("bind the port: %d\n",LOCAL_PORT);- v/ u& q/ J7 _
-
5 [7 M$ \1 g, f - //开启端口监听
) |# w3 j8 x9 T0 G/ {$ I. k - if(listen(sockfd,3)>=0)
1 ?9 e- k1 j, W7 t% w# z- g& G - printf("begin listenning...\n");
, e( `4 Z9 p) n -
+ \' A: }' m4 n0 S8 C" e - //默认所有fd没有被打开
; F7 `5 s8 r! F" L8 g$ u- A/ D - for(fd=0;fd<MAX;fd++)0 W7 w/ Q5 B5 t5 T
- is_connected[fd]=0;; G1 g4 b" }- r4 C( M$ T
- / `: |1 J* K% k+ m2 H
- while(1){
6 t. T1 f7 F" ^' [- D2 w' b - //将服务端套接字加入集合中( m. o4 J5 n* D
- FD_ZERO(&fds);2 v( K8 t" _. p& h5 L- N2 b$ ^
- FD_SET(sockfd,&fds);
g4 ~! o5 h+ _ -
) @& O' o3 G! e% R - //将活跃的套接字加入集合中' ~" z. T y6 c! ^9 `. j$ p
- for(fd=0;fd<MAX;fd++)
) Z+ I- v9 Z4 J/ z/ Z- m, }# m - if(is_connected[fd])2 d/ Y( l, v- t5 h
- FD_SET(fd,&fds);: U6 l0 I* A2 Y$ \
- " n) @) g& a- S
- //监视集合中的可读信号,如果某个套接字有信号则继续执行,此时集合中只有存在信号的套接字会被置为1,其他置为0
3 R! G# p) ~4 I- i9 ?. v$ z" A - if(!select(MAX,&fds,NULL,NULL,NULL))& B" O+ a4 O9 r5 ]" b1 \- i
- continue;
2 o/ H8 N/ @ N2 p; L- z4 ~8 y -
: ^8 m0 m: f2 N! K- L - //遍历所有套接字判断是否在属于集合中的活跃套接字
^; K1 d5 L; |( F, u$ a; Z1 Y - for(fd=0;fd<MAX;fd++){
+ U3 ~9 G0 }: n$ o, g6 k) g6 q - if(FD_ISSET(fd,&fds)){
- g6 t6 u5 E+ O - if(fd==sockfd){ //如果套接字是服务端,那么与客户端accept建立连接
6 c4 J \- _) u% k: U3 T$ S( P - connfd = accept(sockfd,(struct sockaddr*)&addr,&addr_len);
$ M6 J( Y" A8 I2 u; ~ - write(connfd,msgsend,sizeof(msgsend)); //向其输出欢迎语
; N8 U0 T: }/ }/ h/ T2 i: h% y; `: r - is_connected[connfd]=1; //对客户端的fd对应下标将其设为活跃状态,方便下次调用9 ~3 \0 s7 H7 \! v
- printf("connected from %s\n",inet_ntoa(addr.sin_addr));
, D0 g# A+ O; i3 `" K) w - }else{ //如果套接字是客户端,读取其信息并返回,如果读取不到信息,冻结其套接字
7 \4 |% k: l g; b: m - if(read(fd,msgbuffer,sizeof(msgbuffer))>0){ - s" W, y1 f7 ]; |) j8 X6 `6 I; Y
- write(fd,msgbuffer,sizeof(msgbuffer));& G. C0 C" q/ E3 j7 d9 i
- printf("[read]: %s\n",msgbuffer);
4 ? q, R& a6 @# d8 P, a2 y - }else{. s: X' e: K5 V5 v
- is_connected[fd]=0;
; k1 ?5 L! Q' K% k - close(fd);7 H) c# ?; }+ f! ]+ h' V
- printf("close connected\n");9 y H6 x2 |# a- b5 W7 D# z
- }, g; L, m8 K/ |. H1 l1 ]0 t( n
- }
* m) P2 Q$ u, q0 g2 J0 F+ f - }& Q3 U: W* k4 c3 ?
- }, ]8 y& [* x1 L9 \$ D
- }# e8 w. L0 C/ F
- }
复制代码 - d" H* W5 ?' k5 }! Y: e
# m: z7 v; d# ~/ y+ M( Y- ]# R8 m! i _- Z$ y0 Z# t0 K
8 _# w4 D! h* o4 p5 D
& e# S9 F+ E; R' \: B: r) h+ i! S$ o1 Q
; \5 P, i. Z: F% B9 D# f* h+ g, v, U |