int select(int nfds, fd\_set \*readfds, fd\_set \*writefds,  
              fd\_set \*exceptfds, struct timeval \*timeout);  

　　　　struct timeval {
　　　　　　　　long tv_sec; /* seconds */
　　　　　　　　long tv_usec; /* microseconds */
　　　　　　　　};

1.函数介绍

nfds

最大文件描述符+1

通过告诉内核最多需要检查的文件描述符数量，以提高效率，（否则内核需要检查所有的文件描述符）

至于为什么是最大文件描述符值+1，表示 需要检查的文件描述符的数量，原因是 文件描述符从0开始，而数量从1 开始。

readfds, writefds, exceptfds

都是传入传出参数

通过位掩码的方式表示监听的文件描述符

  void FD\_CLR(int fd, fd\_set \*set);  
   int  FD\_ISSET(int fd, fd\_set \*set);  
   void FD\_SET(int fd, fd\_set \*set);  
   void FD\_ZERO(fd\_set \*set);

timeout

可以选择：

一直阻塞，直到有事件触发

阻塞一段时间，直到有事件触发

不阻塞，立即返回

阻塞可能被信号处理中断，而timeout不是传出参数，所以timeout不会记录剩余的等待时间，而是使用上次的值调用。

如果需要剩余的等待时间，可以在select调用前后记录系统时间以计算。

2. 事件触发的情况

3. 改写客户端

基于select的 str_cli

客户端套接字可能的事件如下

void
str_cli(FILE *fp, int sockfd)
{
int maxfdp1;
fd_set rset;
char sendline[MAXLINE], recvline[MAXLINE];

    FD\_ZERO(&rset);  
    for ( ; ; ) {  
            FD\_SET(fileno(fp), &rset);  
            FD\_SET(sockfd, &rset);  
            maxfdp1 = max(fileno(fp), sockfd) + 1;  
            Select(maxfdp1, &rset, NULL, NULL, NULL);

            if (FD\_ISSET(sockfd, &rset)) {  /\* socket is readable \*/  
                    if (Readline(sockfd, recvline, MAXLINE) == 0)  
                            err\_quit("str\_cli: server terminated prematurely");  
                    Fputs(recvline, stdout);  
            }

            if (FD\_ISSET(fileno(fp), &rset)) {  /\* input is readable \*/  
                    if (Fgets(sendline, MAXLINE, fp) == NULL)  
                            return;         /\* all done \*/  
                    Writen(sockfd, sendline, strlen(sendline));  
            }  
    }  

}

改进

（1）批量输入

因为程序采用 停等方式，如果采用交互输入，一个RTT的情况如下

可见只用了管道的 1/8

如果使用文件重定向的方式运行程序，那么会批量输入程序，但运行结果出错，输出文件小于输入文件。

考虑下面情况

当运行到时刻8时，客户端已经read完了文件，所以会close，造成套接字进入半关闭，

如此服务器发送的数据，客户端就无法接受，导致数据丢失。

半关闭
单方面调用close后，
主动关闭方进入 FIN_WAIT_2， 不能进行读写操作
被动关闭方进入 CLOSE_WAIT，能进行读写操作，不过read返回0，write的数据不能传递给对端的应用层（在对端的TCP层被接受后丢弃）。

解决方法是：

发送FIN，告诉对方自己已经完成了数据发送，但是仍然保持套接字描述符打开以便读取，

使用 shutdown实现

（2）缓冲和 select

select 关于读写操作的事件触发是按照read/write的情况，即不带缓冲的情况，

如果使用 stdio或者自定义的缓冲操作容易造成错误，

如，使用 fgets，当 select 触发后，fgets会尽可能读数据到缓冲，可能读了多行输入，但是一次只返回一行，

于是select触发一次，收到多行输入，但是只处理了一行输入。

解决方法：

避免select和缓冲io合用。

shutdown函数

为了实现，客户端关闭后，仍能接受对方的输入

   int shutdown(int sockfd, int how);

