实验环境是linux系统,效果如下: 1.启动服务端程序,监听在6666端口上 2.启动客户端,与服务端建立TCP连接 3.建立完TCP连接,在客户端上向服务端发送消息 4.断开连接 实现的功能很简单,但是对于初来乍到的我费了不少劲,因此在此总结一下,如有错点请各位大神指点指点
# v U% @* Z x. h5 G2 ]. h什么是SOCKET(插口): 这里不用 "套接字" 而是用 "插口" 是因为在《TCP/IP协议卷二》中,翻译时也是用 "插口" 来表示socket的。- a! v; R m6 ~
"套接字" 这词不知道又是哪个教授级人物造出来的,听起来总是很怪,虽然可以避免语义上的歧义,但不明显。 对插口通俗的理解就是:它是一个可以用来输入或者输出的网络端,另一端也具有同样相对应的操作。 具体其他高级的定义不是这里的重点。值得说的是: 每个插口都可以标识某个程序通信的一端,通过系统调用使得程序与网络设备之间的交流连接起来。 应用程序 -> 系统调用 -> 插口层 -> 协议层 -> 接口层 ->发送(接收的话与之相反)
6 q( ?/ i# a; x
5 d- i9 D' k; L M0 l
4 N% Q* f2 d, T/ L3 h如何标识一个SOCKET: 如上定义所述,可以通过地址,协议,端口三要素来确定一个通信端,而在linux C程序中使用 标识符 来标识一个 SOCKET,Unix系统对设备的读写操作等同于对描述符的读写操作,标识符可以用于:插口 管道 目录 设备 文件等等
+ D+ Z7 v, n& Q: B+ N1 F 描述符是个正整数,事实上他是检查表表项中的一个下标,用于指向打开文件表的结构。 述符前三个标识符0 1 2 分别系统保留:标准输入(键盘),标准输出(屏幕),标准错误输出 当我们使用新的描述符来创建socket时,他一般从最小未使用的数字开始分配,也就是3 4 J. z3 J3 F4 K
# Q' w9 \5 l4 A, o/ q0 S服务端实现的流程: 1.服务端开启一个SOCKET(socket函数) 2.使用SOCKET绑定一个端口号(bind函数) 3.在这个端口号上开启监听功能(listen函数) 4.当有对端发送连接请求,向其发送ack+syn建立连接(accept函数) 5.接收或者回复消息(read函数 write函数) # ]1 F8 w t( n! x
/ x1 o5 C& u/ p* ~
客户端实现流程: 1.打开一个SOCKET 2.向指定的IP 和端口号发起连接(connect函数) 3.接收或者发送消息(send函数 recv函数) - Y& M4 W4 l6 V6 P$ W+ v" [! D
- E3 F7 U; H7 s8 K! m' K/ w6 A% X5 c. I' d5 G% ~' d, z0 p
如何并发处理: 如果按照以上流程实现其实并不难,但是有个缺陷,因为C语言是按顺序单一流程运行,也就是说如果 直接在程序当中使用accept函数(建立连接)的话,那么程序会阻塞在accept这里,这是因为如果客户端 一直没有发送connect连接,那么accept就无法得知客户端的IP和端口,也就只能一直等待(阻塞)直到 有请求触发继续执行为止,这样就导致如果同时多个客户向服务端发送请求连接,那么服务端只能按照 单一线程去处理第一个客户端,无法开启多个线程同时处理多个用户的请求。 / |3 f+ R6 C4 g! O$ Y- |
' w B* A) k8 T: M, @5 ~( t如何解决: 下面摘文截取网上的资料,有兴趣者可以看看 系统提供select函数来实现多路复用输入/输出模型,该函数用于在非阻塞中,当一个套接字或一组套接字有信号时通知你 - int select(int nfds, fd_set *readfds, fd_set *writefds, exceptfds, const struct timeval* timeout);
复制代码所在的头文件为: - #include <sys/time.h>, y: U) _1 ^% P& t
- 1 S+ V& c3 }: v# D1 |0 L8 h
- #include <unistd.h>
复制代码 功能:测试指定的fd是否可读,可写 或者 是否有异常条件待处理 0 T; l& X: E6 {0 g
readset 用来检查可读性的一组文件描述字。
& N% ]. h0 ~3 @' k1 z writeset 用来检查可写性的一组文件描述字。
- b, n0 }) U! H5 K+ l
exceptset用来检查是否有异常条件出现的文件描述字。(注:不包括错误)
4 p$ h' o) h$ s; M( q1 T* w timeout 用于描述一段时间长度,如果在这个时间内,需要监视的描述符没有事件发生则函数返回,返回值为0。! ?/ I K* `- [4 I# M5 ? H: o/ ?
: M- ^' x; T* r8 ]% H
对于select函数的功能简单的说就是对文件fd做一个测试。测试结果有三种可能:
' }* {' o9 B6 V+ G ! B9 \( Q, P. ?% E& ~
- 1.timeout=NULL (阻塞:select将一直被阻塞,直到某个文件描述符上发生了事件)" @1 F! p# G) V8 x
- 8 H- P) z' C6 W- ~7 d# }5 F. ?/ b/ ?% b
- 2.timeout所指向的结构设为非零时间 (等待固定时间:如果在指定的时间段里有事件发生或者时间耗尽,函数均返回)( b2 l5 K8 w" Q( R0 C# R( H
6 u( `. r3 N/ L1 w; W, f- 3.timeout所指向的结构,时间设为0 (非阻塞:仅检测描述符集合的状态,然后立即返回,并不等待外部事件的发生)
复制代码 返回值: 返回对应位仍然为1的fd的总数。注意啦:只有那些可读,可写以及有异常条件待处理的fd位仍然为1。 否则为0哦。举个例子,比如recv(), 在没有数据到来调用它的时候,你的线程将被阻塞,如果数据一直不来, 你的线程就要阻塞很久.这样显然不好。所以采用select来查看套节字是否可读(也就是是否有数据读了) 。 现在,UNIX系统通常会在头文件<sys/select.h>中定义常量FD_SETSIZE,它是数据类型fd_set的描述字数量, 其值通常是1024,这样就能表示<1024的fd。
5 U8 F1 d/ V0 F! d# C. N: x3 n& e1 {$ v# F
2 ]2 L- N% L$ \: T% Y/ X fd_set结构体: 文件描述符集合,用于存放多个fd(文件描述符,这里就是套接字) 可以存放服务端的fd,有客户端的fd。下面是对这个文件描述符集合的操作: - FD_ZERO(*fds): 将fds设为空集
V' _# ~; R; O* ?8 ?7 f5 K - ! h( o# ?+ O: F" `% \
- FD_CLR(fd,*fds): 从集合fds中删除指定的fd
# v, G x$ U N7 P _: x0 l" s - 8 Q$ ? x/ e/ g" @6 t. I! u
- FD_SET(fd,*fds): 从集合fds中添加指定的fd
) S9 l; C2 _5 n( H/ c3 y, F - * \; ]9 U. `& Y% p& w7 t' b) H
- FD_ISSET(fd,*fds): 判断fd是否属于fds的集合
复制代码步骤如下 - socket s;3 u7 U& t. V- w4 T l+ z x
- .....: F# A* |# L- y/ _* ~+ T
- fd_set set;
: _. t0 V5 N1 A0 T* q) z& e2 D - while(1){1 v+ \, s" B* H: t2 Q( `
- FD_ZERO(&set); //将你的套节字集合清空
% N H* G' w( }4 ^1 N - FD_SET(s, &set); //加入你感兴趣的套节字到集合,这里是一个读数据的套节字s& r1 N! t2 O% N) }* c
- select(0,&set,NULL,NULL,NULL); //检查套节字是否可读,
! j/ Q: ^ b/ O- p* b - if(FD_ISSET(s, &set) //检查s是否在这个集合里面,
. D1 B4 w7 \5 E# ?5 z6 n! U - { //select将更新这个集合,把其中不可读的套节字去掉
, w, \% Y7 }3 M# G. V( i- l - //只保留符合条件的套节字在这个集合里面
4 ~! X5 r& L9 ]7 ~! p& X# \- J" w; N - recv(s,...);! g& x$ W/ Z! S- f [4 m% Q
- }: Y2 H. n) ?# t
- //do something here7 B* ~8 s4 f! b) T* R, ?1 b) M
- }
复制代码假设fd_set长度为1字节,fd_set中的每一位可以对应一个文件描述符,那么1字节最大可以对应8个fd - (1)执行fd_set set; FD_ZERO(&set); 则set用位为0000,0000。
; d1 o/ Q/ w& R, \8 D4 }
* F. d5 w- x# F% S- (2)若fd=5,执行FD_SET(fd,&set); 后set变为 0001,0000(第5位置为1)8 @% Y+ ] `1 w; ?9 p: B
- 4 [* ?% ]" X- ?$ q% K2 ~% A9 K
- (3)若再加入fd=2,fd=1 则set变为 0001,0011
" x% S# K2 ]1 c! h2 ?, g - ' c9 T* {& S) A# B7 v$ \( \
- (4)执行select(6,&set,0,0,0) 阻塞等待6 P& f9 G3 e, G' b# h$ n/ a) W$ D: D1 \
- ! l g3 d8 k9 I* m4 [5 U
- (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 H/ l$ P: a# L+ c, T- N' ]9 X
% g" Q9 y3 {2 q7 K2 ~( l2 C使用select函数的过程一般是: " [- `6 A& X4 z; T6 e2 w2 Q
先调用宏FD_ZERO将指定的fd_set清零,然后调用宏FD_SET将需要测试的fd加入fd_set, 接着调用函数select测试fd_set中的所有fd,最后用宏FD_ISSET检查某个fd在函数select调用后,相应位是否仍然为1 复制粘贴的摘文排版起来真的是痛苦,我已经尽力排版了。。。
0 v. V9 |) ~* f _( g 2 {5 Z- d" u* H
客户端: - #include <time.h>
. a7 z1 A0 ~7 F8 A - #include <stdio.h>
, F) K( v0 B/ O1 j2 Z - #include <stdlib.h>
1 Q# A+ q5 h/ f5 c, c5 j - #include <string.h>
/ [' T0 y4 Y5 B' f' z4 `" R; w9 A - #include <unistd.h># \7 @$ \' K* c4 M: ~
- #include <arpa/inet.h>
6 S$ v9 @, c6 z# J' N# W2 R: E* f ` - #include <netinet/in.h>+ o8 ?* U9 E! R8 v
- #include <fcntl.h>/ o. K. X4 U. w& V; [
- #include <sys/stat.h>
) |) g h7 l' |& I. W* p t* X - #include <sys/types.h>
% W$ A8 d* Y( o; ?/ W+ v - #include <sys/socket.h>9 C) _) {4 M8 e0 S+ T; Y1 V
- 8 e1 D* y) C$ M
- #define REMOTE_PORT 6666 //服务器端口6 R6 @5 Q' y% W: a9 }2 {0 T! M
- #define REMOTE_ADDR "127.0.0.1" //服务器地址
' S, K2 Q) G3 ~ -
! X1 Q8 g' o6 |- N - int main(){4 r* a6 ~3 W3 n/ Y: {* [
- int sockfd;5 U( \8 B* q! q7 A/ R
- struct sockaddr_in addr;7 {0 ?9 g! c* m/ k9 j
- char msgbuffer[256];5 ~3 x8 n- m( o
-
" L6 _: w0 P# c0 s0 B& g - //创建套接字, D8 w% Y2 |3 c5 r E( U1 i* y' J( {
- sockfd = socket(AF_INET,SOCK_STREAM,0);
+ K2 r- }! W" x8 D, v - if(sockfd>=0)
( H4 O- V0 r1 ]6 V - printf("open socket: %d\n",sockfd);7 z7 _1 K- f- ]; _8 t& f% p) _
- % ]$ x% c- k1 _$ a
- //将服务器的地址和端口存储于套接字结构体中
; i! b$ S* y7 ]* A* [ - bzero(&addr,sizeof(addr));
9 ^7 W4 q! q$ c. F. z/ R) o2 W8 w - addr.sin_family=AF_INET;& K" L$ `4 N! F5 v [9 l/ ~& C+ R
- addr.sin_port=htons(REMOTE_PORT);
: N3 p& i- [ u& v X- i6 ]0 i - addr.sin_addr.s_addr = inet_addr(REMOTE_ADDR);- U2 D) w% x9 U( D- K! A
-
! R' H1 l% G& V. W% B r7 Z - //向服务器发送请求
4 b# b; z# s! `4 W/ p4 G - if(connect(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)' k& p+ m) D7 r9 @* e
- printf("connect successfully\n");
. L, r0 {7 D7 N5 a8 e" g4 ]! v -
) f. r" b3 \9 o5 ]& p" \ - //接收服务器返回的消息(注意这里程序会被阻塞,也就是说只有服务器回复信息,才会继续往下执行)7 N5 l( r4 P4 _ d% A( T5 I
- recv(sockfd,msgbuffer,sizeof(msgbuffer),0);
+ F: Z4 g/ T t9 q - printf("%s\n",msgbuffer);
. L: S9 \) b% v! d/ z! V( R -
0 L) ^0 A' c# l1 p0 J/ Q: u, c - while(1){
! _0 P0 A3 q. a; ~1 F - //将键盘输入的消息发送给服务器,并且从服务器中取得回复消息
( U7 Y' Z* T) r - bzero(msgbuffer,sizeof(msgbuffer));" G$ V, g9 c7 J+ i! \7 c2 X
- read(STDIN_FILENO,msgbuffer,sizeof(msgbuffer));7 K; h* X" G( d: G
- if(send(sockfd,msgbuffer,sizeof(msgbuffer),0)<0); n1 p$ _1 b1 [$ |& }3 y. S
- perror("ERROR");
& D8 d! L8 V; {' l, b2 j$ u/ K( _. H - & N2 W* e' N' C
- bzero(msgbuffer,sizeof(msgbuffer));
% P3 P+ |: j% z$ u9 i2 f# ` - recv(sockfd,msgbuffer,sizeof(msgbuffer),0);$ F& [ o( U& l
- printf("[receive]:%s\n",msgbuffer);+ I6 P6 ~& D) V
-
; j9 Q7 Y+ G; c% A$ D8 `5 B& e - usleep(500000);# [2 H8 A$ O! [, ^) d
- }+ R2 [0 m- G/ W- U
- }
复制代码 ! z6 {* K4 T/ b- y0 A4 c
+ f6 b, p9 x0 |( h. b* V服务端: - #include <time.h>; l* s0 I+ {6 r+ q j7 Y+ Q. m
- #include <stdio.h>- @4 I0 Z& I4 h, q y/ S% V
- #include <stdlib.h>3 [; m+ [! }) i! L% |) b" M) {
- #include <string.h>5 l- `( t ~9 M) g
- #include <unistd.h>" i0 r, F5 l; G6 {+ K/ {
- #include <arpa/inet.h>
+ c7 b5 D& o' @9 G& ] - #include <netinet/in.h>
5 }; l3 ?- q6 w; u$ E - #include <sys/types.h>
b8 G" V( l! g1 y - #include <sys/socket.h>
* H: }) i6 y, @6 R$ i - : n$ R. Z6 S+ X7 }# o
- #define LOCAL_PORT 6666 //本地服务端口0 Q. Z' {6 f8 N: \* ~
- #define MAX 5 //最大连接数量$ W# R0 N6 T3 A) ^$ `0 ~/ ]
-
6 l! w4 ]( }- k* w - int main(){
9 o7 Q6 f. Z$ B3 x- n - int sockfd,connfd,fd,is_connected[MAX];
" B4 Z1 j. P3 E5 t% j: v - struct sockaddr_in addr;; E! ^" \; V; J' g$ q
- int addr_len = sizeof(struct sockaddr_in);) {5 e8 X) r; |% h+ f$ g6 R
- char msgbuffer[256];
) N8 n! g4 I4 o3 H) S$ W2 u* j* o- M - char msgsend[] = "Welcome To Demon Server";5 m0 V% ~3 y( p* k" Q
- fd_set fds;
1 @/ S2 r C" q -
& @& {# h! _+ E% x, U6 {! g- N9 W - //创建套接字/ k* |' |5 K( |1 ], `& D
- sockfd = socket(AF_INET,SOCK_STREAM,0);. a, l3 R* E* W! w9 ?8 _- ]
- if(sockfd>=0)
. n, t1 `0 `. R4 b - printf("open socket: %d\n",sockfd);( h. u4 N9 A! U- Z* `$ ~
-
4 \0 D* d6 \" K- E - //将本地端口和监听地址信息保存到套接字结构体中
7 ?) g' G. z- O# p: m" l! C - bzero(&addr,sizeof(addr));
4 f) m; U1 Z2 @: H V2 j+ `! v - addr.sin_family=AF_INET;
: z2 y% D: ~3 z7 P0 L - addr.sin_port=htons(LOCAL_PORT);6 `0 [) q Y4 L! r/ ~2 }3 S: E
- addr.sin_addr.s_addr = htonl(INADDR_ANY); //INADDR_ANY表示任意地址0.0.0.0 0.0.0.0
8 C; z' _$ ^5 ^1 Z' D -
+ y. g. u; o! c - //将套接字于端口号绑定. B) z6 `0 R$ y
- if(bind(sockfd,(struct sockaddr*)&addr,sizeof(addr))>=0)) }9 ^0 @9 }2 \. }
- printf("bind the port: %d\n",LOCAL_PORT);
1 h- P2 }. Y/ a- c) U2 r - % l- [' S3 S% N: m" N
- //开启端口监听1 K' w$ ~4 G, y( l2 O
- if(listen(sockfd,3)>=0)7 V) r6 O) W5 l; |* R
- printf("begin listenning...\n");# D. |: y# z( }
-
7 l3 V. u4 x' v$ i% H! G - //默认所有fd没有被打开
. K- S) S/ D0 Z3 f- Q - for(fd=0;fd<MAX;fd++)/ n9 P8 _( \7 c5 l
- is_connected[fd]=0;3 T$ J: P: r! ^: ~5 j% u( s
- , T. Y" y3 ^% ~+ i+ H) M
- while(1){
_' o, S( Z6 r) P% V/ j/ }% c& w - //将服务端套接字加入集合中% T2 ]( P! W# Y" |( D3 S
- FD_ZERO(&fds);
2 y9 J2 C5 p4 q ` _+ { - FD_SET(sockfd,&fds);
% M3 g" e9 o0 a& i5 }3 H. ? -
) b& ~' F1 W- |+ F5 Z% X& H: R - //将活跃的套接字加入集合中- i; e8 ~5 k; f1 Y' R/ s9 n) Z
- for(fd=0;fd<MAX;fd++)
3 s q9 v; Q6 K: Q0 s% j0 [* Y: u - if(is_connected[fd])
1 K, n1 `- H1 y9 ~ - FD_SET(fd,&fds);
+ T9 t8 D7 Y* e+ v6 {+ c" w8 z -
! ^2 a" R# r! w" K - //监视集合中的可读信号,如果某个套接字有信号则继续执行,此时集合中只有存在信号的套接字会被置为1,其他置为0
: z1 m$ }( N; R; j4 H- N, A$ ~ - if(!select(MAX,&fds,NULL,NULL,NULL))+ C8 J! o, K" y
- continue;
; X T& G N4 f) d" o6 a+ D -
1 ]9 ]2 D2 K( ~- f- }3 t- ] - //遍历所有套接字判断是否在属于集合中的活跃套接字1 y$ s3 q v' j: B4 v
- for(fd=0;fd<MAX;fd++){
% H* N0 c. D) Q/ c1 L. m) ~; Z5 K - if(FD_ISSET(fd,&fds)){
1 [- i5 z6 G; F% c% ^/ K/ \ - if(fd==sockfd){ //如果套接字是服务端,那么与客户端accept建立连接
9 r% }3 V' \; m. _. w8 R, _ - connfd = accept(sockfd,(struct sockaddr*)&addr,&addr_len);+ y0 p3 T$ Z) j2 F Z6 E* b
- write(connfd,msgsend,sizeof(msgsend)); //向其输出欢迎语
$ w$ { b( n' j* `/ x - is_connected[connfd]=1; //对客户端的fd对应下标将其设为活跃状态,方便下次调用
: s$ S. A0 F! s0 [# T - printf("connected from %s\n",inet_ntoa(addr.sin_addr));
3 l$ x/ H% n' \! A - }else{ //如果套接字是客户端,读取其信息并返回,如果读取不到信息,冻结其套接字: A; n3 M! I4 E& e x4 p: G
- if(read(fd,msgbuffer,sizeof(msgbuffer))>0){
5 d2 Z/ | c8 x; a# F( v - write(fd,msgbuffer,sizeof(msgbuffer));
! D, l1 U# x: ` - printf("[read]: %s\n",msgbuffer);
. ^" t/ X0 }' K$ @ - }else{/ @+ _- o7 N* z- i9 L' Y. ]8 B
- is_connected[fd]=0;
1 M$ \. u2 T$ k - close(fd);
2 W; ? P- R2 f5 ]1 j, R2 ~ - printf("close connected\n");. F5 O/ l/ c: \4 p4 @1 @5 v
- }) g* I4 E" M5 I$ @/ v h
- }
6 M& l) n0 g# z1 ~" e - }
. c' Y7 F: p- `$ C# a - }0 t/ `# |: l4 }5 ~: j! q% d ]* i) q
- }
% O# a9 _2 o7 m- T. |- z1 u - }
复制代码
2 j U* S1 H8 b( Z& Z0 }
% Z4 I1 ?/ v! k, C* F. X2 v! S1 W8 b4 `
5 j2 X( `. ]4 Z# A2 g" a& h8 ^) D3 B/ e0 q
G1 U9 e2 v+ s5 ^' D! ?: b& u; ?
$ s1 v: m/ a) Z2 N) N! g
|