实验环境是linux系统,效果如下: 1.启动服务端程序,监听在6666端口上 2.启动客户端,与服务端建立TCP连接 3.建立完TCP连接,在客户端上向服务端发送消息 4.断开连接 实现的功能很简单,但是对于初来乍到的我费了不少劲,因此在此总结一下,如有错点请各位大神指点指点
: C: k% H) C, a# K- Y+ T+ Z8 T什么是SOCKET(插口): 这里不用 "套接字" 而是用 "插口" 是因为在《TCP/IP协议卷二》中,翻译时也是用 "插口" 来表示socket的。
! J8 Q# `- ^- {3 U0 g "套接字" 这词不知道又是哪个教授级人物造出来的,听起来总是很怪,虽然可以避免语义上的歧义,但不明显。 对插口通俗的理解就是:它是一个可以用来输入或者输出的网络端,另一端也具有同样相对应的操作。 具体其他高级的定义不是这里的重点。值得说的是: 每个插口都可以标识某个程序通信的一端,通过系统调用使得程序与网络设备之间的交流连接起来。 应用程序 -> 系统调用 -> 插口层 -> 协议层 -> 接口层 ->发送(接收的话与之相反)
& H; N* T. u: ?/ O/ v9 w/ d8 b ! c8 f0 K- q+ x
2 X3 m y& C3 z5 C1 c. T) l) ~如何标识一个SOCKET: 如上定义所述,可以通过地址,协议,端口三要素来确定一个通信端,而在linux C程序中使用 标识符 来标识一个 SOCKET,Unix系统对设备的读写操作等同于对描述符的读写操作,标识符可以用于:插口 管道 目录 设备 文件等等3 e1 n( F7 E' ^ @! d# O
描述符是个正整数,事实上他是检查表表项中的一个下标,用于指向打开文件表的结构。 述符前三个标识符0 1 2 分别系统保留:标准输入(键盘),标准输出(屏幕),标准错误输出 当我们使用新的描述符来创建socket时,他一般从最小未使用的数字开始分配,也就是3 ' X6 V1 A4 Q" K
7 T7 g, q8 k: d( D1 m5 u: Z
服务端实现的流程: 1.服务端开启一个SOCKET(socket函数) 2.使用SOCKET绑定一个端口号(bind函数) 3.在这个端口号上开启监听功能(listen函数) 4.当有对端发送连接请求,向其发送ack+syn建立连接(accept函数) 5.接收或者回复消息(read函数 write函数)
1 @2 {% C) A0 c2 m! x
8 y* H/ C6 b0 O* w客户端实现流程: 1.打开一个SOCKET 2.向指定的IP 和端口号发起连接(connect函数) 3.接收或者发送消息(send函数 recv函数) / w' v+ M% X# N3 M
% S' o: ~; w- A1 T \
2 D9 q$ V# p# [0 t: ?3 ]) F如何并发处理: 如果按照以上流程实现其实并不难,但是有个缺陷,因为C语言是按顺序单一流程运行,也就是说如果 直接在程序当中使用accept函数(建立连接)的话,那么程序会阻塞在accept这里,这是因为如果客户端 一直没有发送connect连接,那么accept就无法得知客户端的IP和端口,也就只能一直等待(阻塞)直到 有请求触发继续执行为止,这样就导致如果同时多个客户向服务端发送请求连接,那么服务端只能按照 单一线程去处理第一个客户端,无法开启多个线程同时处理多个用户的请求。 + H6 y8 ?6 W. `3 W5 d
# d; q& o6 J" t4 T) ?) ^6 F. k如何解决: 下面摘文截取网上的资料,有兴趣者可以看看 系统提供select函数来实现多路复用输入/输出模型,该函数用于在非阻塞中,当一个套接字或一组套接字有信号时通知你 - int select(int nfds, fd_set *readfds, fd_set *writefds, exceptfds, const struct timeval* timeout);
复制代码所在的头文件为: - #include <sys/time.h>& p1 b6 L; z, A" @* l
- $ @% @2 L" F# k; i' D+ j
- #include <unistd.h>
复制代码 功能:测试指定的fd是否可读,可写 或者 是否有异常条件待处理 1 _% K* W C: a& W. b7 i
readset 用来检查可读性的一组文件描述字。
4 P) e' n9 l" \ writeset 用来检查可写性的一组文件描述字。
" P4 B/ J) c8 L* @# U
exceptset用来检查是否有异常条件出现的文件描述字。(注:不包括错误) ' p/ l% w3 T: \, {% S1 Y
timeout 用于描述一段时间长度,如果在这个时间内,需要监视的描述符没有事件发生则函数返回,返回值为0。3 M6 x0 B6 R4 G5 c. b x
( ^1 {4 P% S+ S3 Z
对于select函数的功能简单的说就是对文件fd做一个测试。测试结果有三种可能:' q/ X' S( f9 J5 s# S: o) W
( q* [( R( g9 N3 G. M6 o# `$ L2 N
- 1.timeout=NULL (阻塞:select将一直被阻塞,直到某个文件描述符上发生了事件)
8 f$ U# I1 c, D
# v4 n$ C8 Z. x* `' p( ~7 J- 2.timeout所指向的结构设为非零时间 (等待固定时间:如果在指定的时间段里有事件发生或者时间耗尽,函数均返回)
* Z, W' }2 W% w2 I- P p
% ^/ F6 D5 F% m8 @- 3.timeout所指向的结构,时间设为0 (非阻塞:仅检测描述符集合的状态,然后立即返回,并不等待外部事件的发生)
复制代码 返回值: 返回对应位仍然为1的fd的总数。注意啦:只有那些可读,可写以及有异常条件待处理的fd位仍然为1。 否则为0哦。举个例子,比如recv(), 在没有数据到来调用它的时候,你的线程将被阻塞,如果数据一直不来, 你的线程就要阻塞很久.这样显然不好。所以采用select来查看套节字是否可读(也就是是否有数据读了) 。 现在,UNIX系统通常会在头文件<sys/select.h>中定义常量FD_SETSIZE,它是数据类型fd_set的描述字数量, 其值通常是1024,这样就能表示<1024的fd。- P& _' A( `* L* B" B6 a/ u
* E6 u! i5 Q! Y3 o3 P& Y3 i" v
! {0 F! `3 |. L/ v
fd_set结构体: 文件描述符集合,用于存放多个fd(文件描述符,这里就是套接字) 可以存放服务端的fd,有客户端的fd。下面是对这个文件描述符集合的操作: - FD_ZERO(*fds): 将fds设为空集
! F% C1 n6 B# k7 A& h* h - 3 X+ l- M0 c( @! j, k" C( E# L0 {
- FD_CLR(fd,*fds): 从集合fds中删除指定的fd8 o; R0 X+ t& B7 E* n4 s/ S5 P3 u
- 5 B% r, Y# Y6 S
- FD_SET(fd,*fds): 从集合fds中添加指定的fd0 g5 l2 w& E' b& x& h3 I
- ; |6 K. I1 C4 e% z" `) e6 o
- FD_ISSET(fd,*fds): 判断fd是否属于fds的集合
复制代码步骤如下 - socket s; a& O7 [/ c Y
- ....., m2 R6 F: j9 \- c- R. K
- fd_set set;
6 F& N0 E7 F9 [5 x! a0 _ - while(1){1 X0 G* F& ]2 R, m* R. ^
- FD_ZERO(&set); //将你的套节字集合清空8 ^7 j5 s; k& I2 w7 O) t9 X
- FD_SET(s, &set); //加入你感兴趣的套节字到集合,这里是一个读数据的套节字s! O# G1 G4 C* K: M$ s- E% V% @) a
- select(0,&set,NULL,NULL,NULL); //检查套节字是否可读,' N/ @- h) q+ U- k
- if(FD_ISSET(s, &set) //检查s是否在这个集合里面,$ o! b/ X) Q4 a) R4 D
- { //select将更新这个集合,把其中不可读的套节字去掉5 n2 U, i) s, n1 N/ [& c* e
- //只保留符合条件的套节字在这个集合里面
4 C. Y0 K! t) c2 b. m: K. ] - recv(s,...);* n! [# U4 Q6 a9 I6 o3 f6 ~6 `7 w0 g
- }
, F- m; Z/ b7 n" y+ j# `: [6 [; h - //do something here
/ h. P" l) M) a r - }
复制代码假设fd_set长度为1字节,fd_set中的每一位可以对应一个文件描述符,那么1字节最大可以对应8个fd - (1)执行fd_set set; FD_ZERO(&set); 则set用位为0000,0000。
7 F |: ]- ~, `! @ - % R6 _3 M0 b5 e G: Z, k
- (2)若fd=5,执行FD_SET(fd,&set); 后set变为 0001,0000(第5位置为1)' M$ _' I. T& a( @, `7 i5 w' O
* ~0 t% Q8 s3 \ b- (3)若再加入fd=2,fd=1 则set变为 0001,0011% j: z9 O* {4 ^. @3 K. W3 b7 A( A
- 9 _5 ` u0 c' p+ N \3 l
- (4)执行select(6,&set,0,0,0) 阻塞等待) ]8 j( X+ [& P. k" T5 D
/ K! f; A: ]6 u( {7 Q+ L- (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.具体过程看代码会好理解 4 S+ @; H! l8 @3 Q3 j
- l5 }! ^) f) Y T+ W( f
使用select函数的过程一般是:
7 Z& k9 A1 Y! y' A" ~8 N+ ^: ~ 先调用宏FD_ZERO将指定的fd_set清零,然后调用宏FD_SET将需要测试的fd加入fd_set,
接着调用函数select测试fd_set中的所有fd,最后用宏FD_ISSET检查某个fd在函数select调用后,相应位是否仍然为1 复制粘贴的摘文排版起来真的是痛苦,我已经尽力排版了。。。
) j, F% W) f7 N$ t3 r : u# w+ d% z3 g
客户端: - #include <time.h>7 z& H9 Z) q* _7 a- _' v
- #include <stdio.h>
. d, H* w; M/ j' u3 L) f8 K7 H5 {4 M - #include <stdlib.h>
' ]" d" B5 ]: R% y1 F - #include <string.h>
+ x' r- ^5 Y8 m - #include <unistd.h>
) ?% E$ Z6 c& t( a - #include <arpa/inet.h>
- @( x6 k, u; g0 V3 e - #include <netinet/in.h>, z2 O C! _! ` b
- #include <fcntl.h>
- \& c# g/ \, K/ z# P; J& b( K+ J5 W' H - #include <sys/stat.h>
) }) J$ V) P7 b* G - #include <sys/types.h>/ m8 I$ {' k# ~$ ]5 [/ M5 ~
- #include <sys/socket.h>4 W' b2 V& q8 m/ l$ c) }- y
- ) m4 y6 k8 n# l0 m2 C
- #define REMOTE_PORT 6666 //服务器端口; w( J4 g8 o- g( q. S
- #define REMOTE_ADDR "127.0.0.1" //服务器地址
4 h* |, l1 x1 I& Z7 d/ B+ J -
: ], _$ {* Z* H! z! i - int main(){- a7 C, X1 B3 n9 a0 b- K
- int sockfd;- ~$ Y; o9 O" z2 M
- struct sockaddr_in addr;) T8 ?" @9 i' Q4 v9 X
- char msgbuffer[256];
5 l z- D- H2 @) C" u6 W. S -
9 h h) s0 g6 i" s - //创建套接字
; R" g' d% X6 M% `& k - sockfd = socket(AF_INET,SOCK_STREAM,0);) S4 n, N: w* S' u2 p
- if(sockfd>=0)2 d6 v0 h& ~. A( x# S: E- i
- printf("open socket: %d\n",sockfd);
f g! k( O! _ M$ r: I -
" l# P' L& {$ E _! m2 D5 \7 ? - //将服务器的地址和端口存储于套接字结构体中
, C7 f( R) z/ d. j2 ? - bzero(&addr,sizeof(addr));- s5 `* ?, }" x1 z' _* K6 Y
- addr.sin_family=AF_INET;" E$ d) I q/ c4 l
- addr.sin_port=htons(REMOTE_PORT);. D0 Z. ^' @6 m6 w0 p/ Y! S6 j2 V
- addr.sin_addr.s_addr = inet_addr(REMOTE_ADDR);
5 `" y0 R! t8 ?7 Q& { - 3 @; U, z( i5 x. A1 y* b
- //向服务器发送请求" j2 `5 S! t: |6 o1 ?, R$ ]+ l! a# N0 @
- if(connect(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)
Y% c+ k3 w' O - printf("connect successfully\n");* p: f4 S' F% m+ r8 R8 Y
- # l C: F9 Z o) y
- //接收服务器返回的消息(注意这里程序会被阻塞,也就是说只有服务器回复信息,才会继续往下执行); a" y5 k, ?! j% q4 T
- recv(sockfd,msgbuffer,sizeof(msgbuffer),0);
$ }! v7 s0 |7 t0 N, s - printf("%s\n",msgbuffer);% x6 h, r. Y0 T2 M* F
-
" w4 X) v7 \7 N! N* d - while(1){$ S6 [# k- r( S A! ^
- //将键盘输入的消息发送给服务器,并且从服务器中取得回复消息" s' e: f5 j$ Q' M6 b
- bzero(msgbuffer,sizeof(msgbuffer));
% @% e% F* X+ F2 m- P. ^0 [ - read(STDIN_FILENO,msgbuffer,sizeof(msgbuffer));
* V, g+ v2 B# b0 l( L0 {) ?7 D - if(send(sockfd,msgbuffer,sizeof(msgbuffer),0)<0)
6 ]6 Z, S! ]$ i9 r3 w& N - perror("ERROR");
1 L, D6 ]$ {1 s4 ~ -
; Y- s4 K" f" g# W7 O& H% m& ]0 |& U - bzero(msgbuffer,sizeof(msgbuffer));0 V( b* F) G0 r* x; \
- recv(sockfd,msgbuffer,sizeof(msgbuffer),0);
. i7 [+ s* F1 d8 [9 F - printf("[receive]:%s\n",msgbuffer);1 G2 m9 x' N% I) R, F4 `9 r; @- S- _
- . _8 D+ C' K1 |3 R, D( U
- usleep(500000);
3 u1 K4 h" L8 k0 V/ `4 X1 r - }
" ?* o$ \) c5 D! T% x- c* I - }
复制代码 & X9 p% v5 B& `7 {4 x* O$ Z
0 T/ j; A4 t6 w* x Y* n+ a
服务端: - #include <time.h>
0 D4 U# P2 h2 \, n - #include <stdio.h>
1 d, I' @% Z; j5 z - #include <stdlib.h>
6 z9 B8 i- g @8 ]6 X4 I - #include <string.h>
/ p' i7 u) |. a - #include <unistd.h> ?" ^; s9 q$ G' K! y3 J4 _
- #include <arpa/inet.h>' k) l- g4 ^0 ^' c( V) }
- #include <netinet/in.h>
7 Y5 y% f3 b# t& x+ m - #include <sys/types.h>6 |* y; n- K& V; ?8 ~8 b& ~! _7 Z9 e. }( o
- #include <sys/socket.h>
5 c+ p6 i6 _2 ~: V# o7 k - / d3 T0 H3 p! c" B) N3 H1 `
- #define LOCAL_PORT 6666 //本地服务端口+ E1 X! l$ f0 x
- #define MAX 5 //最大连接数量
- W- F4 |* A( C. K - " ?* _0 C* u8 O/ N- D5 {
- int main(){$ B9 N% I A* n" U, @) v# c6 t
- int sockfd,connfd,fd,is_connected[MAX];9 e3 o! N b' S2 t! ~- {
- struct sockaddr_in addr;
5 H' S, u5 a; O& I& x - int addr_len = sizeof(struct sockaddr_in);
- N9 G3 V2 K, C' U2 T - char msgbuffer[256];5 f6 c# s, ]* U. [8 y
- char msgsend[] = "Welcome To Demon Server";2 i1 w7 B7 E' j$ D( X, g6 z
- fd_set fds;
, R* J+ w* S& [ -
_& B" [7 s) T a* ^$ i - //创建套接字: Q/ ?1 p6 |) H: o
- sockfd = socket(AF_INET,SOCK_STREAM,0);
5 U- g4 Y( |3 y$ J( h - if(sockfd>=0)
; Y. X4 |9 r$ e. m1 ?8 ` - printf("open socket: %d\n",sockfd);
# Z1 [0 [- e/ C( X -
% H. p& q1 b' V: Q% J h+ d - //将本地端口和监听地址信息保存到套接字结构体中5 k8 _; A* E0 a% B$ q
- bzero(&addr,sizeof(addr));6 i& ?2 G+ x5 C \4 k6 G/ r
- addr.sin_family=AF_INET;) J- {" k) U' z# R
- addr.sin_port=htons(LOCAL_PORT);
9 ^6 ^5 e6 _% z9 X - addr.sin_addr.s_addr = htonl(INADDR_ANY); //INADDR_ANY表示任意地址0.0.0.0 0.0.0.0
3 i% z" W: f) R" \% I. w9 U( C -
( V* G" T( w) R5 M6 |' S$ ^+ j - //将套接字于端口号绑定
5 s; R5 M+ t4 s( t5 j: D* V - if(bind(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)
( Z4 i) P; `' M ` - printf("bind the port: %d\n",LOCAL_PORT);) w( x6 s1 F) @9 v1 o
-
& I& I3 X1 w, M Y; |8 R# i - //开启端口监听: J+ P4 s- L7 `9 x7 s; ~4 F- D- h6 r; X
- if(listen(sockfd,3)>=0)
& L" F' p6 ^% _1 E& U: B3 K9 X - printf("begin listenning...\n");8 p- ?6 y8 J; }( }
-
( Z) l$ }% ^+ C! z2 } - //默认所有fd没有被打开$ b8 X% R5 l# s8 |
- for(fd=0;fd<MAX;fd++)
% f% q6 T) R: C# b - is_connected[fd]=0;
5 x1 r0 Q' k: U/ N+ | -
0 A, N& ]" p. i5 x) {! }2 S$ U" ` - while(1){0 p- N& T% U$ }& @) m4 [/ z
- //将服务端套接字加入集合中
. o7 \' K* T" j5 j: B& D( i - FD_ZERO(&fds);
8 ~9 u. ~% b9 \8 `9 c8 X7 V( @! ^ - FD_SET(sockfd,&fds); z; L& |' [% K' _8 M
- ! ]/ o) G6 E# o' m' z
- //将活跃的套接字加入集合中
, v1 @9 P0 Z8 f; v6 @ - for(fd=0;fd<MAX;fd++): m5 j6 K4 t1 h% h2 |+ W
- if(is_connected[fd])
+ Y) F8 e$ U8 |6 I" W - FD_SET(fd,&fds);
$ i0 q( o& e+ C `. @" m. u -
" D; t$ ?6 V* L2 u7 o - //监视集合中的可读信号,如果某个套接字有信号则继续执行,此时集合中只有存在信号的套接字会被置为1,其他置为02 ?! _) p: h, D3 b
- if(!select(MAX,&fds,NULL,NULL,NULL))
: l7 ]' h: f- V% U. d4 p- q - continue;
% o$ d: l2 T; Y( [; Q" y - , W8 h9 j6 Q# \' r C- r
- //遍历所有套接字判断是否在属于集合中的活跃套接字
# `' q4 |: u, Y. w" W - for(fd=0;fd<MAX;fd++){
' x; D, N% r. v5 L: W - if(FD_ISSET(fd,&fds)){* `/ }% a9 q8 L0 `3 H" A
- if(fd==sockfd){ //如果套接字是服务端,那么与客户端accept建立连接! m5 e- V- {7 D
- connfd = accept(sockfd,(struct sockaddr*)&addr,&addr_len);+ O' v) Y! g' T+ ^# D. }
- write(connfd,msgsend,sizeof(msgsend)); //向其输出欢迎语% K( U/ Z/ x/ p$ W* C
- is_connected[connfd]=1; //对客户端的fd对应下标将其设为活跃状态,方便下次调用
y; L5 Y* N8 @ - printf("connected from %s\n",inet_ntoa(addr.sin_addr));
9 z8 ?; d+ |, y( I - }else{ //如果套接字是客户端,读取其信息并返回,如果读取不到信息,冻结其套接字
7 o4 P! l6 }+ J, j& c4 O - if(read(fd,msgbuffer,sizeof(msgbuffer))>0){
$ \0 J) f# W$ k8 A* f/ q6 K - write(fd,msgbuffer,sizeof(msgbuffer));: G( k) A4 f; u6 B* g) M
- printf("[read]: %s\n",msgbuffer);: V8 H6 M3 q: t* }7 h" i) {7 \
- }else{
" {7 X4 a% O3 G: Q5 W7 y: w/ l - is_connected[fd]=0;* X7 J% u+ e( V; ?5 h
- close(fd);
/ G5 v, ^" T7 }/ _ - printf("close connected\n");) g7 o3 D* V* n
- }8 w( J8 }: I: I" s. q
- }; `+ ~. E. F- Z/ \
- }( f& k" ]* y* w3 g
- }
9 g) m$ d( Z8 S+ I" @ - }
5 \8 }5 M2 m, q! P7 e - }
复制代码 9 ]9 H; A/ y( G2 m8 \& z
4 [1 a! h7 ?* m' A2 d1 a
' `8 F8 H) T8 v5 |
- n0 o0 n: u% O& z' T0 R
- U, @! T% b" ?+ M! I
' ^0 B2 n7 `& m$ s# h& d. @; l |