howto

SHUT_RD
关闭读，丢弃套接字接受缓冲区所有数据，所有新来的对端数据被悄悄接受，回复，并丢弃

SHUT_WR
关闭写，套接字发送缓冲区现有数据正常发送，并发送FIN，进程不能对该套接字进行写操作

SHUT_RDWR
相当于分别调用 SHUT_RD,和SHUT_WR

修订版

void
str_cli(FILE *fp, int sockfd)
{
int maxfdp1, stdineof;
fd_set rset;
char buf[MAXLINE];
int n;

    stdineof = 0;  
    FD\_ZERO(&rset);  
    for ( ; ; ) {  
            if (stdineof == 0)  
                    FD\_SET(fileno(fp), &rset);  
            FD\_SET(sockfd, &rset);  
            maxfdp1 = max(fileno(fp), sockfd) + 1;  
            Select(maxfdp1, &rset, NULL, NULL, NULL);

            if (FD\_ISSET(sockfd, &rset)) {  /\* socket is readable \*/  
                    if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {  
                            if (stdineof == 1)  
                                    return;         /\* normal termination \*/  
                            else  
                                    err\_quit("str\_cli: server terminated prematurely");  
                    }

                    Write(fileno(stdout), buf, n);  
            }

            if (FD\_ISSET(fileno(fp), &rset)) {  /\* input is readable \*/  
                    if ( (n = Read(fileno(fp), buf, MAXLINE)) == 0) {  
                            stdineof = 1;  
                            Shutdown(sockfd, SHUT\_WR);      /\* send FIN \*/  
                            FD\_CLR(fileno(fp), &rset);  
                            continue;  
                    }

                    Writen(sockfd, buf, n);  
            }  
    }  

}

select 实现服务器

通过select ，实现单个进程检测多个套接字。

思考需要的数据结构，由于单进程要维护多个客户端连接，即需要区分多个客户端，客户端的区分使用对应套接字，所以需要一个维护已连接客户端的文件描述符数组。

另外，由于使用select，监控read事件，所以需要一个readfds数组。

client中，将未使用的置为-1.

rset中，前三个描述符被占用，fd3为监听套接字。

另外需要思考，添加客户端，和删除客户端，时对上面的数据结构的操作顺序。

对于添加客户端，

　　首先，已经知道的数据，accept获得 connfd，所以client[i] = connfd，FD_SET(connfd, &rset)

　　然后select需要 maxfd1 ，所以需要维护一个maxfd, if(connfd > maxfd) maxfd = connfd;

对于删除客户端

　　首先，已经知道的数据：FD_ISSET(fd, &rset) 获得 connfd，所以 if(client[i] == fd) client[i] = -1; FD_CLR(fd, &rset)

　　对于maxfd1，不方便处理，所以就不处理了，比较几乎不会影响效率。

/* include fig01 */
#include "unp.h"

