问题聚焦：
当客户端阻塞于从标准输入接收数据时，将读取不到别的途径发过来的必要信息，如TCP发过来的FIN标志。
因此，进程需要内核一旦发现进程指定的一个或多个IO条件就绪（即输入已准备好被读取，或者描述符已能承接更多的输出），它就通知进程。
这个机制称为I/O复用，这是由select, poll, epoll函数支持的。
编译环境：
Ubuntu12.04 g++
需求描述：
- 单进程，IO复用，实现多个连接同时监听和收发信息
- 当服务器进程一终止，客户就能马上得到结果（select +shutdown实现）
- 当客户端使用"exit"命令或者Cirl+C结束进程时，服务器可以立即感应到，并关闭当前接口（select+close实现
来看一下实现后的运行效果：
步骤：
- 服务器连接了第一个客户，并收发消息“hello world”
- 服务器连接了第二个客户，并收发消息“hello select”
- 服务器从第一个客户收发消息“hello world again”
- 服务器从第二个客户收发消息“hello select again”
- 第二个客户关闭连接
- 第一个客户关闭连接
在了解select实现之前，先复习一下之前了解的IO模型
五种IO模型
- 阻塞式IO
- 非阻塞式IO
- IO复用
- 信号驱动式IO
- 异步IO
对比：
一个输入操作通常包括两个不同的阶段：
- 等待数据准备好
- 从内核向进程复制数据
对于TCP来说，这两步分别为：
- 等待数据从网络中到达，当所等待分组到达时，它被复制到内核中的某个缓冲区
- 把数据从内核缓冲区复制到应用进程缓冲区
select
流程：
- select主要通过维护两个数组，来实现端口的轮询：
- client[]数组，记录有哪些连接已经建立
- rset[]数组，记录有注册哪些端口，需要监听
- 当rset数组中注册的端口被激活，这时将端口号放到client数组中，稍后遍历client[]数组，处理连接上的数据
代码实现：
服务器端：
#include "mtserver.h" int main(int argc, char* argv[])
{
checkArgc(argc, ); const char* ip = argv[];
int port = atoi( argv[] ); /* declare socket*/
int listenfd, connfd, sockfd;
int ret; /* initialize listen socket*/
mySocket(listenfd); /* server address */
struct sockaddr_in servaddr;
initSockAddr(servaddr, ip, port); /* bind */
myBind(listenfd,
(struct sockaddr*)&servaddr,
sizeof(servaddr)); /* listen */
myListen(listenfd, ); /* handle SIGCHLD signal*/
//signal(SIGCHLD, handle_sigchild); /* waiting for connecting */
pid_t chipid;
socklen_t clilen;
struct sockaddr_in cliaddr; /* select initialize */
int maxfd, maxi, i;
bool toclose;
int nready, client[FD_SETSIZE];
fd_set rset, allset; maxfd = listenfd;
maxi = -;
for ( i=; i < FD_SETSIZE; i++ )
client[i] = -; FD_ZERO(&allset);
FD_SET(listenfd, &allset); printf("Waiting for connecting...\n"); for(;;) {
rset = allset;
if ( (nready=select(maxfd+, &rset, NULL, NULL, NULL)) < ) {
fprintf(stderr,
"select failed.%s\n",
strerror(errno));
continue;
} /* handle listen fd and no recv or respond */
if (FD_ISSET(listenfd, &rset)) {
clilen = sizeof(cliaddr);
connfd = myAccept(listenfd,
(struct sockaddr*)&cliaddr,
&clilen);
printf("Connection is established with sockfd: %d\n",
connfd);
for ( i = ; i < FD_SETSIZE; i++) {
if ( client[i] < ) {
client[i] = connfd;
break;
}
} if (i == FD_SETSIZE) {
fprintf(stderr,
"too many clients\n"
);
break;
} FD_SET( connfd, &allset );
if ( connfd > maxfd ) {
maxfd = connfd;
}
if ( i > maxi) {
maxi = i;
} if (--nready <= ) {
continue;
}
} /* handle accept fds(client[]) and handle recv or respond msg */
for ( i = ; i <= maxi; i++) {
if ( (sockfd = client[i]) < )
continue;
if ( FD_ISSET(sockfd, &rset) ) {
if( (toclose = handle_recv(sockfd))) {
printf("Client close this connection: %d\n" ,
sockfd);
close(sockfd);
FD_CLR(sockfd, &allset);
client[i] = -;
} if (--nready <= )
break;
}
}
}
} bool handle_recv(int connfd) { char recvbuf[BUFSIZE]; memset( recvbuf, '\0', BUFSIZE );
if ( recv(connfd, recvbuf,BUFSIZE,) != ) {
if (!strcmp(recvbuf, "exit"))
return true;
fprintf(stderr,"recv msg: \"%s\" from connfd:%d\n", recvbuf, connfd);
send(connfd, recvbuf, strlen(recvbuf), );
fprintf(stderr,"send back: \"%s\" to connfd:%d\n\n", recvbuf, connfd);
}
else
return true;
return false;
}
客户端：
#include "mtclient.h" int main(int argc, char* argv[])
{
checkArgc(argc, ); int port = atoi(argv[]);
char* ip = argv[]; int sockfd;
struct sockaddr_in servaddr; mySocket(sockfd); initSockAddr(servaddr,ip, port); myConnect(sockfd,
(struct sockaddr*)&servaddr,
sizeof(servaddr)); handle_msg(sockfd);
exit(); } void handle_msg(int sockfd) { char sendbuf[BUFSIZE];
char recvbuf[BUFSIZE]; int maxfdpl, ret;
fd_set rset;
int normalTermi = ; FD_ZERO(&rset); while() {
memset( sendbuf, '\0', BUFSIZE );
memset( recvbuf, '\0', BUFSIZE ); if (normalTermi == )
FD_SET( , &rset ); FD_SET( sockfd, &rset );
maxfdpl = sockfd + ; if(DEBUG)
printf("Debug: waiting in select\n");
if ( select( maxfdpl, &rset, NULL, NULL, NULL) < ) {
fprintf(stderr,
"select failed.%s\n",
strerror(errno));
}
if(DEBUG)
printf("Debug: after select\n"); if (FD_ISSET( sockfd, &rset )) {
if (recv(sockfd, recvbuf, BUFSIZE, ) == ) { if(DEBUG)
printf("Debug: ready to quit, normalTermi: %d\n" ,
normalTermi); if (normalTermi == ) {
printf("handle_msg: normal terminated.\n");
return;
}
else {
printf("handle_msg: server terminated.\n");
exit();
}
}
fprintf(stderr,
"recv back: %s\n",
recvbuf);
}
else if ( FD_ISSET( , &rset ) ) {
gets(sendbuf);
if (strlen(sendbuf) > ) {
send(sockfd, sendbuf, strlen(sendbuf), );
if ( !strcmp(sendbuf, "exit") ) {
normalTermi = ;
shutdown(sockfd, SHUT_WR);
FD_CLR(, &rset);
continue;
}
}
}
}
close( sockfd );
return;
}
问题：
1 监听标准输入的描述符？
解决：标准输入描述符：0
2 当客户端发送所有消息，即可关闭连接，但是如果这时候调用close方法，会导致接收不到仍在传送过来的信息。
方案：需要一种关闭TCP连接其中一半的方法，也即是说，我们想给服务器发送一个FIN，告诉它我们已经完成了数据发送，但是仍然保持套接字描述符打开以便读取。
完成这个功能的函数为shutdown。
shutdown函数可以不管描述符的引用计数，就激发TCP的正常连接终止序列。
关闭一半的图示：
函数声明：
#include <sys/socket.h>
int shutdown(int sockfd, int howto);
howto：取值SHUT_RD（关闭这一端的读，不再读取连接上的数据）
SHUT_WR（关闭这一端的写，不再往连接上写数据）
SHUT_RDWR（关闭这一端的读和写）
3 套接字描述符的第一个可用描述符是多少？
答案：3。0 1 2分别为标准输入，标准输出，标准错误输出。
4 服务器进程终止后的动作？
这里需要知道的一点是，当服务器进程一终止，就会对客户进程发送一个FIN信号，这时套接字连接可读，read返回0
参考资料：
《Linux高性能服务器编程》
《UNIX网络编程 卷1：套接字联网API（第3版）》