实验环境是linux系统,效果如下: 1.启动服务端程序,监听在6666端口上 2.启动客户端,与服务端建立TCP连接 3.建立完TCP连接,在客户端上向服务端发送消息 4.断开连接 实现的功能很简单,但是对于初来乍到的我费了不少劲,因此在此总结一下,如有错点请各位大神指点指点 % [" j! K9 x) ]
什么是SOCKET(插口): 这里不用 "套接字" 而是用 "插口" 是因为在《TCP/IP协议卷二》中,翻译时也是用 "插口" 来表示socket的。
7 _& `4 W# \" {- M. I# f "套接字" 这词不知道又是哪个教授级人物造出来的,听起来总是很怪,虽然可以避免语义上的歧义,但不明显。 对插口通俗的理解就是:它是一个可以用来输入或者输出的网络端,另一端也具有同样相对应的操作。 具体其他高级的定义不是这里的重点。值得说的是: 每个插口都可以标识某个程序通信的一端,通过系统调用使得程序与网络设备之间的交流连接起来。 应用程序 -> 系统调用 -> 插口层 -> 协议层 -> 接口层 ->发送(接收的话与之相反)9 ?( t% x u9 h# i
9 `/ m% i" {8 `& {) B6 t' q' U1 r/ [) M. Z/ {, w
如何标识一个SOCKET: 如上定义所述,可以通过地址,协议,端口三要素来确定一个通信端,而在linux C程序中使用 标识符 来标识一个 SOCKET,Unix系统对设备的读写操作等同于对描述符的读写操作,标识符可以用于:插口 管道 目录 设备 文件等等- o: Y$ i3 p2 W" v
描述符是个正整数,事实上他是检查表表项中的一个下标,用于指向打开文件表的结构。 述符前三个标识符0 1 2 分别系统保留:标准输入(键盘),标准输出(屏幕),标准错误输出 当我们使用新的描述符来创建socket时,他一般从最小未使用的数字开始分配,也就是3 - a! C. a9 Y' q3 ~$ A- D4 I |! h& v
# V" e3 e( \& o服务端实现的流程: 1.服务端开启一个SOCKET(socket函数) 2.使用SOCKET绑定一个端口号(bind函数) 3.在这个端口号上开启监听功能(listen函数) 4.当有对端发送连接请求,向其发送ack+syn建立连接(accept函数) 5.接收或者回复消息(read函数 write函数) / Q2 w1 L, V/ X+ p' h+ z
2 Q% f/ r9 ]% P1 M0 K客户端实现流程: 1.打开一个SOCKET 2.向指定的IP 和端口号发起连接(connect函数) 3.接收或者发送消息(send函数 recv函数)
6 G: m5 \5 S/ l# V% _- ^
& c! _' d; P" r8 E5 g. }
+ A5 Z; @5 `9 V' ?* `2 X* w5 E如何并发处理: 如果按照以上流程实现其实并不难,但是有个缺陷,因为C语言是按顺序单一流程运行,也就是说如果 直接在程序当中使用accept函数(建立连接)的话,那么程序会阻塞在accept这里,这是因为如果客户端 一直没有发送connect连接,那么accept就无法得知客户端的IP和端口,也就只能一直等待(阻塞)直到 有请求触发继续执行为止,这样就导致如果同时多个客户向服务端发送请求连接,那么服务端只能按照 单一线程去处理第一个客户端,无法开启多个线程同时处理多个用户的请求。
+ `+ \4 R6 L/ A Q* Y9 g! h1 |1 ]
# u3 X( _. N( [如何解决: 下面摘文截取网上的资料,有兴趣者可以看看 系统提供select函数来实现多路复用输入/输出模型,该函数用于在非阻塞中,当一个套接字或一组套接字有信号时通知你 - int select(int nfds, fd_set *readfds, fd_set *writefds, exceptfds, const struct timeval* timeout);
复制代码所在的头文件为: - #include <sys/time.h>) B/ F" }1 {% j8 }
- ! W4 @* L: L* V$ T
- #include <unistd.h>
复制代码 功能:测试指定的fd是否可读,可写 或者 是否有异常条件待处理
" o; ?, w7 h/ u- ?* Q- e" w$ ] readset 用来检查可读性的一组文件描述字。
1 k* F3 e+ O+ B, b writeset 用来检查可写性的一组文件描述字。
: G: D7 B7 s2 p" k8 p! G! p exceptset用来检查是否有异常条件出现的文件描述字。(注:不包括错误)
8 }8 I3 ]/ p% c8 l2 D
timeout 用于描述一段时间长度,如果在这个时间内,需要监视的描述符没有事件发生则函数返回,返回值为0。6 `( Y* Y x; X( H* u
4 k% T7 e/ `" c, x
对于select函数的功能简单的说就是对文件fd做一个测试。测试结果有三种可能:- u( X* `1 H; O5 L
7 q4 i6 i& c* \- 1.timeout=NULL (阻塞:select将一直被阻塞,直到某个文件描述符上发生了事件)
5 H [% Q# H7 n2 M2 s+ h4 `
8 K8 E9 A7 n0 P: I- 2.timeout所指向的结构设为非零时间 (等待固定时间:如果在指定的时间段里有事件发生或者时间耗尽,函数均返回)" c- Y) p2 J1 v: ~
+ z+ \' l |9 {0 s- 3.timeout所指向的结构,时间设为0 (非阻塞:仅检测描述符集合的状态,然后立即返回,并不等待外部事件的发生)
复制代码 返回值: 返回对应位仍然为1的fd的总数。注意啦:只有那些可读,可写以及有异常条件待处理的fd位仍然为1。 否则为0哦。举个例子,比如recv(), 在没有数据到来调用它的时候,你的线程将被阻塞,如果数据一直不来, 你的线程就要阻塞很久.这样显然不好。所以采用select来查看套节字是否可读(也就是是否有数据读了) 。 现在,UNIX系统通常会在头文件<sys/select.h>中定义常量FD_SETSIZE,它是数据类型fd_set的描述字数量, 其值通常是1024,这样就能表示<1024的fd。 M# t% W" e9 D0 g
! L$ y8 r5 `1 m7 n% A$ b$ M2 q
5 q. U4 L9 C8 U! N9 {* ~, g4 J fd_set结构体: 文件描述符集合,用于存放多个fd(文件描述符,这里就是套接字) 可以存放服务端的fd,有客户端的fd。下面是对这个文件描述符集合的操作: - FD_ZERO(*fds): 将fds设为空集+ S+ i7 w0 _' P' E: O: d
- ; x, Y) f: {6 l; Q. a7 c+ v
- FD_CLR(fd,*fds): 从集合fds中删除指定的fd
0 [3 p! C/ O7 T/ H2 d - ! m A. u3 T) d3 J- T4 R1 U
- FD_SET(fd,*fds): 从集合fds中添加指定的fd9 s# Y# r! O2 C4 O9 \" u
) Z7 k6 j' a( W5 v# n: x" z4 M1 |! A- a- FD_ISSET(fd,*fds): 判断fd是否属于fds的集合
复制代码步骤如下 - socket s;
/ {! p2 W" I M z- Z - .....8 @: d' I) }# t) s
- fd_set set;' M' ]/ g# }1 C% P
- while(1){
( P' U, N+ T/ L3 X' o" {; `, Z - FD_ZERO(&set); //将你的套节字集合清空; @# | G7 ~5 K: p+ ^/ C# e/ C
- FD_SET(s, &set); //加入你感兴趣的套节字到集合,这里是一个读数据的套节字s
k5 c5 {; {" Y* r5 o! M6 J - select(0,&set,NULL,NULL,NULL); //检查套节字是否可读,
) m, S2 p( O4 B, Y/ [; g - if(FD_ISSET(s, &set) //检查s是否在这个集合里面,
: V" D! D' Q- `% h - { //select将更新这个集合,把其中不可读的套节字去掉 F) Y1 _% U- |4 Z9 K
- //只保留符合条件的套节字在这个集合里面" g- U$ x6 T5 L
- recv(s,...);
0 y: Y; W- a) o8 d - }
* H" N( _3 B/ J3 u. } - //do something here; g8 q; S3 g1 R8 V$ I. J
- }
复制代码假设fd_set长度为1字节,fd_set中的每一位可以对应一个文件描述符,那么1字节最大可以对应8个fd - (1)执行fd_set set; FD_ZERO(&set); 则set用位为0000,0000。
0 X2 y0 _# G) N
`+ h- U5 z" K, i: g/ A- (2)若fd=5,执行FD_SET(fd,&set); 后set变为 0001,0000(第5位置为1)- @1 B) B- }! o: ]1 M6 Z
- - R, n3 ~) e6 k8 w: P
- (3)若再加入fd=2,fd=1 则set变为 0001,0011
+ @) L: o" s. w R; a- ^6 }
& d, ?: R( U9 W7 e- v! }% Z- (4)执行select(6,&set,0,0,0) 阻塞等待9 r: {4 k; F% U
- ( T( t1 Z3 X3 R$ f$ p" R$ f
- (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.具体过程看代码会好理解
' i7 `+ ]# b1 R6 K4 {* ^& b: ]/ n2 n
使用select函数的过程一般是:
. [2 h# w+ p* V7 @% n) s: o1 Y& p 先调用宏FD_ZERO将指定的fd_set清零,然后调用宏FD_SET将需要测试的fd加入fd_set,
接着调用函数select测试fd_set中的所有fd,最后用宏FD_ISSET检查某个fd在函数select调用后,相应位是否仍然为1 复制粘贴的摘文排版起来真的是痛苦,我已经尽力排版了。。。
! v$ l4 a( x. U
4 P$ c4 A+ Z- e, ]. t客户端: - #include <time.h>: Z0 k( _: W* d! t3 q
- #include <stdio.h>$ @. ]- T9 T% X6 H% B
- #include <stdlib.h>) A6 p/ u; k- }- Y
- #include <string.h>
, ^& O6 _, y6 ^9 T( i( [8 l" ?% r - #include <unistd.h>; H' q" x: {# v+ e5 b* V
- #include <arpa/inet.h>9 t3 s! X4 P( \" R9 ~
- #include <netinet/in.h>% t; y8 H' f) I, \7 s; {
- #include <fcntl.h>0 ?3 W! T8 S, T$ c4 A% F- J
- #include <sys/stat.h>$ t! Q1 ?/ c6 d5 D, x4 _
- #include <sys/types.h>
, W p' C# l0 N - #include <sys/socket.h>* X2 L$ |% `/ a. ^5 H: Y& f& d S
- ! t) k0 ?0 i+ S" ?7 L2 v
- #define REMOTE_PORT 6666 //服务器端口, @4 P! G" P( Y! q5 Q8 r) S
- #define REMOTE_ADDR "127.0.0.1" //服务器地址: H1 ~5 @% b* Y2 Q6 p( E
-
6 `- H" V- P+ g1 D+ H" t; z - int main(){
) K) c* g! E o4 H$ o" ~& @ - int sockfd;
/ L7 A# w8 Y) ^& S. Z1 p2 r - struct sockaddr_in addr;
$ Q: @; g4 k: C( ~& a: h& n [ - char msgbuffer[256];
4 ?" h" D- \" n+ Z - # b' g H- i( x" D8 n7 t
- //创建套接字
. F6 Q+ z/ b: h: N1 W0 l& } - sockfd = socket(AF_INET,SOCK_STREAM,0);
# e3 \# G& ?. G! m* m - if(sockfd>=0)1 j& ^7 T5 u6 }* y
- printf("open socket: %d\n",sockfd);
; P# r0 c, Q1 E( x -
& g% x/ ?' C3 p - //将服务器的地址和端口存储于套接字结构体中: ^9 V; s" h/ z' N9 t9 \
- bzero(&addr,sizeof(addr));
2 J+ a y0 r/ p: I. U; [8 d: ?( O# m - addr.sin_family=AF_INET;8 s( X* \0 k, @' H4 ~' h" J: r. n
- addr.sin_port=htons(REMOTE_PORT);
( s1 F+ a* a" g9 Z. S7 E - addr.sin_addr.s_addr = inet_addr(REMOTE_ADDR);
: v0 D- F; E) P' @" X: ? - % K# e8 `2 _: o) ^
- //向服务器发送请求
& m. @# t5 k5 w7 ^( l h - if(connect(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)8 a3 c; v; ]4 P$ |
- printf("connect successfully\n");( h2 P @& \0 [( G
- $ z4 ~* w# o) ?8 K" V! ?* d
- //接收服务器返回的消息(注意这里程序会被阻塞,也就是说只有服务器回复信息,才会继续往下执行)
9 t( {. r. Y: Y' j; O; c! t- \5 H - recv(sockfd,msgbuffer,sizeof(msgbuffer),0);, x3 o4 e/ K( ?! d/ m- o
- printf("%s\n",msgbuffer);
9 y2 x" |% X" H" q -
* D) j5 {9 V5 b, J; [; I - while(1){
4 g' s9 A3 a+ `6 a$ t: t - //将键盘输入的消息发送给服务器,并且从服务器中取得回复消息
h' m1 d0 C* {! Z- A) R - bzero(msgbuffer,sizeof(msgbuffer));( w- x) [" e/ C; U# K" M1 f' Y
- read(STDIN_FILENO,msgbuffer,sizeof(msgbuffer));
/ w6 I8 {% g) ]8 Y: a, C3 ^ - if(send(sockfd,msgbuffer,sizeof(msgbuffer),0)<0)9 X( X" W4 K, h9 Q6 H0 `
- perror("ERROR");
- p/ \7 \7 d5 u J0 V& Y+ g) X - ) p' K* k/ E: Z: a6 U
- bzero(msgbuffer,sizeof(msgbuffer));* F6 O! ^; K3 A* O& ^ C% H
- recv(sockfd,msgbuffer,sizeof(msgbuffer),0);
, P; p: {5 _* t; P8 Q* M7 H, J - printf("[receive]:%s\n",msgbuffer);
6 h2 L9 A: t+ M5 F1 ^- o" o - $ A& D" {; Q3 ^
- usleep(500000);+ J7 H; F- u2 K( u1 X* h
- }
7 ?( K: S3 n3 r! C0 b - }
复制代码 5 n$ X7 o: v+ `0 V# l
: s2 a) z) Z* h
服务端: - #include <time.h>
* Y& {2 A7 W, B- b! e - #include <stdio.h>
! z( u: Y0 G0 A, K2 h4 m, E% | - #include <stdlib.h>) N& l$ l7 R/ i* g( `9 @
- #include <string.h>- d/ F1 g9 c. O2 l& f. w V) Y
- #include <unistd.h>
& i, {/ O6 |% l9 v - #include <arpa/inet.h>' D0 M( {2 k9 ]$ @
- #include <netinet/in.h>( J7 e4 p2 Y9 \- ?+ m1 z2 n; o0 u
- #include <sys/types.h>
( A$ w% j7 P( b D) W - #include <sys/socket.h>' f& d- U/ W' Q; ?8 z
-
, u/ X" g3 i: ~0 w# ?) X- C7 Y - #define LOCAL_PORT 6666 //本地服务端口 T K; m7 I2 U* k9 I3 `% n" g* g/ s
- #define MAX 5 //最大连接数量+ p- @* R) ?. S- ~7 |! i( L& `, ^
-
8 r) ~- |8 k4 Q( ` - int main(){
1 A; j T( ]7 O: D! x8 l - int sockfd,connfd,fd,is_connected[MAX];2 w. C. p( P& [8 ?
- struct sockaddr_in addr;0 ~" W% Z4 m% y3 @, d; ^! {$ A
- int addr_len = sizeof(struct sockaddr_in);! N$ @1 f9 R5 V8 z2 Q3 Z) q B% y
- char msgbuffer[256];1 i' B4 i r5 Z% B! l
- char msgsend[] = "Welcome To Demon Server";
) n0 J5 `1 \: A" S: | - fd_set fds;
( O* Q/ k& [2 `6 F1 h - 5 n+ h2 K; g, t
- //创建套接字
9 w. \. n- a7 d- P - sockfd = socket(AF_INET,SOCK_STREAM,0);3 {- v* J$ I" [$ d' a. y9 i& ?/ b
- if(sockfd>=0)
8 ]1 Q: S2 t# F - printf("open socket: %d\n",sockfd);
) H% U1 l8 Q& l2 _ -
& H7 |) O9 Q. t& k - //将本地端口和监听地址信息保存到套接字结构体中' I& a2 Y" e9 s [/ S: Z; E
- bzero(&addr,sizeof(addr));
; e3 R( J, h# w; b) X - addr.sin_family=AF_INET;! F2 L; s7 {' U3 ?+ [% u8 Z6 O
- addr.sin_port=htons(LOCAL_PORT);
( N r+ O4 Z2 M* ^8 B - addr.sin_addr.s_addr = htonl(INADDR_ANY); //INADDR_ANY表示任意地址0.0.0.0 0.0.0.0
4 z v9 o9 W( `+ h: @ -
, L- K% j# M% E& w5 G8 T1 g - //将套接字于端口号绑定
7 F7 T1 z/ r- d% S1 ~* m - if(bind(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)
# d. A _" N- k6 n' @ ~- N - printf("bind the port: %d\n",LOCAL_PORT);
P& F0 b$ _7 R6 I* W- S2 _" @) H -
( [% z9 I& b% a& i! B9 D - //开启端口监听9 G: z+ ?- u7 k
- if(listen(sockfd,3)>=0)
/ j' X+ A# }4 E, h - printf("begin listenning...\n");/ f, }3 [0 [! l
- ! i6 C1 p$ X- ?: r+ ]/ i7 x
- //默认所有fd没有被打开
) O b0 x4 q6 q: A* `1 {) u - for(fd=0;fd<MAX;fd++)
! U4 g' N3 W) E& Y - is_connected[fd]=0; Q9 K$ j0 T* S( t9 h' ^+ U9 b) g! _
-
4 O/ A! m4 \+ l( q/ u2 }- y6 g - while(1){' V7 ~1 R1 y' s2 g. W# j: e
- //将服务端套接字加入集合中, ~1 X; m- L8 v5 V- k) @
- FD_ZERO(&fds);, W) V" H5 W4 ]$ C: _7 \
- FD_SET(sockfd,&fds);0 I$ s t9 O) g7 K
-
3 @7 y% U" ^! o$ d0 S - //将活跃的套接字加入集合中
: b1 D+ U6 a$ @5 N4 A5 X - for(fd=0;fd<MAX;fd++)1 M: S% c( W' b$ f: f9 Z5 F
- if(is_connected[fd])8 |7 I5 i; A/ O6 I, f) P
- FD_SET(fd,&fds);9 C0 w2 ^, b" @* ^" @) Z
- ! Q, L# L! i! F& j5 U. p" ~
- //监视集合中的可读信号,如果某个套接字有信号则继续执行,此时集合中只有存在信号的套接字会被置为1,其他置为0
5 z( Q R$ I% i$ L# E; k - if(!select(MAX,&fds,NULL,NULL,NULL))- X+ R" _4 Y! p) c! Z6 a7 ]
- continue;. h- q. d0 \5 O( O! r U
-
7 T( y, I: E7 R7 X, m& ] - //遍历所有套接字判断是否在属于集合中的活跃套接字
1 b% S* X* h& a% @9 r# r8 |* |/ X - for(fd=0;fd<MAX;fd++){
% D1 E" ^% x. |% G - if(FD_ISSET(fd,&fds)){$ I& B! b r: q' X x. O
- if(fd==sockfd){ //如果套接字是服务端,那么与客户端accept建立连接
+ }0 \. j+ l* ~8 ~# c7 o, L* D - connfd = accept(sockfd,(struct sockaddr*)&addr,&addr_len); R# |; T/ p, u0 J% z" }# @( I
- write(connfd,msgsend,sizeof(msgsend)); //向其输出欢迎语 N! D y* J0 o5 L' g
- is_connected[connfd]=1; //对客户端的fd对应下标将其设为活跃状态,方便下次调用
: W( O. t9 D* V1 N3 |1 u; s2 X1 { - printf("connected from %s\n",inet_ntoa(addr.sin_addr));1 ~- q/ W ?8 X5 {+ `5 B/ A9 L- Q
- }else{ //如果套接字是客户端,读取其信息并返回,如果读取不到信息,冻结其套接字- u, j+ C: j( \* A) a
- if(read(fd,msgbuffer,sizeof(msgbuffer))>0){
( h: v5 P$ p$ i, }' c' S% C. u; ] - write(fd,msgbuffer,sizeof(msgbuffer));
6 y' X5 i v& Q( h - printf("[read]: %s\n",msgbuffer);) p6 C2 F2 a4 _; h" D, h* g
- }else{
. {: j% g5 J5 ~8 s! f - is_connected[fd]=0;
- v3 |9 o, S' R% r( x. D - close(fd);
4 \* S6 a3 G; b/ i* N# ~ - printf("close connected\n");
8 z+ X$ @. Z9 O- b. l0 a - }. u) x, b" [1 Q, q/ m" R1 `
- }$ f9 q8 K. o* U
- }8 i2 }. o) j, x! K
- }
; m- l: I) y8 y2 H! v' H8 G - }
& s* t& c6 ]2 T - }
复制代码 ! p/ k% {1 G7 J6 u& \- V
+ G# c9 P4 B/ f5 z' n+ U
* {1 r6 L4 q& g
& l2 }& x; G$ `9 I9 w' R$ p
3 W' T5 `" V4 k; Y; v! U
+ `5 d! G- ]1 o$ f" G |