实验环境是linux系统,效果如下: 1.启动服务端程序,监听在6666端口上 2.启动客户端,与服务端建立TCP连接 3.建立完TCP连接,在客户端上向服务端发送消息 4.断开连接 实现的功能很简单,但是对于初来乍到的我费了不少劲,因此在此总结一下,如有错点请各位大神指点指点 : L5 o, K7 J( N! d" x8 {
什么是SOCKET(插口): 这里不用 "套接字" 而是用 "插口" 是因为在《TCP/IP协议卷二》中,翻译时也是用 "插口" 来表示socket的。
4 l5 s2 C/ O( c, d7 x' ? "套接字" 这词不知道又是哪个教授级人物造出来的,听起来总是很怪,虽然可以避免语义上的歧义,但不明显。 对插口通俗的理解就是:它是一个可以用来输入或者输出的网络端,另一端也具有同样相对应的操作。 具体其他高级的定义不是这里的重点。值得说的是: 每个插口都可以标识某个程序通信的一端,通过系统调用使得程序与网络设备之间的交流连接起来。 应用程序 -> 系统调用 -> 插口层 -> 协议层 -> 接口层 ->发送(接收的话与之相反). @! F- M2 r1 ~
! X$ m- @& E! S' R8 @3 V& T2 q- |$ |2 F: B/ m# j" O
如何标识一个SOCKET: 如上定义所述,可以通过地址,协议,端口三要素来确定一个通信端,而在linux C程序中使用 标识符 来标识一个 SOCKET,Unix系统对设备的读写操作等同于对描述符的读写操作,标识符可以用于:插口 管道 目录 设备 文件等等
' ]- ~! ]9 g) F |: ` 描述符是个正整数,事实上他是检查表表项中的一个下标,用于指向打开文件表的结构。 述符前三个标识符0 1 2 分别系统保留:标准输入(键盘),标准输出(屏幕),标准错误输出 当我们使用新的描述符来创建socket时,他一般从最小未使用的数字开始分配,也就是3
\8 i4 y2 q5 Q& p7 P8 B0 Y
, ^' ~% Z0 S) e3 k$ r服务端实现的流程: 1.服务端开启一个SOCKET(socket函数) 2.使用SOCKET绑定一个端口号(bind函数) 3.在这个端口号上开启监听功能(listen函数) 4.当有对端发送连接请求,向其发送ack+syn建立连接(accept函数) 5.接收或者回复消息(read函数 write函数)
5 N) q K- ]4 J X! l* u7 o- M. U& y. h$ |' x
客户端实现流程: 1.打开一个SOCKET 2.向指定的IP 和端口号发起连接(connect函数) 3.接收或者发送消息(send函数 recv函数)
& W* U7 ]9 a0 j. E' R& h; Y6 `9 Q: Z- O) J' n! F- W
" x; N y4 b. t+ ] T, h- u, o如何并发处理: 如果按照以上流程实现其实并不难,但是有个缺陷,因为C语言是按顺序单一流程运行,也就是说如果 直接在程序当中使用accept函数(建立连接)的话,那么程序会阻塞在accept这里,这是因为如果客户端 一直没有发送connect连接,那么accept就无法得知客户端的IP和端口,也就只能一直等待(阻塞)直到 有请求触发继续执行为止,这样就导致如果同时多个客户向服务端发送请求连接,那么服务端只能按照 单一线程去处理第一个客户端,无法开启多个线程同时处理多个用户的请求。
$ j, e/ `+ N# [; A# [) v% P6 `! X7 g" i/ \7 N/ q: {
如何解决: 下面摘文截取网上的资料,有兴趣者可以看看 系统提供select函数来实现多路复用输入/输出模型,该函数用于在非阻塞中,当一个套接字或一组套接字有信号时通知你 - int select(int nfds, fd_set *readfds, fd_set *writefds, exceptfds, const struct timeval* timeout);
复制代码所在的头文件为: - #include <sys/time.h>1 g4 Z3 e3 h2 h! F7 [4 [# t
" N9 h( X3 {6 ^( _ x6 p. G- #include <unistd.h>
复制代码 功能:测试指定的fd是否可读,可写 或者 是否有异常条件待处理
6 r# Q/ V7 x! r8 |. Q. Z readset 用来检查可读性的一组文件描述字。
/ z6 H; v8 T c2 M% t' U& u2 p writeset 用来检查可写性的一组文件描述字。
( P6 s5 l$ q! M) l: D% V5 h exceptset用来检查是否有异常条件出现的文件描述字。(注:不包括错误)
7 G5 o1 [* C, E( `
timeout 用于描述一段时间长度,如果在这个时间内,需要监视的描述符没有事件发生则函数返回,返回值为0。: ~$ ~& G) p# x( d
$ M# I+ j; n$ g+ _& m% T: v
对于select函数的功能简单的说就是对文件fd做一个测试。测试结果有三种可能:8 d# b9 [- @, H- L% o
) }6 f) P- m$ W# D+ @# N- Y
- 1.timeout=NULL (阻塞:select将一直被阻塞,直到某个文件描述符上发生了事件)
I3 ~$ [& |& B# h O& m - : W. ^, p6 W. F( C
- 2.timeout所指向的结构设为非零时间 (等待固定时间:如果在指定的时间段里有事件发生或者时间耗尽,函数均返回)
+ K. @+ k* I" H7 w* i8 s" s8 y - ' x7 S$ r# k: O% V. N ^2 @) H
- 3.timeout所指向的结构,时间设为0 (非阻塞:仅检测描述符集合的状态,然后立即返回,并不等待外部事件的发生)
复制代码 返回值: 返回对应位仍然为1的fd的总数。注意啦:只有那些可读,可写以及有异常条件待处理的fd位仍然为1。 否则为0哦。举个例子,比如recv(), 在没有数据到来调用它的时候,你的线程将被阻塞,如果数据一直不来, 你的线程就要阻塞很久.这样显然不好。所以采用select来查看套节字是否可读(也就是是否有数据读了) 。 现在,UNIX系统通常会在头文件<sys/select.h>中定义常量FD_SETSIZE,它是数据类型fd_set的描述字数量, 其值通常是1024,这样就能表示<1024的fd。7 X) F# |( e* s6 p. {5 R
" F& d/ i: a* {6 v0 \( k
" q. l: y5 Y( P( }8 s! Q2 V0 j fd_set结构体: 文件描述符集合,用于存放多个fd(文件描述符,这里就是套接字) 可以存放服务端的fd,有客户端的fd。下面是对这个文件描述符集合的操作: - FD_ZERO(*fds): 将fds设为空集( y6 V3 A. j ]/ _! ~ C0 F' r6 a
- / l$ Z8 m! A$ L5 w
- FD_CLR(fd,*fds): 从集合fds中删除指定的fd) I9 I p! O9 P: s3 u# O- C
" C9 @; Y+ E- T+ H( B- FD_SET(fd,*fds): 从集合fds中添加指定的fd0 W1 X) u0 @, d' x* {! q* l: L0 _
- , N3 B4 U' r( s& b
- FD_ISSET(fd,*fds): 判断fd是否属于fds的集合
复制代码步骤如下 - socket s;
" n& d% \5 H0 m - .....5 t! n4 _* {8 `9 D, H
- fd_set set;
3 c4 I, g M" w: W - while(1){
& B, N# m5 B" d* u( A - FD_ZERO(&set); //将你的套节字集合清空
, b% B# {4 m0 D9 E" Y2 J - FD_SET(s, &set); //加入你感兴趣的套节字到集合,这里是一个读数据的套节字s
$ q& |7 D: G; h3 U - select(0,&set,NULL,NULL,NULL); //检查套节字是否可读,
; f, f8 g( t) C! S1 `" I& X) c1 W - if(FD_ISSET(s, &set) //检查s是否在这个集合里面,
$ n# ?# z5 R0 k4 ] - { //select将更新这个集合,把其中不可读的套节字去掉6 b- F2 @1 Y# p. E
- //只保留符合条件的套节字在这个集合里面
% d7 W D8 [* F( ? - recv(s,...);7 U) T- i' B4 e8 P4 M4 k
- }
+ c8 k1 b' `; l$ j: [9 S+ J+ a - //do something here& j! [+ n; D0 B1 z
- }
复制代码假设fd_set长度为1字节,fd_set中的每一位可以对应一个文件描述符,那么1字节最大可以对应8个fd - (1)执行fd_set set; FD_ZERO(&set); 则set用位为0000,0000。
! \! r- g1 w7 Y' \ - / S# n/ V& i$ V& p2 b
- (2)若fd=5,执行FD_SET(fd,&set); 后set变为 0001,0000(第5位置为1)
' ?0 P- d$ ^! V+ o
% K. A& N9 Q- U% k3 j- (3)若再加入fd=2,fd=1 则set变为 0001,0011
1 a/ K; a# W, S( f - * j$ z; F+ t$ y
- (4)执行select(6,&set,0,0,0) 阻塞等待
* ?5 j8 M7 F( a* N4 {+ N& L - % z+ s* {3 ~! C
- (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.具体过程看代码会好理解 / c3 P( t* E6 l$ j7 \9 N# K
% O, v" W& u2 y9 l5 P2 T! h! s使用select函数的过程一般是:
2 ?2 k9 n9 ~$ `/ ~; }* l 先调用宏FD_ZERO将指定的fd_set清零,然后调用宏FD_SET将需要测试的fd加入fd_set,
接着调用函数select测试fd_set中的所有fd,最后用宏FD_ISSET检查某个fd在函数select调用后,相应位是否仍然为1 复制粘贴的摘文排版起来真的是痛苦,我已经尽力排版了。。。
; U6 A; E9 N% ~3 t! G Q$ |
. t/ S. O3 O! T客户端: - #include <time.h>
3 S. b* B9 _( n% L9 K- k% c/ E - #include <stdio.h>9 A7 t9 J: h( E
- #include <stdlib.h>4 Y$ B& M# e' O6 J6 H" G+ k b
- #include <string.h>
8 m7 R* H: W$ ]2 `! G - #include <unistd.h>1 T, i9 L& ~0 h: x! {% w- U* |, f. o
- #include <arpa/inet.h>( n2 ]8 }! S' R, ~2 }
- #include <netinet/in.h>
% [5 u* \9 r1 A# { - #include <fcntl.h>. V2 X; b4 {. J. E$ E
- #include <sys/stat.h>/ Q6 P+ V# K, r! n
- #include <sys/types.h>
+ {9 J2 q" Q, j- U. Y& t5 U - #include <sys/socket.h>! H) w) z0 R4 q0 m, W+ B4 N9 H2 i
- 2 m: f( m1 m8 V8 S$ X
- #define REMOTE_PORT 6666 //服务器端口4 T4 y. |% B8 \' v( E+ _
- #define REMOTE_ADDR "127.0.0.1" //服务器地址
2 M$ g- |# v2 l' ^; V' @* F -
- v7 t* {) N# R% ?! G - int main(){
* {0 u9 P2 b7 i4 x p/ K- G G; u& ` - int sockfd;
_- m1 `5 r1 U2 R - struct sockaddr_in addr;: X, A" [7 F: \; K5 t5 M" p
- char msgbuffer[256];: E1 v1 K) J% p7 ?9 {1 Y
- 6 M& X _8 ^* q& k/ q% H: c
- //创建套接字
4 j: X( M6 j) O4 J: B. C - sockfd = socket(AF_INET,SOCK_STREAM,0);6 ^- M& U) t& W1 C+ j! }
- if(sockfd>=0)5 m0 s% z8 _" ]
- printf("open socket: %d\n",sockfd);+ ?8 f& y0 ~: s7 D }& m
-
! F6 N" q$ ]: ^) L - //将服务器的地址和端口存储于套接字结构体中
4 X1 D! D! i7 t5 n$ y1 F - bzero(&addr,sizeof(addr));5 M# Q, D( P+ G8 e3 B
- addr.sin_family=AF_INET;
" g/ M% t, @6 J$ r4 t7 ], x' b) Y8 o - addr.sin_port=htons(REMOTE_PORT);
. l- c" n3 e5 H; X4 x* n2 `! W - addr.sin_addr.s_addr = inet_addr(REMOTE_ADDR);
: r- Z5 j9 F3 t; m1 C0 p4 ~7 \# V -
% d! }, H& k- k" I - //向服务器发送请求: y" }" F j; _5 c
- if(connect(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)
: v; S5 s* A1 @. n, i8 l1 ?6 R - printf("connect successfully\n");) v/ O9 W3 H4 T; V1 U
-
6 e6 x# r6 c: [: r' Q l) Y" M - //接收服务器返回的消息(注意这里程序会被阻塞,也就是说只有服务器回复信息,才会继续往下执行)3 L+ ^) x* Y1 C7 Q# N5 G3 i7 S
- recv(sockfd,msgbuffer,sizeof(msgbuffer),0);
; J# X/ L) |1 r6 L. n( j. T* g! K - printf("%s\n",msgbuffer);) ]8 \( Y% b7 v, B; ?$ o D
-
% t3 X" }/ K1 x - while(1){
; B: U! j: [/ g5 ` - //将键盘输入的消息发送给服务器,并且从服务器中取得回复消息
6 s+ u; s0 x' t - bzero(msgbuffer,sizeof(msgbuffer)); r& I, B h4 m/ z' L1 e
- read(STDIN_FILENO,msgbuffer,sizeof(msgbuffer)); ~1 K: P4 f0 i. ]. x- |
- if(send(sockfd,msgbuffer,sizeof(msgbuffer),0)<0)
4 P7 e7 D1 S0 i+ H! J9 _$ q# v - perror("ERROR"); _/ N3 c: R/ w7 @' [2 W/ O: H
- ( e0 b' K/ l8 J# `
- bzero(msgbuffer,sizeof(msgbuffer));/ l- _3 z/ U) X9 h( W' \1 G
- recv(sockfd,msgbuffer,sizeof(msgbuffer),0);0 U4 [7 C, ^9 J: `9 N* G
- printf("[receive]:%s\n",msgbuffer);
+ \$ n& I4 `' l7 q -
v* Z7 T4 ?- y - usleep(500000);+ e7 W9 O) k; `" a' p
- }" [6 ?% q9 m3 k$ E$ L
- }
复制代码
+ k( y3 e# K$ i& f
+ j( h& q" I, ?% J; R服务端: - #include <time.h>4 c; n" e3 w' @' ?' z9 V m; U; E
- #include <stdio.h>, e8 C8 V/ `) A- J( T
- #include <stdlib.h>
% b- r/ L( Q6 x' y; `% t - #include <string.h>
7 G& R" K% Y. s) w8 H9 F; [6 m - #include <unistd.h>
# D0 Z# T' d8 ]: D - #include <arpa/inet.h>
6 S) K- y/ s8 \ - #include <netinet/in.h>( k* g' ^5 Z: O5 a! {3 k3 V
- #include <sys/types.h>3 ~' ~8 h3 @1 B! ?" [; s
- #include <sys/socket.h>4 F, b/ p9 V4 G- w8 S
- 1 Y! d$ K- v" u, u
- #define LOCAL_PORT 6666 //本地服务端口% q/ y$ C& R8 z2 n
- #define MAX 5 //最大连接数量0 k& @7 x/ \& |- ]
-
. `2 h+ S6 e7 e9 W+ \ I - int main(){1 n) ^9 e2 z- H. S
- int sockfd,connfd,fd,is_connected[MAX];$ s R& a2 B0 G# W& o) i8 |+ F6 w
- struct sockaddr_in addr;. m* A; X. N2 d3 f/ h" t
- int addr_len = sizeof(struct sockaddr_in);
" d7 L# ^& w* t) y. b! V - char msgbuffer[256];
2 T4 n7 f9 n' j4 N) N - char msgsend[] = "Welcome To Demon Server";
$ Z7 w7 D4 M" k1 F7 N - fd_set fds;
+ S! _6 y3 ?$ K/ Z8 s5 W - * p: I/ d3 S; P1 i9 d" c
- //创建套接字
9 `4 _, r4 g' l. t - sockfd = socket(AF_INET,SOCK_STREAM,0);; |2 a. k T; n
- if(sockfd>=0)4 O+ c' B( M# M. I! s. J1 T% Z
- printf("open socket: %d\n",sockfd);0 L/ V0 E4 s0 V# _5 K0 i: Y* I
-
* A6 x& |" O* e( a - //将本地端口和监听地址信息保存到套接字结构体中
9 G2 O- D# g1 G6 |& T8 k - bzero(&addr,sizeof(addr));; S* l$ S' H4 [& @2 F$ V% U7 P
- addr.sin_family=AF_INET;5 q. p* z3 I0 u8 ~7 H* D. b
- addr.sin_port=htons(LOCAL_PORT);
+ ~7 `: T* ]5 ? - addr.sin_addr.s_addr = htonl(INADDR_ANY); //INADDR_ANY表示任意地址0.0.0.0 0.0.0.0
# }- V: L4 {* C( z -
% m; n) O* j6 |6 |0 u) n - //将套接字于端口号绑定
' m2 D$ C9 I! L3 W+ m - if(bind(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)
: a( a. Y0 a3 s: m0 [/ X - printf("bind the port: %d\n",LOCAL_PORT);- n; r8 v, W1 U: v! E
-
- s D2 f+ h1 D' e+ D: B - //开启端口监听
/ U6 Q7 @0 ?1 z: T! L( A - if(listen(sockfd,3)>=0)
3 R7 e8 I- t" e - printf("begin listenning...\n");5 \7 M9 g" k* \; f
- ' k. ^& A/ f* s! _& t6 X# B
- //默认所有fd没有被打开; x4 w4 D! J3 R* z
- for(fd=0;fd<MAX;fd++). c) c' z+ L$ \+ h
- is_connected[fd]=0; X" f$ u( _9 M3 F. A
- - o! b) O3 ?3 O V$ d4 w7 F( L
- while(1){/ s5 Y, H, W+ h0 ?1 q
- //将服务端套接字加入集合中; \4 v! N" t+ X" o& j" ~. ?: ~
- FD_ZERO(&fds);+ X; {4 w& f. K: A" n9 k: O+ I
- FD_SET(sockfd,&fds);
( I+ E; A7 p( H( P+ Z0 O( o -
; d6 ?3 p* j2 U: P - //将活跃的套接字加入集合中: ]& V. \; E( @
- for(fd=0;fd<MAX;fd++)
& Y+ F' a5 _8 h( ]' ]8 v5 r - if(is_connected[fd])
9 @; t( h" x8 s5 p) R - FD_SET(fd,&fds);1 V: {- \$ \' t R( ^$ O, ?
-
3 V' Z' X! ]3 I8 P6 O2 m- _+ | - //监视集合中的可读信号,如果某个套接字有信号则继续执行,此时集合中只有存在信号的套接字会被置为1,其他置为0
6 S/ b Q3 F3 w/ F( d: L& d - if(!select(MAX,&fds,NULL,NULL,NULL))
6 g5 X4 {7 y: r# g! s' G - continue;8 \9 B/ n6 T, E, `; }( m) P
- & ^) U" I0 q: X& L; L9 o6 {5 O) o
- //遍历所有套接字判断是否在属于集合中的活跃套接字9 i+ L ?6 h6 d! T9 [' K
- for(fd=0;fd<MAX;fd++){4 A. |( }7 z8 J9 a x ~' `2 N
- if(FD_ISSET(fd,&fds)){
! a9 z5 |) }* X- L1 e - if(fd==sockfd){ //如果套接字是服务端,那么与客户端accept建立连接" E1 R( n# _8 w% }3 W, T- X
- connfd = accept(sockfd,(struct sockaddr*)&addr,&addr_len);& G& a& c- N5 U! W* f1 l
- write(connfd,msgsend,sizeof(msgsend)); //向其输出欢迎语 j+ r! V2 I- i+ a% ~: M( Z, _' \, D
- is_connected[connfd]=1; //对客户端的fd对应下标将其设为活跃状态,方便下次调用
/ w' ]" ?9 H# @ - printf("connected from %s\n",inet_ntoa(addr.sin_addr));0 E/ f9 Z6 h% F0 h4 X$ n
- }else{ //如果套接字是客户端,读取其信息并返回,如果读取不到信息,冻结其套接字
" V: g1 M, u. k+ E0 s+ ` - if(read(fd,msgbuffer,sizeof(msgbuffer))>0){
/ z( v) E+ E Y0 |5 ]6 h) I - write(fd,msgbuffer,sizeof(msgbuffer));
. g* D5 z3 L" u1 j. u, _0 t( A - printf("[read]: %s\n",msgbuffer);
0 ^; |8 L& ?8 @ - }else{/ N3 z- L! T! F. c( x
- is_connected[fd]=0;! q. s0 q( m% K3 Z1 o8 n
- close(fd);
1 W* L7 y: g" G - printf("close connected\n");
' T7 k# i" Z1 Y - }
- s/ m5 N+ `: I# A - }, ]& l8 p% y- x1 K& w/ C
- }' [6 o: ^/ j# |: k$ [: C' ^# I
- }
: y' V/ K/ N/ q4 i6 b' }5 z3 R - }
) |1 e* B/ j" F3 b - }
复制代码
/ _7 x6 p3 i$ B
" R$ b* `6 [5 F [9 G' J
% O l$ ^) N+ h, n3 O% w+ i9 C
2 R/ b2 _$ _' }: X) c6 _% s: ^7 B, u9 q
" y6 X0 P) ^% h% M |