Linux 多路轉接I/O select函數

網絡管理考試最後一道大題涉及socket和多路轉接I/O的select函數。哎，感覺複習的時候還是沒有把握到精髓，那道題就有些遺憾了……

多路轉接I/O：

先構造一張有關描述符的列表，然後調用一個函數，直到這些描述符中的一個已準備好進行I/O時，該函數才返回。在返回時，它告訴進程哪些描述符已準備好可以進行I/O。

select函數

作用：允許程序監視多個文件描述符，以等待一個或多個文件描述符變爲ready,以便進行I/O操作。

Ready:一個文件描述符可以執行相應I/O操作而不會被blocking時，該文件描述符被認爲是ready

 格式：#inlucde <sys/select.h>

         int select(int maxfdp1, 

                     fd_set *restrict readfds,  

                     fd_set *restrict writefds,

                     fd_set *restrict exceptfds,

                     struct timeval *restrict  tvptr);

•返回值：

—返回準備就緒的描述符，所以正返回值表示已經準備好的描述符

—若超時則返回0，表示沒有描述符準備好

—若出錯則返回-1

參數 timeout爲結構timeval，用來設置select()的等待時間，其結構定義如下
struct timeval
{
time_t tv_sec;
time_t tv_usec;
};

有三種情況：

• tvptr == NULL

            永遠等待。如果捕捉到一個信號則中斷此無限期等待。當所指定的描述符中的一個已準備好或捕捉到一個信號則返回。如果捕捉到一個信號，則select返回-1，errno設置爲EINTR

• tvptr->tv_sec == 0 && tvptr->tv_usec == 0

             完全不等待。測試所有指定的描述符並立即返回。

• tvptr->tv_sec ！= 0 || tvptr->tv_usec ！= 0

             等待指定的秒數和微妙數。當指定的描述符之一已準備好或當指定的時間值已經超過時立即返回。如果在超時時還沒有一個描述符準備好，則返回值是0.與第一種情況一樣，這種等待可被捕捉到的信號中斷。

中間三個參數readfds、writefds和exceptfds是指向描述符集的指針。這三個描述符集說明了我們關心的可讀、可寫或處於異常條件的各個描述符。每個描述符集存放在一個fd_set數據類型中。這種數據類型爲每一可能的描述符保持了一位。

    select的中間三個參數（指向描述符集的指針）中的任意一個或全部都可以是空指針，這表示對相應狀態並不關心。如果所有三個指針都是空指針，則select提供了較sleep更精確的計時器。
     select的第一個參數maxfdp1的意思是“最大描述符加1”。在三個描述符集中找出最大描述符值，然後加1，這就是第一個參數。也可以將第一個參數設置爲FD_SETSIZE，這是<sys/select.h>中的一個常量，它說明了最大的描述符（經常是1024）。如果將第一個參數設置爲我們關注的最大描述符編號值加1，內核就只需在此範圍內尋找打開的位，而不必在三個描述符集中的數百位內搜索。

描述符集的處理函數:
FD_CLR(inr fd,fd_set* set); //用來清除描述詞組set中相關fd 的位
FD_ISSET(int fd,fd_set *set); //用來測試描述詞組set中相關fd 的位是否爲真
FD_SET(int fd,fd_set*set); //用來設置描述詞組set中相關fd的位
FD_ZERO(fd_set *set); //用來清除描述詞組set的全部位

使用select函數的過程一般是：
先調用宏FD_ZERO將指定的fd_set清零，然後調用宏FD_SET將需要測試的fd加入fd_set，接着調用函數select測試fd_set中的所有fd，最後用宏FD_ISSET檢查某個fd在函數select調用後，相應位是否仍然爲1。
以下是一個測試單個文件描述字可讀性的例子：
int isready(int fd)
{
      int rc;
      fd_set fds;
      struct tim tv;
      FD_ZERO(&fds);
      FD_SET(fd,&fds);
      tv.tv_sec = tv.tv_usec = 0;
      rc = select(fd+1, &fds, NULL, NULL, &tv);
      if (rc < 0) //error
      return -1;
      return FD_ISSET(fd,&fds) ? 1 : 0;
}

基於select實現的網絡服務器和客戶端：

server.c

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<signal.h>
#include<sys/wait.h>

/*
 *網絡服務器，select參與調度
 * */

//ERR_EXIT(M)是一個錯誤退出宏
#define ERR_EXIT(m) \
    do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while (0)


