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 = 1;
    
    listenfd = socket(AF_INET,SOCK_STREAM,0);

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

    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 == -1) {
        printf("bind socket error
");
        exit(0);
    }

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

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

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

        nready = select(maxfd + 1, &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
", inet_ntoa(clitaddr.sin_addr), clitaddr.sin_port);
            fprintf(stdout, "accept clitaddr %s:%d
", inet_ntoa(clitaddr.sin_addr), clitaddr.sin_port);
            for(i = 0; i < FD_SETSIZE; i++) {
                if(client[i] < 0){
                    client[i] = connfd;
                    break;
                }
            }

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

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

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

    return 0;
}

客户端：

#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 = 0;
    FD_ZERO(&rset);

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

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

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

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

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

    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 < 0) {
        printf("connect error
");
        exit(0);
    }

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

执行结果：

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