io多路复用-select()

参照《Unix网络编程》相关章节内容，实现了一个简单的单线程IO多路复用服务器与客户端。

普通迭代服务器，由于执行recvfrom则会发生阻塞，直到客户端发送数据并正确接收后才能够返回，一个服务器进程只能服务于一个客户端，解决这种问题可采用多线程方式（参见虚拟机隐藏进程检测工具实现）和IO多路复用select和poll，select()机制的优势在于可以同时等待多个描述符就绪。

与IO复用密切相关的另一种IO模型是在多线程中使用阻塞式IO。

简要描述select机制：

fd_set rset

void FD_ZERO(fd_set *fdset)

void FD_SET(int fd, fd_set *fdset)

void FD_CLR(int fd, fd_set *fdset)

void FD_ISSET(int fd, fd_set *fdset)

其中rset类型为fd_set，可理解为一个位图，用于标识哪些描述符正在被监听。FD_ZERO用于初始化rset，FD_SET用于设置新的用于被监听的描述符，FD_CLR用于清空rset，FD_ISSET用户判断具体哪个描述符就绪。

由于tcp服务器中具有监听套接字与已连接套接字两个概念，在服务器端实现中主要过程如下：

1. 初始化rset，转2；
2. 添加监听套接字到rset中，转3；
3. select阻塞等待是否存在描述符就绪，转4；
4. 当客户端连接后，rset中设置的监听套接字就绪，添加已连接套接字到rset，转5；
5. 判断哪个描述符就绪（一般为新的已连接套接字），进行套接字读写操作，转1；

在《Unix网络编程》中，上述步骤5结束后直接转2，但在实际测试与资料查阅中，由于内核会修改描述符内容，使得需要重新初始化rset才能有效。

代码测试：

服务端：

 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/select.h>
 #include <unistd.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <linux/netlink.h>
 #include <string.h>
 #include <arpa/inet.h>

 #define IP_ADDR 127.0.0.1
 #define IP_PORT 8081

 #define LISTEN_NUM 10

 #define MAXLINE 1024

 int main(void)
 {
     struct sockaddr_in clitaddr, servaddr;
     unsigned int clilen;
     int listenfd, connfd, sockfd, ret;

     int maxindex, i, n;

     int maxfd;
     fd_set allset;

     int client[FD_SETSIZE];
     int nready;

     char buf[MAXLINE];

     int reuse = ;

     listenfd = socket(AF_INET,SOCK_STREAM,);

     if(setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -) {
         return -;
     }

     bzero(&servaddr,sizeof(servaddr));
     servaddr.sin_family = AF_INET;
     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
     servaddr.sin_port = htons(IP_PORT);

     ret = bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
     if(ret == -) {
         printf("bind socket error\n");
         exit();
     }

     ret = listen(listenfd,LISTEN_NUM);
     if(ret == -) {
         printf("listen socket error\n");
         exit();
     }

     maxfd = listenfd;
     maxindex = -;
     for(i = ; i < FD_SETSIZE; i++) {
         client[i] = -;
     }
     //FD_ZERO(&allset);
     //FD_SET(listenfd, &allset);

     for( ; ; ) {
         //reset = allset;
         FD_ZERO(&allset);
         FD_SET(listenfd, &allset);
         for (i = ; i <= maxindex; i++) {
             FD_SET(client[i], &allset);
         }

         nready = select(maxfd + , &allset, NULL, NULL, NULL);

         if(FD_ISSET(listenfd, &allset)) {
             clilen = sizeof(clitaddr);
             connfd = accept(listenfd, (struct sockaddr*)&clitaddr, &clilen);
             //connfd = accept(listenfd, (struct sockaddr*)&clitaddr, sizeof(clitaddr));

             //printf("clitaddr ip : %d,port : %d\n", inet_ntoa(clitaddr.sin_addr), clitaddr.sin_port);
             fprintf(stdout, "accept clitaddr %s:%d\n", inet_ntoa(clitaddr.sin_addr), clitaddr.sin_port);
             for(i = ; i < FD_SETSIZE; i++) {
                 if(client[i] < ){
                     client[i] = connfd;
                     break;
                 }
             }

             if(i == FD_SETSIZE) {
                 printf("too many clients\n");
                 exit();
             }

             FD_SET(connfd, &allset);
             if(connfd > maxfd) {
                 maxfd = connfd;
             }
             if(i > maxindex) {
                 maxindex = i;
             }
             if(--nready <= )
                 continue;
         }

         for(i = ; i <= maxindex; i++) {
             if((sockfd = client[i]) < )
                 continue;
             if(FD_ISSET(sockfd, &allset)) {
                 if((n = recv(sockfd, buf, MAXLINE, )) == ) {
                     close(sockfd);
                     FD_CLR(sockfd, &allset);
                     client[i] = -;
                 }
                 else {
                     printf("server recv buf is %s\n", buf);
                     send(sockfd, buf, strlen(buf), );
                 }
                 if(--nready <= )
                     break;
             }
         }
     }

     return ;
 }

客户端：

 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <sys/select.h>
 #include <time.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <errno.h>
 #include <math.h>

 #define SERVER_ADDR "127.0.0.1"
 #define SERVER_PORT 8081

 #define MAXLINE 1024

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

     stdineof = ;
     FD_ZERO(&rset);

     for( ; ; ) {
         if(stdineof == )
             FD_SET(fileno(fp), &rset);
         FD_SET(sockfd, &rset);
         maxfdp = (fileno(fp) > sockfd) ? (fileno(fp) + ) : (sockfd + );
         //maxfdp = max(fileno(fp), sockfd) + 1;
         select(maxfdp, &rset, NULL, NULL, NULL);

         if(FD_ISSET(sockfd, &rset)) {
             if ((n = recv(sockfd, buf, MAXLINE, )) == ) {
                 if (stdineof = ) {
                     return ;
                 }
                 else {
                     printf("server prematurely\n");
                     exit();
                 }
             }
             printf("client:sockfd ready\n");
             //write(fileno(stdout), buf, n);
             write(fileno(stdout), buf, strlen(buf) + );
         }

         if (FD_ISSET(fileno(fp), &rset)) {
             if ((n = read(fileno(fp), buf, MAXLINE)) == ) {
                 stdineof = ;
                 shutdown(sockfd, SHUT_WR);
                 FD_CLR(fileno(fp), &rset);
                 continue;
             }
             //buf[n] = '\0';
             printf("client buf is %s",buf);
             send(sockfd, buf, strlen(buf), );
         }
     }
     return ;
 }

 int main(void)
 {
     int sockfd, ret;
     struct sockaddr_in servaddr;

     sockfd = socket(AF_INET, SOCK_STREAM, );
     if(sockfd < ) {
         printf("create socket error\n");
         exit();
     }

     bzero(&servaddr, sizeof(servaddr));
     servaddr.sin_family = AF_INET;
     servaddr.sin_port = htons(SERVER_PORT);
     servaddr.sin_addr.s_addr = inet_addr(SERVER_ADDR);

     ret = connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
     if(ret < ) {
         printf("connect error\n");
         exit();
     }

     str_cli(stdin, sockfd);
     exit();
 }

执行结果：

服务器启动后处于监听状态，可以启动多个客户端连入服务器请求并响应。实验结果略。