int main(void)
{
    signal(SIGPIPE, SIG_IGN);

    //1.創建套接字
    int listenfd;                 //被動套接字(文件描述符），即只可以accept, 監聽套接字
    if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
        ERR_EXIT("socket error"); //調用上邊的宏

    struct sockaddr_in servaddr;

    //memset(&servaddr, 0, sizeof(servaddr));
    //三個結構體成員
    //設置本地IP 和端口
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(8080);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    /* servaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); */
    /* inet_aton("127.0.0.1", &servaddr.sin_addr); */

    //2.設置套接字屬性
    int on = 1;
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
        ERR_EXIT("setsockopt error");

    //3.綁定
    if (bind(listenfd, (struct sockaddr*)&servaddr,sizeof(servaddr)) < 0)
        ERR_EXIT("bind error");

    //4.監聽
    if (listen(listenfd, SOMAXCONN) < 0) //listen應在socket和bind之後，而在accept之前
        ERR_EXIT("listen error");

    struct sockaddr_in peeraddr; //傳出參數
    socklen_t peerlen = sizeof(peeraddr); //傳入傳出參數，必須有初始值

    int conn; // 已連接套接字(變爲主動套接字，即可以主動connect)
    int i;
    int client[FD_SETSIZE];
    int maxi = 0; // client數組中最大不空閒位置的下標
    for (i = 0; i < FD_SETSIZE; i++)
        client[i] = -1;

    int nready;
    int maxfd = listenfd;
    fd_set rset;
    fd_set allset;
    FD_ZERO(&rset);
    FD_ZERO(&allset);
    FD_SET(listenfd, &allset);

    while (1) {
        rset = allset;
        nready = select(maxfd + 1, &rset, NULL, NULL, NULL);
        if (nready == -1) {
            if (errno == EINTR)
                continue;
            ERR_EXIT("select error");
        }

        if (nready == 0)
            continue;

        if (FD_ISSET(listenfd, &rset)) {

            conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen);  //accept不再阻塞
            if (conn == -1)
                ERR_EXIT("accept error");

            for (i = 0; i < FD_SETSIZE; i++) {
                if (client[i] < 0) {
                    client[i] = conn;
                    if (i > maxi)
                        maxi = i;
                    break;
                }
            }

            if (i == FD_SETSIZE) {
                fprintf(stderr, "too many clients\n");
                exit(EXIT_FAILURE);
            }

            printf("recv connect ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr),
                ntohs(peeraddr.sin_port));

            FD_SET(conn, &allset);
            if (conn > maxfd)
                maxfd = conn;

            if (--nready <= 0)
                continue;
        }

        for (i = 0; i <= maxi; i++) {
            conn = client[i];
            if (conn == -1)
                continue;

            if (FD_ISSET(conn, &rset)) {

                char recvbuf[1024] = {0};
                int ret = read(conn, recvbuf, 1024);
                if (ret == -1)
                    ERR_EXIT("readline error");
                else if (ret  == 0) { //客戶端關閉
                    printf("client close \n");
                    FD_CLR(conn, &allset);
                    client[i] = -1;
                    close(conn);
                }

                fputs(recvbuf, stdout);
                write(conn, recvbuf, strlen(recvbuf));

                if (--nready <= 0)
                    break;
            }
        }
    }
    return 0;
}

client.c

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>


#define ERR_EXIT(m) \
    do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while (0)




int main(void)
{
    int sock;
    if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
        //  listenfd = socket(AF_INET, SOCK_STREAM, 0)
        ERR_EXIT("socket error");


    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(8080);
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    /* inet_aton("127.0.0.1", &servaddr.sin_addr); */

    if (connect(sock, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
        ERR_EXIT("connect error");
    struct sockaddr_in localaddr;
    char cli_ip[20];
    socklen_t local_len = sizeof(localaddr);
    memset(&localaddr, 0, sizeof(localaddr));
    if( getsockname(sock,(struct sockaddr *)&localaddr,&local_len) != 0 )
        ERR_EXIT("getsockname error");
    inet_ntop(AF_INET, &localaddr.sin_addr, cli_ip, sizeof(cli_ip));
    printf("host %s:%d\n", cli_ip, ntohs(localaddr.sin_port));

    fd_set rset;
    FD_ZERO(&rset);
    int nready;
    int maxfd;
    int fd_stdin = fileno(stdin); //
    if (fd_stdin > sock)
        maxfd = fd_stdin;
    else
        maxfd = sock;
    char sendbuf[1024] = {0};
    char recvbuf[1024] = {0};

    while (1)
    {

        FD_SET(fd_stdin, &rset);
        FD_SET(sock, &rset);
        nready = select(maxfd + 1, &rset, NULL, NULL, NULL); //select返回表示檢測到可讀事件
        if (nready == -1)
            ERR_EXIT("select error");

        if (nready == 0)
            continue;

        if (FD_ISSET(sock, &rset))
        {

            int ret = read(sock, recvbuf, sizeof(recvbuf));
            if (ret == -1)
                ERR_EXIT("read error");
            else if (ret  == 0)   //服務器關閉
            {
                printf("server close\n");
                break;
            }

            fputs(recvbuf, stdout);
            memset(recvbuf, 0, sizeof(recvbuf));
        }

        if (FD_ISSET(fd_stdin, &rset))
        {

            if (fgets(sendbuf, sizeof(sendbuf), stdin) == NULL)
                break;

            write(sock, sendbuf, strlen(sendbuf));
            memset(sendbuf, 0, sizeof(sendbuf));
        }
    }

    close(sock);
    return 0;
}