int
main(int argc, char **argv)
{
int i, maxi, maxfd, listenfd, connfd, sockfd;
int nready, client[FD_SETSIZE];
ssize_t n;
fd_set rset, allset;
char buf[MAXLINE];
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;

listenfd = Socket(AF\_INET, SOCK\_STREAM, 0);

bzero(&servaddr, sizeof(servaddr));  
servaddr.sin\_family      = AF\_INET;  
servaddr.sin\_addr.s\_addr = htonl(INADDR\_ANY);  
servaddr.sin\_port        = htons(SERV\_PORT);

Bind(listenfd, (SA \*) &servaddr, sizeof(servaddr));

Listen(listenfd, LISTENQ);

maxfd = listenfd;            /\* initialize \*/  
maxi = -1;                    /\* index into client\[\] array \*/  
for (i = 0; i < FD\_SETSIZE; i++)  
    client\[i\] = -1;            /\* -1 indicates available entry \*/  
FD\_ZERO(&allset);  
FD\_SET(listenfd, &allset);  

/* end fig01 */

/* include fig02 */
for ( ; ; ) {
rset = allset; /* structure assignment */
nready = Select(maxfd+1, &rset, NULL, NULL, NULL);

    if (FD\_ISSET(listenfd, &rset)) {    /\* new client connection \*/  
        clilen = sizeof(cliaddr);  
        connfd = Accept(listenfd, (SA \*) &cliaddr, &clilen);  

#ifdef NOTDEF
printf("new client: %s, port %d\n",
Inet_ntop(AF_INET, &cliaddr.sin_addr, 4, NULL),
ntohs(cliaddr.sin_port));
#endif

        for (i = 0; i < FD\_SETSIZE; i++)  
            if (client\[i\] < 0) {  
                client\[i\] = connfd;    /\* save descriptor \*/  
                break;  
            }  
        if (i == FD\_SETSIZE)  
            err\_quit("too many clients");

        FD\_SET(connfd, &allset);    /\* add new descriptor to set \*/  
        if (connfd > maxfd)  
            maxfd = connfd;            /\* for select \*/  
        if (i > maxi)  
            maxi = i;                /\* max index in client\[\] array \*/

        if (--nready <= 0)  
            continue;                /\* no more readable descriptors \*/  
    }

    for (i = 0; i <= maxi; i++) {    /\* check all clients for data \*/  
        if ( (sockfd = client\[i\]) < 0)  
            continue;  
        if (FD\_ISSET(sockfd, &rset)) {  
            if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {  
                    /\*4connection closed by client \*/  
                Close(sockfd);  
                FD\_CLR(sockfd, &allset);  
                client\[i\] = -1;  
            } else  
                Writen(sockfd, buf, n);

            if (--nready <= 0)  
                break;                /\* no more readable descriptors \*/  
        }  
    }  
}  

}
/* end fig02 */

拒绝服务型攻击

　　对于上面这种单个服务进程处理多个客户端，可能由拒绝服务型攻击，

　　比如，如果服务器使用 ReadLine 与客户端通信，那么恶意客户端可能只输入一个字符，不输入回车，于是服务器就会阻塞在readline，导致无法为其他客户端服务。

　　解决方法是，（a）多进程或多线程处理客户端 （b）非阻塞IO（c）IO操作设置超时

pselect

   int pselect(int nfds, fd\_set \*readfds, fd\_set \*writefds,  
               fd\_set \*exceptfds, const struct timespec \*timeout,  
               const sigset\_t \*sigmask);

pselect 是select的增强版，具体增强如下：

　　（1）使用 timespec ,代替timeval

       struct timeval {  
           long    tv\_sec;         /\* seconds \*/  
           long    tv\_usec;        /\* microseconds \*/  
       };

   and

       struct timespec {  
           long    tv\_sec;         /\* seconds \*/  
           long    tv\_nsec;        /\* nanoseconds \*/  
       };

　　　　timespec.tv_nsec是纳秒级。而select只能设置到微秒级。

　　（2）可以设置pselect阻塞期间的 sigmask。这可解决如下问题

　　　　SIGINT的回调函数只设置全局变量 intr_flag，通过检测intr_flag决定是否处理handle_intr，

　　　　但是如果 SIGINT 发生在 if(intr_flag) 之后，select阻塞之前，则程序会永远阻塞。

if (intr_flag)
handle_intr();
if ((nready = select()) < 0) {
if (errno == EINTR) {
if (intr_flag)
handle_intr();
}
}

　　　　可以使用pselect解决，在pselect之前阻塞 SIGINT，pselect阻塞时，放开 SIGINT

sigset_t newmask, oldmask, zeromask

sigemptyset(&zeromask);
sigemptyset(&newmask);
sigaddset(&newmask, SIGINT);

sigprocmask(SIG_BLOCK, &newmask, &oldmask);

if (intr_flag)
handle_intr();
if ((nready = pselect(…, &zeromask)) < 0) {
if (errno == EINTR) {
if (intr_flag)
handle_intr();
}
}