实验环境是linux系统,效果如下: 1.启动服务端程序,监听在6666端口上 2.启动客户端,与服务端建立TCP连接 3.建立完TCP连接,在客户端上向服务端发送消息 4.断开连接 实现的功能很简单,但是对于初来乍到的我费了不少劲,因此在此总结一下,如有错点请各位大神指点指点 7 t' D3 n+ u- ]# b7 h
什么是SOCKET(插口): 这里不用 "套接字" 而是用 "插口" 是因为在《TCP/IP协议卷二》中,翻译时也是用 "插口" 来表示socket的。7 m2 U% g! L3 y, |" x- q, k5 Y
"套接字" 这词不知道又是哪个教授级人物造出来的,听起来总是很怪,虽然可以避免语义上的歧义,但不明显。 对插口通俗的理解就是:它是一个可以用来输入或者输出的网络端,另一端也具有同样相对应的操作。 具体其他高级的定义不是这里的重点。值得说的是: 每个插口都可以标识某个程序通信的一端,通过系统调用使得程序与网络设备之间的交流连接起来。 应用程序 -> 系统调用 -> 插口层 -> 协议层 -> 接口层 ->发送(接收的话与之相反)
8 X3 p; |8 t5 _% F * Z% L( i1 n1 c+ A
+ s% j6 o/ b' u) K' v如何标识一个SOCKET: 如上定义所述,可以通过地址,协议,端口三要素来确定一个通信端,而在linux C程序中使用 标识符 来标识一个 SOCKET,Unix系统对设备的读写操作等同于对描述符的读写操作,标识符可以用于:插口 管道 目录 设备 文件等等
, }& J! Q9 }; o 描述符是个正整数,事实上他是检查表表项中的一个下标,用于指向打开文件表的结构。 述符前三个标识符0 1 2 分别系统保留:标准输入(键盘),标准输出(屏幕),标准错误输出 当我们使用新的描述符来创建socket时,他一般从最小未使用的数字开始分配,也就是3
3 X9 I. }- E" I0 h: E; R1 U& H4 U2 Q! G# f* M+ }* d; Y$ N) J( s
服务端实现的流程: 1.服务端开启一个SOCKET(socket函数) 2.使用SOCKET绑定一个端口号(bind函数) 3.在这个端口号上开启监听功能(listen函数) 4.当有对端发送连接请求,向其发送ack+syn建立连接(accept函数) 5.接收或者回复消息(read函数 write函数)
' r- B0 E, S, O- X5 T
% R/ Y. u) ~* Y客户端实现流程: 1.打开一个SOCKET 2.向指定的IP 和端口号发起连接(connect函数) 3.接收或者发送消息(send函数 recv函数) - G& V$ _" |: A! \. N$ u( B) d7 U
1 o4 \ @1 ]( i' X& W8 S; H6 r6 M ?. l) D
如何并发处理: 如果按照以上流程实现其实并不难,但是有个缺陷,因为C语言是按顺序单一流程运行,也就是说如果 直接在程序当中使用accept函数(建立连接)的话,那么程序会阻塞在accept这里,这是因为如果客户端 一直没有发送connect连接,那么accept就无法得知客户端的IP和端口,也就只能一直等待(阻塞)直到 有请求触发继续执行为止,这样就导致如果同时多个客户向服务端发送请求连接,那么服务端只能按照 单一线程去处理第一个客户端,无法开启多个线程同时处理多个用户的请求。
% L" v M/ y. V8 O, w6 X5 L
) e7 m! L) l# W& q: K0 o% D9 q. X如何解决: 下面摘文截取网上的资料,有兴趣者可以看看 系统提供select函数来实现多路复用输入/输出模型,该函数用于在非阻塞中,当一个套接字或一组套接字有信号时通知你 - int select(int nfds, fd_set *readfds, fd_set *writefds, exceptfds, const struct timeval* timeout);
复制代码所在的头文件为: - #include <sys/time.h>
$ D# h0 z5 Y B; U* i; H
3 E7 L: ^: `* S9 D- #include <unistd.h>
复制代码 功能:测试指定的fd是否可读,可写 或者 是否有异常条件待处理
" B2 m) y2 S( y1 q3 H readset 用来检查可读性的一组文件描述字。
* y' c O4 }" }0 z' \' u writeset 用来检查可写性的一组文件描述字。
0 @" g9 S0 q, J
exceptset用来检查是否有异常条件出现的文件描述字。(注:不包括错误) & l: [9 [" v* O7 @0 I
timeout 用于描述一段时间长度,如果在这个时间内,需要监视的描述符没有事件发生则函数返回,返回值为0。3 z+ R0 r# F5 d# i5 k- V) E- y- h0 U
1 L; l4 }1 Q2 p: @( I2 P" N 对于select函数的功能简单的说就是对文件fd做一个测试。测试结果有三种可能:
6 j, ] h" n. L, l; _
: X! a& f5 d8 T0 }4 d- 1.timeout=NULL (阻塞:select将一直被阻塞,直到某个文件描述符上发生了事件)
7 C9 e1 M I% L8 w6 U
: |' i4 p) i: \5 L3 r3 M- 2.timeout所指向的结构设为非零时间 (等待固定时间:如果在指定的时间段里有事件发生或者时间耗尽,函数均返回)
" u7 B& u" v: J; Q5 v& H
$ ^7 M/ X* ?* f3 q# c, l- 3.timeout所指向的结构,时间设为0 (非阻塞:仅检测描述符集合的状态,然后立即返回,并不等待外部事件的发生)
复制代码 返回值: 返回对应位仍然为1的fd的总数。注意啦:只有那些可读,可写以及有异常条件待处理的fd位仍然为1。 否则为0哦。举个例子,比如recv(), 在没有数据到来调用它的时候,你的线程将被阻塞,如果数据一直不来, 你的线程就要阻塞很久.这样显然不好。所以采用select来查看套节字是否可读(也就是是否有数据读了) 。 现在,UNIX系统通常会在头文件<sys/select.h>中定义常量FD_SETSIZE,它是数据类型fd_set的描述字数量, 其值通常是1024,这样就能表示<1024的fd。2 a5 H) H, z* `
0 A- {8 o* ~8 m# h9 A% J
2 i; a% s9 x/ f, g fd_set结构体: 文件描述符集合,用于存放多个fd(文件描述符,这里就是套接字) 可以存放服务端的fd,有客户端的fd。下面是对这个文件描述符集合的操作: - FD_ZERO(*fds): 将fds设为空集6 d% o4 m- }2 b7 C
-
3 }2 K" s7 e9 d" d6 k( P5 c& j, j& K - FD_CLR(fd,*fds): 从集合fds中删除指定的fd, e' C4 A$ b. Z. A
- 2 D. k. j* x) u3 i
- FD_SET(fd,*fds): 从集合fds中添加指定的fd
9 R# N% U% e1 e4 U2 R/ e
. H9 |5 [# l* F: G0 d `. @( j- FD_ISSET(fd,*fds): 判断fd是否属于fds的集合
复制代码步骤如下 - socket s;' u8 O& s0 c! R4 B$ I5 \% }
- .....
8 t4 v& z: y! u. c5 v - fd_set set;
/ y( h+ ]" |7 t) }1 ` - while(1){
) s, a+ \0 J7 T: [. r! d" L; S) _ - FD_ZERO(&set); //将你的套节字集合清空
, r' ~7 z6 r7 z$ s$ }' E - FD_SET(s, &set); //加入你感兴趣的套节字到集合,这里是一个读数据的套节字s
- M% g) U: M) H1 m% [ - select(0,&set,NULL,NULL,NULL); //检查套节字是否可读,; ?" I8 |! K$ h6 k( U" T
- if(FD_ISSET(s, &set) //检查s是否在这个集合里面,
9 s" T0 J+ v1 H: f$ H* n q. l - { //select将更新这个集合,把其中不可读的套节字去掉
& e0 R! R( g) J9 v- y. d/ G - //只保留符合条件的套节字在这个集合里面
! e0 F" _ ]7 I. J7 z4 y x$ \# O0 u - recv(s,...);
! N9 e' q9 g: V8 }, J - }4 J8 _) y7 L8 r
- //do something here! \* L f* g6 }5 Q- s
- }
复制代码假设fd_set长度为1字节,fd_set中的每一位可以对应一个文件描述符,那么1字节最大可以对应8个fd - (1)执行fd_set set; FD_ZERO(&set); 则set用位为0000,0000。# }# r5 R4 V* e* B- r7 U
- ( }; I% Y3 }& F, ~4 G9 y
- (2)若fd=5,执行FD_SET(fd,&set); 后set变为 0001,0000(第5位置为1), P: l8 c4 J, K; g. w) I; R1 ?; Q
0 F7 i1 r; |8 P- (3)若再加入fd=2,fd=1 则set变为 0001,0011
+ O6 h7 T. }- P5 k' j
5 |/ w9 H4 T! @4 _) g* c- (4)执行select(6,&set,0,0,0) 阻塞等待5 I1 S$ M2 f' X! I" e) A
- % A% q- f& {% H4 L+ n u% t
- (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' @$ A# r7 ^3 |: @, q- `# M# i1 S9 @! I" p* D9 G% c; {/ {8 G
使用select函数的过程一般是:
' t* C# d6 l1 m* T7 m 先调用宏FD_ZERO将指定的fd_set清零,然后调用宏FD_SET将需要测试的fd加入fd_set,
接着调用函数select测试fd_set中的所有fd,最后用宏FD_ISSET检查某个fd在函数select调用后,相应位是否仍然为1 复制粘贴的摘文排版起来真的是痛苦,我已经尽力排版了。。。9 K" i/ i2 Y! V3 C) M+ u7 ^3 E
' @) y: x j( f客户端: - #include <time.h>
( d9 A3 P% }1 s ~9 b, j7 W$ |; `+ \% R - #include <stdio.h>* `9 W/ v1 \2 j+ Y1 Y
- #include <stdlib.h>7 e% [- h8 v; V2 v
- #include <string.h>
! s8 P8 \, y5 ?/ f - #include <unistd.h>7 O. I/ l* \& b3 v: w: n7 y, ]; `9 e
- #include <arpa/inet.h>
4 D9 N% N9 I; b$ D; W - #include <netinet/in.h>& ^! S4 q% ]* `2 k" ]- P
- #include <fcntl.h>: |& x! v _$ F; r
- #include <sys/stat.h>8 `! C- y& }1 H- e: q# }; N W" @ Z
- #include <sys/types.h>; i) j8 W0 U \
- #include <sys/socket.h>
* A; x/ L$ B; l# d r - : M$ H- d, m& D$ x1 x' |
- #define REMOTE_PORT 6666 //服务器端口$ o8 ?; ?* c* d; T
- #define REMOTE_ADDR "127.0.0.1" //服务器地址
0 I& _# U% g# p( ^ -
2 c) ~- F1 Q N5 v, t. x - int main(){
7 z$ }4 q% @! G/ P - int sockfd;
2 y N5 v, G# J/ S& O: m/ a& J% ] - struct sockaddr_in addr;
4 E3 s1 J2 m! ?/ e' @9 w4 V" z Z - char msgbuffer[256];
9 a7 I; P& t: {6 e - % ^9 I: D4 L/ i' ]7 l- [
- //创建套接字6 q9 c; {: d/ a6 B3 b* q9 c
- sockfd = socket(AF_INET,SOCK_STREAM,0);
& P; M( t; I4 A8 d' f - if(sockfd>=0)/ {: i8 j+ a( p1 k
- printf("open socket: %d\n",sockfd);7 n |' ?# |; B4 w
-
& B3 F m7 B$ H4 t9 j9 \( l5 H$ ^ - //将服务器的地址和端口存储于套接字结构体中
0 g6 \ v+ k) d" O( ^ - bzero(&addr,sizeof(addr));
# i1 E' J% u, k6 |" n - addr.sin_family=AF_INET;
+ N3 G, [8 t* K: ]# |, y; v q - addr.sin_port=htons(REMOTE_PORT);
3 S4 r/ c& {9 u7 {. _ V, o - addr.sin_addr.s_addr = inet_addr(REMOTE_ADDR);
! k# b$ V) L2 i. J* D3 G - 1 h: T) y0 y' a- `( U# J0 X; D
- //向服务器发送请求
7 \8 @4 }9 s! M8 p9 W - if(connect(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)
5 p9 A5 w/ ` F, g9 F9 }1 A - printf("connect successfully\n");
; m! @) H2 X3 @4 u6 K# p2 J! f - ! X% j8 A* i. Y9 F e( x) Y4 i% j# s3 L
- //接收服务器返回的消息(注意这里程序会被阻塞,也就是说只有服务器回复信息,才会继续往下执行)
C! o5 y' U5 ?, [, a/ e2 K! m- | - recv(sockfd,msgbuffer,sizeof(msgbuffer),0);. Z6 ]$ U& N' N8 P7 d
- printf("%s\n",msgbuffer);
5 [0 M) J5 n' ?* F( ]1 r4 ? -
* v# o1 x7 R5 q - while(1){
/ r2 @* N' d) o5 z. `0 S D - //将键盘输入的消息发送给服务器,并且从服务器中取得回复消息
$ }1 u& t t: I$ Z2 b - bzero(msgbuffer,sizeof(msgbuffer));
+ s2 l3 U: v7 v - read(STDIN_FILENO,msgbuffer,sizeof(msgbuffer));
, |' J: O* y8 S/ [1 z - if(send(sockfd,msgbuffer,sizeof(msgbuffer),0)<0)$ d3 Z5 g" _8 n) P7 \
- perror("ERROR");
. l' [" `( ?/ q+ |) e H% g, w1 b -
, V& W/ N! J! X' a - bzero(msgbuffer,sizeof(msgbuffer));
$ S- v) N2 M: @3 d; e( w - recv(sockfd,msgbuffer,sizeof(msgbuffer),0);: | y& X1 p& y- `% X
- printf("[receive]:%s\n",msgbuffer);& t& V0 y9 W5 N' a
- , A1 B- y6 @) [+ r' Y/ h
- usleep(500000);+ s; x: P( o# b7 y8 z! w2 O
- }
% q' G+ _$ l* y2 f: F - }
复制代码 ! A+ Y0 r# m& j2 X
1 `& g( u0 y; Q$ ~. E
服务端: - #include <time.h>
( z$ l, x& d7 d - #include <stdio.h>
! R7 q! f. h+ z; x& A3 u$ ? - #include <stdlib.h>
- w) M. Z2 f( s4 k+ n' x( u& e - #include <string.h>( k1 z0 k Z7 X {
- #include <unistd.h>
2 g# }! n4 s4 X, }$ z' }+ u - #include <arpa/inet.h>% S/ m: d+ q5 j) x M
- #include <netinet/in.h>
/ h4 s9 d- A# }8 l: N( E - #include <sys/types.h>
4 {0 e' Q+ c2 Q; k5 y - #include <sys/socket.h>
1 k% J/ ^" G) Q$ v m$ t - 5 q4 v% \2 V. i5 B% H" ~
- #define LOCAL_PORT 6666 //本地服务端口
5 @* U9 z. P6 M$ f - #define MAX 5 //最大连接数量2 u2 j7 v: V. ?( S
- : X) a" z7 b; X8 M4 w. ?
- int main(){: @9 r" F3 e- F+ S, x/ j
- int sockfd,connfd,fd,is_connected[MAX];4 D0 X- H) z- [
- struct sockaddr_in addr;5 P I' A* m7 n2 U1 O
- int addr_len = sizeof(struct sockaddr_in);0 i' @5 |( U& V& p! E N, Y
- char msgbuffer[256];
8 C6 [; p8 ^; Z* W- i5 @- H - char msgsend[] = "Welcome To Demon Server";3 b( w% T) F& Q* H k
- fd_set fds;
! u" c2 U. C& [; G1 v4 v - 2 }3 U% z6 p* w; M4 M3 H6 P- d$ x+ t
- //创建套接字, Q; W% [- G# g6 w& {) B3 J
- sockfd = socket(AF_INET,SOCK_STREAM,0);+ P0 S1 l4 n0 t
- if(sockfd>=0)
( P- m N8 U: O5 J R0 X - printf("open socket: %d\n",sockfd);
- b) {' Y9 M$ z$ l - - _* q# c4 n" K4 E
- //将本地端口和监听地址信息保存到套接字结构体中
7 E4 c% c% }$ S) t8 D9 b! z4 Y$ o - bzero(&addr,sizeof(addr));
8 e. ]* g4 L# X - addr.sin_family=AF_INET;
/ d3 u* i# x' C - addr.sin_port=htons(LOCAL_PORT);4 d7 N6 E7 l$ ~* X. ^* P
- addr.sin_addr.s_addr = htonl(INADDR_ANY); //INADDR_ANY表示任意地址0.0.0.0 0.0.0.06 S; r0 J C/ y( Q. K" J& g
- " j( ~6 H: x) Z3 P. A0 E4 t! f% P
- //将套接字于端口号绑定
" \$ ^" t: I; p1 G7 A6 ^3 |0 { - if(bind(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)
/ O5 w: d" y% D) t4 |5 W4 q3 j - printf("bind the port: %d\n",LOCAL_PORT);! D4 Q2 }6 N# u* Q( n
- 3 i9 c9 H+ i y. V- u
- //开启端口监听
6 H# ?4 J, b. y" B0 I - if(listen(sockfd,3)>=0)
1 w3 C( [2 n6 Z9 K - printf("begin listenning...\n");7 k y7 t, J/ g, s
-
( `8 T3 I+ Y- b4 z ~- | - //默认所有fd没有被打开
& t. F4 u# [! m3 q8 \ - for(fd=0;fd<MAX;fd++)0 h9 X# h1 g/ [$ M* v
- is_connected[fd]=0;
! w3 ]8 i+ I6 V; A2 H( Z9 q - ) }) U7 P( I7 i- G: P
- while(1){
% G0 D. S& \' S4 g: @. ? - //将服务端套接字加入集合中
- p7 v C% T: ]7 q2 D" }+ ~% u - FD_ZERO(&fds);
" |% P8 g1 r. v4 M6 h# b4 l& s - FD_SET(sockfd,&fds);$ A: n; Y u3 C$ C; E6 b8 |
-
5 o0 `' \5 U. Z! }' M; Q - //将活跃的套接字加入集合中* P5 X7 Q7 m& \8 k. D4 F7 C
- for(fd=0;fd<MAX;fd++)
9 Z1 n$ i. x: s/ U" I+ X4 `2 [, F - if(is_connected[fd])1 }' n2 Q+ T; l( F- p
- FD_SET(fd,&fds);
2 G" k) T: W. q3 d! l- Y - ( [* `" H& |* L5 Z
- //监视集合中的可读信号,如果某个套接字有信号则继续执行,此时集合中只有存在信号的套接字会被置为1,其他置为0
/ H; E; ^# F& g; N2 [+ o4 \ - if(!select(MAX,&fds,NULL,NULL,NULL)) o* ^: Z4 }' y6 D* O, ?
- continue;
- l6 V! z3 L: \0 A- i3 J - 4 T0 o; S$ G6 y, J& q! A9 M
- //遍历所有套接字判断是否在属于集合中的活跃套接字2 H) G5 T$ u: z
- for(fd=0;fd<MAX;fd++){) i* `* ]+ k) Z J8 s, |
- if(FD_ISSET(fd,&fds)){
# _/ X1 x' a2 p0 Y& g; Q: j( m( c+ p - if(fd==sockfd){ //如果套接字是服务端,那么与客户端accept建立连接
2 U. M5 k8 e8 m - connfd = accept(sockfd,(struct sockaddr*)&addr,&addr_len);) b/ @ {0 `" x& s" s& ]5 M
- write(connfd,msgsend,sizeof(msgsend)); //向其输出欢迎语' k- d% z; Y) f
- is_connected[connfd]=1; //对客户端的fd对应下标将其设为活跃状态,方便下次调用
" Y4 r$ T8 R( m# W% E1 Q/ N0 m - printf("connected from %s\n",inet_ntoa(addr.sin_addr));/ ~) a1 F, I% f$ w8 @! l5 l
- }else{ //如果套接字是客户端,读取其信息并返回,如果读取不到信息,冻结其套接字- C. s1 G( ~* x" Q- g4 ?
- if(read(fd,msgbuffer,sizeof(msgbuffer))>0){
9 d1 H* W* N3 c+ g7 G - write(fd,msgbuffer,sizeof(msgbuffer));
. {) w, M- U0 Q! n. u4 l5 ?! h - printf("[read]: %s\n",msgbuffer);0 h! w( Y4 q! S: t
- }else{
0 A$ I( o9 S' V* J3 U1 ?5 m1 e' R' I - is_connected[fd]=0;
& V1 F' _* d: ?& T, M - close(fd);
5 o1 z* q6 U4 W, I: Q+ ?+ b( C8 X - printf("close connected\n");
4 K- m4 E( y1 Q* y - }& {8 @2 \* x r' G) u4 H; r( }
- }- y5 H1 {1 W% N# z- R
- }, c8 X, f4 R( A) j5 O) C" f j5 M) m) K
- }
- ^& n8 l* v# z( }/ v! X - }
! v7 h; V5 R4 Y, `9 |& x7 [# ^9 M/ H - }
复制代码 . S) o( u7 W1 j, f y0 b0 [
$ R: k, x/ }' l9 \8 ~, i; \1 U/ p8 ?
+ t: b; j# m: Z" {6 M. b; j8 O) w. A! ?+ R7 H# D. v- m
/ `$ y" `. d/ M! ?7 d) z
|