实验环境是linux系统,效果如下: 1.启动服务端程序,监听在6666端口上 2.启动客户端,与服务端建立TCP连接 3.建立完TCP连接,在客户端上向服务端发送消息 4.断开连接 实现的功能很简单,但是对于初来乍到的我费了不少劲,因此在此总结一下,如有错点请各位大神指点指点 E% A& p7 ~3 G
什么是SOCKET(插口): 这里不用 "套接字" 而是用 "插口" 是因为在《TCP/IP协议卷二》中,翻译时也是用 "插口" 来表示socket的。; d4 {( f+ k/ z$ V
"套接字" 这词不知道又是哪个教授级人物造出来的,听起来总是很怪,虽然可以避免语义上的歧义,但不明显。 对插口通俗的理解就是:它是一个可以用来输入或者输出的网络端,另一端也具有同样相对应的操作。 具体其他高级的定义不是这里的重点。值得说的是: 每个插口都可以标识某个程序通信的一端,通过系统调用使得程序与网络设备之间的交流连接起来。 应用程序 -> 系统调用 -> 插口层 -> 协议层 -> 接口层 ->发送(接收的话与之相反)
) u5 u8 J! ^, H0 C
& w& r% w( J" z! z* Y
: Q( G1 H+ |, a$ l1 k如何标识一个SOCKET: 如上定义所述,可以通过地址,协议,端口三要素来确定一个通信端,而在linux C程序中使用 标识符 来标识一个 SOCKET,Unix系统对设备的读写操作等同于对描述符的读写操作,标识符可以用于:插口 管道 目录 设备 文件等等
. a1 W( x# `' E( ^8 P& { 描述符是个正整数,事实上他是检查表表项中的一个下标,用于指向打开文件表的结构。 述符前三个标识符0 1 2 分别系统保留:标准输入(键盘),标准输出(屏幕),标准错误输出 当我们使用新的描述符来创建socket时,他一般从最小未使用的数字开始分配,也就是3
, K* p. T- T% j% G9 G
: y6 A% |$ d/ y& _1 g& R, u服务端实现的流程: 1.服务端开启一个SOCKET(socket函数) 2.使用SOCKET绑定一个端口号(bind函数) 3.在这个端口号上开启监听功能(listen函数) 4.当有对端发送连接请求,向其发送ack+syn建立连接(accept函数) 5.接收或者回复消息(read函数 write函数) 5 w( b4 I& i6 i- c/ q
7 v6 ]; u. c/ m4 b% h, ~
客户端实现流程: 1.打开一个SOCKET 2.向指定的IP 和端口号发起连接(connect函数) 3.接收或者发送消息(send函数 recv函数) 8 T+ O* O( f9 z% b& o
& ?! t M6 p8 A r4 O$ |2 s+ w! h/ z8 e$ y
如何并发处理: 如果按照以上流程实现其实并不难,但是有个缺陷,因为C语言是按顺序单一流程运行,也就是说如果 直接在程序当中使用accept函数(建立连接)的话,那么程序会阻塞在accept这里,这是因为如果客户端 一直没有发送connect连接,那么accept就无法得知客户端的IP和端口,也就只能一直等待(阻塞)直到 有请求触发继续执行为止,这样就导致如果同时多个客户向服务端发送请求连接,那么服务端只能按照 单一线程去处理第一个客户端,无法开启多个线程同时处理多个用户的请求。 5 x+ ^6 Y2 B% W1 J/ c3 I0 @0 \/ p
i5 |& _4 o3 z0 a) ?7 R
如何解决: 下面摘文截取网上的资料,有兴趣者可以看看 系统提供select函数来实现多路复用输入/输出模型,该函数用于在非阻塞中,当一个套接字或一组套接字有信号时通知你 - int select(int nfds, fd_set *readfds, fd_set *writefds, exceptfds, const struct timeval* timeout);
复制代码所在的头文件为: - #include <sys/time.h>
% @- _. Q) P* J: s3 x5 V" O& p
/ R8 o& }% n6 h. s- #include <unistd.h>
复制代码 功能:测试指定的fd是否可读,可写 或者 是否有异常条件待处理 . Z/ w: l( n9 a( v6 g+ k* n& |
readset 用来检查可读性的一组文件描述字。 x( b: C- y$ H/ }! [8 i! d
writeset 用来检查可写性的一组文件描述字。
: t9 D- s- W, `4 b; ~ exceptset用来检查是否有异常条件出现的文件描述字。(注:不包括错误)
2 R" B& M# q: O4 w
timeout 用于描述一段时间长度,如果在这个时间内,需要监视的描述符没有事件发生则函数返回,返回值为0。
. F5 k: h3 @$ Q! K: D, ?/ t/ x
$ {, ~0 q! u* M% j2 y$ f2 M 对于select函数的功能简单的说就是对文件fd做一个测试。测试结果有三种可能:. h. V# T; s( R' s
" p3 m! D3 `# \0 B- 1.timeout=NULL (阻塞:select将一直被阻塞,直到某个文件描述符上发生了事件)" y$ M' ~" w. z# Q4 @1 b
2 N4 {4 s5 }, @$ C0 q9 }3 f; k- 2.timeout所指向的结构设为非零时间 (等待固定时间:如果在指定的时间段里有事件发生或者时间耗尽,函数均返回): J* n4 W0 q! S
" y3 R4 i) f8 c) C4 x. s/ r- 3.timeout所指向的结构,时间设为0 (非阻塞:仅检测描述符集合的状态,然后立即返回,并不等待外部事件的发生)
复制代码 返回值: 返回对应位仍然为1的fd的总数。注意啦:只有那些可读,可写以及有异常条件待处理的fd位仍然为1。 否则为0哦。举个例子,比如recv(), 在没有数据到来调用它的时候,你的线程将被阻塞,如果数据一直不来, 你的线程就要阻塞很久.这样显然不好。所以采用select来查看套节字是否可读(也就是是否有数据读了) 。 现在,UNIX系统通常会在头文件<sys/select.h>中定义常量FD_SETSIZE,它是数据类型fd_set的描述字数量, 其值通常是1024,这样就能表示<1024的fd。( u# H/ X9 c* i7 \( U7 z1 _
1 D& [- w! I5 p% h" P- C4 t
& s- M/ m( o5 Q4 Q fd_set结构体: 文件描述符集合,用于存放多个fd(文件描述符,这里就是套接字) 可以存放服务端的fd,有客户端的fd。下面是对这个文件描述符集合的操作: - FD_ZERO(*fds): 将fds设为空集9 ]3 T' f: Z; Y3 b' C
- $ w! l$ P4 D0 w$ s* V
- FD_CLR(fd,*fds): 从集合fds中删除指定的fd3 i+ ~! t* p$ X7 ]; Y
# w) C" L6 q8 p2 z/ H T- FD_SET(fd,*fds): 从集合fds中添加指定的fd
% N' k p3 Z9 ~
5 F, [/ @2 i1 d' x1 G0 C. G1 j- FD_ISSET(fd,*fds): 判断fd是否属于fds的集合
复制代码步骤如下 - socket s;7 J g+ r/ m. C" G; k
- .....! f9 V2 U% |1 l3 S" K- R
- fd_set set;
9 U0 \- _; ?$ L$ \% a4 Z - while(1){
/ X2 s2 k2 P) H' n1 { - FD_ZERO(&set); //将你的套节字集合清空
" v5 o5 ~( f/ x' k$ y' z$ m - FD_SET(s, &set); //加入你感兴趣的套节字到集合,这里是一个读数据的套节字s1 a j! ~. _6 C; N; s
- select(0,&set,NULL,NULL,NULL); //检查套节字是否可读,0 U; N- |( p% F6 U3 `9 ?
- if(FD_ISSET(s, &set) //检查s是否在这个集合里面,
( T; Q; C; i3 e: @& i# v1 z6 N3 l0 x - { //select将更新这个集合,把其中不可读的套节字去掉
; c8 C- r, Z6 ^7 a% ^ - //只保留符合条件的套节字在这个集合里面
1 w7 P, D3 M( k- ] - recv(s,...);
' [# ?5 N4 Y6 P: g* M/ `' k - }
1 @% L/ e. g X! n3 R# m8 l - //do something here# y/ `4 j. w% ?4 s3 o1 }
- }
复制代码假设fd_set长度为1字节,fd_set中的每一位可以对应一个文件描述符,那么1字节最大可以对应8个fd - (1)执行fd_set set; FD_ZERO(&set); 则set用位为0000,0000。
$ y1 g+ L E r& W( c% k6 s) ]4 s - + ^9 b, m$ u0 W! u
- (2)若fd=5,执行FD_SET(fd,&set); 后set变为 0001,0000(第5位置为1)8 a4 R8 u5 W' g Z; L/ t* P
! N6 X/ w: r3 J+ F7 W- (3)若再加入fd=2,fd=1 则set变为 0001,0011
% \7 K4 Z5 d% h8 j$ g7 _* u: ]4 u, L - # S8 h7 W# E+ w6 W* x& k
- (4)执行select(6,&set,0,0,0) 阻塞等待
4 E% [1 K* P4 Q - 9 f- s, F, L. i+ l! q
- (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.具体过程看代码会好理解 & J% G* s) P0 Y) h. g4 A3 _- k
# ~" ]- s, U, J$ z8 `/ Q* H8 @# G
使用select函数的过程一般是:
3 K6 m& M- E5 u* h5 H# l ?$ t1 Q 先调用宏FD_ZERO将指定的fd_set清零,然后调用宏FD_SET将需要测试的fd加入fd_set,
接着调用函数select测试fd_set中的所有fd,最后用宏FD_ISSET检查某个fd在函数select调用后,相应位是否仍然为1 复制粘贴的摘文排版起来真的是痛苦,我已经尽力排版了。。。9 h: I, f$ n) }* u9 } h
' R: t6 {( T" `! [% n客户端: - #include <time.h>( r2 z" ]3 g: J
- #include <stdio.h>
4 V( N* J+ d" }+ D5 L; s+ t - #include <stdlib.h>" n7 I# O4 ?. ~# Z
- #include <string.h>
0 @% [8 h( l3 i _ - #include <unistd.h>
1 S' \1 d9 E3 v# s: h! V - #include <arpa/inet.h>1 e: H$ N; T: c
- #include <netinet/in.h>7 {: @! g6 T0 o+ ?" {7 f7 Q6 r0 d; w3 Y
- #include <fcntl.h>$ C$ S" p5 h: {' L# q
- #include <sys/stat.h>- W3 g3 |# A( |% q$ K( R3 n' b# Q
- #include <sys/types.h>9 d% O5 T1 F' {1 O1 Q
- #include <sys/socket.h>
, z) ]& O- J) ], w0 g -
- s3 q6 r2 f- d. M: H( F - #define REMOTE_PORT 6666 //服务器端口. }' f7 `9 a4 S v8 i: T
- #define REMOTE_ADDR "127.0.0.1" //服务器地址
4 R. o8 l1 L' ?# x* B8 g; C) [* P2 J -
$ I4 U; {9 E8 C7 a1 I) T - int main(){
7 N3 J- E$ G# l5 f - int sockfd;
" B, ?* Z( B7 i7 z' Y/ C - struct sockaddr_in addr;
% M' s/ E2 n0 v& X- { - char msgbuffer[256];1 ~% U( q/ ?: X) j; S
- 5 R$ K1 u% P+ B5 q; b9 W2 S$ h
- //创建套接字
u4 q' b. F8 i; x* n1 g - sockfd = socket(AF_INET,SOCK_STREAM,0);: c( ^% y6 W$ W: U* k
- if(sockfd>=0)
. W/ M* t1 H7 h& s$ X/ o/ b* C3 E - printf("open socket: %d\n",sockfd);
+ t- S& l2 P+ f: s# V4 q2 o# ? - ; M0 @, a' k" x
- //将服务器的地址和端口存储于套接字结构体中: x }" d; e, ~0 d
- bzero(&addr,sizeof(addr));" d3 P) O0 D a3 |
- addr.sin_family=AF_INET;
. D( \: r/ C/ W - addr.sin_port=htons(REMOTE_PORT);+ O+ Y7 f4 S0 U; [7 k, D4 O, W6 d
- addr.sin_addr.s_addr = inet_addr(REMOTE_ADDR);
8 q$ A9 n6 J: z" j9 ] - 3 R; U/ v; ]. _1 c( m7 h5 a
- //向服务器发送请求3 a- Q |: O6 z9 {' p
- if(connect(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)2 s& A5 {/ j9 z+ v6 j( y$ D
- printf("connect successfully\n");# j, ]2 _' b1 a' A
- + v$ A4 S* o6 R7 ^
- //接收服务器返回的消息(注意这里程序会被阻塞,也就是说只有服务器回复信息,才会继续往下执行)
& G& q1 V8 k7 W. v - recv(sockfd,msgbuffer,sizeof(msgbuffer),0);
/ F! ~) ?3 Y' Z6 ?5 _# P8 y# ?+ p6 J$ b - printf("%s\n",msgbuffer);
5 T8 A/ s2 o# [+ a. C4 P1 J -
8 V* b% Z. S7 P8 Q `+ j9 A9 A - while(1){
9 k: R4 m* l: S; H# s w) F4 W1 z - //将键盘输入的消息发送给服务器,并且从服务器中取得回复消息
s) m3 e! w q$ C - bzero(msgbuffer,sizeof(msgbuffer));
$ r; J3 R# r$ ~- s# v - read(STDIN_FILENO,msgbuffer,sizeof(msgbuffer));0 w. [3 C, X( \6 r9 A/ _, _, v
- if(send(sockfd,msgbuffer,sizeof(msgbuffer),0)<0)
5 q4 n6 T6 I1 E4 R% g - perror("ERROR");2 v3 w. j% A( |
-
1 |# n& d% r' Q9 Z - bzero(msgbuffer,sizeof(msgbuffer));
6 y* a, k& l4 s* N, f, y. ?) J - recv(sockfd,msgbuffer,sizeof(msgbuffer),0);
1 F& F0 E; R) B$ z+ f% I0 }2 r - printf("[receive]:%s\n",msgbuffer);
) Z. t7 ]+ f u l$ q) O1 ? -
9 G! [; c' H+ T7 S; ~ H - usleep(500000);
6 l) X/ s" |( L- z7 @ - }7 ^! R$ p: a+ }
- }
复制代码 6 f) [1 i2 F a
$ e6 ` ?5 ]% ]9 ^. R服务端: - #include <time.h>3 }) J* R* `2 n3 m
- #include <stdio.h>
' x* i }% M8 e x8 O - #include <stdlib.h>
0 Q) g) w: y3 J% z2 f$ z - #include <string.h>6 h2 S1 ?: u3 Z- u. s8 P
- #include <unistd.h>8 E. y L, q3 f( m [
- #include <arpa/inet.h>
; x5 @1 E& F0 T+ i1 X - #include <netinet/in.h>
& t7 Y0 j5 B8 u4 y0 Y9 F/ T8 y6 f - #include <sys/types.h>, L% F' n$ U0 X' l/ T, N9 r' w
- #include <sys/socket.h>4 ~% B: q, n' R$ K, J
-
- ?) F, {2 n" w, L; S# z - #define LOCAL_PORT 6666 //本地服务端口# L4 f v; D: J! [8 D: G8 s# `
- #define MAX 5 //最大连接数量
9 a9 B4 Y# x0 D$ j/ o7 b& b$ c - + e1 |5 z5 _' @. z. h' h, z
- int main(){
, [; ]5 K6 A3 V# W6 X/ ^0 c - int sockfd,connfd,fd,is_connected[MAX];
- J. d) g: e& s5 J9 e6 Q" m7 [ - struct sockaddr_in addr;
( ]8 b: ~. x8 c0 K) _# I - int addr_len = sizeof(struct sockaddr_in);8 e3 c4 A, L* m: _
- char msgbuffer[256];
1 P5 m8 ?3 i" O& L6 i0 C - char msgsend[] = "Welcome To Demon Server";: D1 ~: P" o. F% U5 I
- fd_set fds;/ V2 ]$ X, e3 R ~
-
# `1 [; D! ]( q - //创建套接字
0 n& h; X5 E$ V# w! \ - sockfd = socket(AF_INET,SOCK_STREAM,0);9 b( k- J1 _& B
- if(sockfd>=0)
' x. u$ b; x) D - printf("open socket: %d\n",sockfd);' a5 d; X4 i4 ]
-
- a# |, H; J7 j' ~) F; `2 i - //将本地端口和监听地址信息保存到套接字结构体中1 ^. J K( X; t7 g# F% x5 j1 v
- bzero(&addr,sizeof(addr));, M& q! h4 o3 t7 @1 A. M
- addr.sin_family=AF_INET;6 g1 a, m: u7 V$ B5 t% M7 y
- addr.sin_port=htons(LOCAL_PORT);4 q* W8 l. H# `' }2 i' j# A
- addr.sin_addr.s_addr = htonl(INADDR_ANY); //INADDR_ANY表示任意地址0.0.0.0 0.0.0.0
5 E! z5 p5 e5 R5 v: U) s( O -
) }/ \* U$ a; }- v) } - //将套接字于端口号绑定# ~9 _: {0 A7 P2 c4 Z3 H
- if(bind(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)
, i3 h! N4 G" i, C9 u - printf("bind the port: %d\n",LOCAL_PORT);
) t7 x1 {, k; x3 G9 ~8 X4 O. @2 e - ( a3 w0 X) { z1 l( ~+ ^
- //开启端口监听$ ~; u; R1 k0 j% ]
- if(listen(sockfd,3)>=0) s& e+ @, }' t" _
- printf("begin listenning...\n");
% a D6 `! B; [9 f% t' W1 `$ ?8 I - # | ~6 C' V; v2 |3 M0 f. y8 t
- //默认所有fd没有被打开3 d* E v" G! g; E
- for(fd=0;fd<MAX;fd++)) _, c) ~3 D/ t0 c6 t
- is_connected[fd]=0;* B' ~# r& W9 R2 E
-
3 c8 S R$ p& `/ M/ w - while(1){
/ U. p2 i, O* T0 G5 O" O0 u4 g - //将服务端套接字加入集合中
' T0 w, x% C' K4 S& B - FD_ZERO(&fds);
+ b- y4 q/ x7 G6 q. L9 h' ]+ [ - FD_SET(sockfd,&fds);
$ W( X; s7 E' | - 0 q4 W7 L; E, b1 v5 y$ @: C
- //将活跃的套接字加入集合中7 w/ A# L4 a4 S/ D0 H) o
- for(fd=0;fd<MAX;fd++)& N" t5 o( g8 O8 q; t
- if(is_connected[fd])
6 k' B1 `' y% R q8 | - FD_SET(fd,&fds);
3 }3 J5 V1 P. Y4 n - 6 C" `" N: ~5 T" {
- //监视集合中的可读信号,如果某个套接字有信号则继续执行,此时集合中只有存在信号的套接字会被置为1,其他置为0
2 L. G% j5 o, v- p: o& |+ ^ - if(!select(MAX,&fds,NULL,NULL,NULL))" a* B. i8 `( ?0 P; D* H
- continue;/ b/ X, c# f' N+ k1 K4 l$ M% ]
- 9 v6 n1 J: L& n/ C* W# i6 d' j- p% T
- //遍历所有套接字判断是否在属于集合中的活跃套接字4 B3 u, U! K3 ^6 `* @" N: @3 p
- for(fd=0;fd<MAX;fd++){6 D8 ?/ p8 |: T6 z: I8 V
- if(FD_ISSET(fd,&fds)){2 l' [7 d( i1 K) ?. t2 ^( p; Q! D
- if(fd==sockfd){ //如果套接字是服务端,那么与客户端accept建立连接
' U* D7 G8 q" ]- H7 W - connfd = accept(sockfd,(struct sockaddr*)&addr,&addr_len);# D h, b# a/ c4 s U
- write(connfd,msgsend,sizeof(msgsend)); //向其输出欢迎语4 V$ z/ W* k& y( ?
- is_connected[connfd]=1; //对客户端的fd对应下标将其设为活跃状态,方便下次调用
! v G: e/ f3 O' K3 S0 r9 y - printf("connected from %s\n",inet_ntoa(addr.sin_addr));- r+ D, C& Y# F
- }else{ //如果套接字是客户端,读取其信息并返回,如果读取不到信息,冻结其套接字' i; J. |8 t+ h& P2 T: t
- if(read(fd,msgbuffer,sizeof(msgbuffer))>0){
" Z m" D; W( u* W - write(fd,msgbuffer,sizeof(msgbuffer));
5 N+ ^8 r9 V9 u - printf("[read]: %s\n",msgbuffer);
! @9 N" J& L# a. X8 b+ [5 L - }else{
+ ^$ @+ ?: n! i1 h3 H8 g: i - is_connected[fd]=0;
4 R# }' v7 Z) q! [7 h! M - close(fd);
+ W8 E! k' r, {: K; Q* B( P - printf("close connected\n");* c0 {7 E* k% H7 {% H0 {
- }
' x$ S9 X- C# y9 K8 ~6 J5 e - }6 V7 V# B. E( w3 R8 E) ~% e
- }
/ g: U: r$ t; f/ T$ H - }9 x3 h& }$ V8 F7 `$ i; E7 P; x
- }
( I; X3 J% V9 x - }
复制代码 # w% G4 O! Z5 {
* I* H$ k7 n* h( h* Z8 c: V( _3 V3 x$ Y r
) m; H0 s: q8 W' v/ _8 C& m! {# f
l7 M. `7 w0 S7 |7 H5 M4 G7 D, ^- Y! q6 X2 z3 W3 w
, p" d% H M2 \3 p0 J0 W
|