poll

poll机制的工作原理及流程与select类似，但poll可监控的进程数量不受select中第二个因素——fd_set集合容量的限制，用户可在程序中自行设置被监测的文件描述符集的容量，当然poll在阻塞模式下也采用轮询的方式监测文件描述符集，因此应合理设置poll中监控进程的数量。poll机制主要通过poll()函数实现，下面对poll()函数进行讲解。

poll()函数存在于函数库poll.h中，其声明如下：

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

poll()函数中参数fds是一个struct pollfd类型的指针，主要用于传入被监测的多个文件描述符，其数据类型struct pollfd的定义如下：

struct pollfd{
  int fd;       //文件描述符
  short events;   //等待的事件
  short revents;   //实际发生的事件
}

该结构体中的成员fd表示文件描述符，当将fd设置为-1时，表示取消对该文件描述符的监测；成员events用于设置程序等待的事件，该值由用户主动设置；成员revents用于设置文件描述符的操作结果对应的事件，该值在函数返回时被设置。poll可能涉及的事件及其对应的宏如表1所示。

表1 poll事件相关宏及其说明

poll()函数中的参数nfds等同于select()函数中的参数nfds，用来设置pollt监控的文件描述符的范围，需设置为文件描述符最大值加1；参数timeout与select()函数中的参数timeout，都用于设置组设时长，但其取值略有差异，poll()函数中参数timeout的取值及其对应含义如下：

● 当timeout=-1时，poll()函数阻塞等待；

● 当timeout=0时，poll()函数将立即返回，以轮询的方式监测文件描述符表；

● 当timeout>0时，等待指定时长（单位为毫秒，若当前系统时间精度不够毫秒则向上取值）。

poll()函数若调用成功将返回就绪文件描述符数量；若等待超时，将返回0，表示没有已就绪的文件描述符；若调用出错，将返回-1，并设置errno。

案例4：使用poll模型搭建多路I/O转接服务器，使服务器可接收客户端数据，并将接收到的数据转为大写，写回客户端；使客户端可向服务器发送数据，并将服务器返回的数据打印到终端。

案例实现如下：

poll_s.c //服务器

 1    #include <stdio.h>
 2    #include <stdlib.h>
 3    #include <string.h>
 4    #include <netinet/in.h>
 5    #include <arpa/inet.h>
 6    #include <poll.h>
 7    #include <errno.h>
 8    #include "wrap.h"
 9    #define MAXLINE 80
 10    #define SERV_PORT 8000
 11    #define OPEN_MAX 1024
 12    int main()
 13    {
 14        int i, j, maxi, listenfd, connfd, sockfd;
 15        int nready;
 16        ssize_t n;
 17        char buf[MAXLINE], str[INET_ADDRSTRLEN];
 18        socklen_t clilen;
 19        struct pollfd client[OPEN_MAX];        //文件描述符与事件集合
 20        struct sockaddr_in cliaddr, servaddr;
 21        listenfd = Socket(AF_INET, SOCK_STREAM, 0);
 22        bzero(&servaddr, sizeof(servaddr));
 23        servaddr.sin_family = AF_INET;
 24        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
 25        servaddr.sin_port = htons(SERV_PORT);
 26        Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
 27        Listen(listenfd, 20);
 28         //初始化poll()的参数fds
 29        client[0].fd = listenfd;
 30        client[0].events = POLLRDNORM;    //设置listenfd监听普通读事件
 31        for (i = 1; i < OPEN_MAX; i++)
 32            client[i].fd = -1;         //将client[]中其余元素的fd成员初始化为-1
 33        maxi = 0;                     //记录client[]数组有效元素中最大元素下标
 34        //使用poll()机制循环检测文件描述符集合
 35         for (;;) {
 36            nready = poll(client, maxi + 1, -1);    //阻塞等待请求到达
 37             //通过listenfd状态判断是否有客户端连接请求，如有则建立连接
 38            if (client[0].revents & POLLRDNORM) {
 39                clilen = sizeof(cliaddr);
 40                connfd = Accept(listenfd,(struct sockaddr *)&cliaddr,&clilen);
 41                printf("received from %s at PORT %d\n",
 42                    inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
 43                    ntohs(cliaddr.sin_port));
 44                 //将accept返回的connfd存放到client[]中的空闲位置
 45                for (i = 1; i < OPEN_MAX; i++){
 46                    if (client[i].fd < 0) {
 47                        client[i].fd = connfd;
 48                        break;
 49                    }
 50                 }
 51                if (i == OPEN_MAX)
 52                    perr_exit("too many clients");
 53                client[i].events = POLLRDNORM;     //设置刚刚返回的connfd，监控读事件
 54                if (i > maxi)                    //更新client[]中最大元素下标
 55                    maxi = i;
 56                if (--nready <= 0)                 //若无就绪事件,回到poll阻塞
 57                    continue;
 58            }
 59             //检测client[]，处理有就绪事件的文件描述符
 60            for (i = 1; i <= maxi; i++){
 61                if ((sockfd = client[i].fd) < 0)
 62                    continue;
 63                if (client[i].revents & (POLLRDNORM | POLLERR)) {
 64                    if ((n = Read(sockfd, buf, MAXLINE)) < 0) {
 65                         //比较errno，若为RST则表示连接中断
 66                        if (errno == ECONNRESET){
 67                            printf("client[%d] aborted connection\n", i);
 68                            Close(sockfd);
 69                            client[i].fd = -1;
 70                        }
 71                        else
 72                            perr_exit("read error");
 73                    }
 74                    else if (n == 0) {//连接由客户端关闭
 75                        printf("client[%d] closed connection\n", i);
 76                        Close(sockfd);
 77                        client[i].fd = -1;
 78                    }
 79                    else {//若成功读取数据，则对数据进行操作
 80                        for (j = 0; j < n; j++)
 81                            buf[j] = toupper(buf[j]);
 82                        Writen(sockfd, buf, n);
 83                    }
 84                     //当就绪文件描述符数量为0时，终止循环
 85                    if (--nready <= 0)
 86                        break; 
 87                }
 88            }
 89        }
 90        return 0;
 91    }

poll_c.c //客户端

 30    #include <stdio.h>
 31    #include <string.h>
 32    #include <unistd.h>
 33    #include <netinet/in.h>
 34    #include "wrap.h"
 35    #define MAXLINE 80
 36    #define SERV_PORT 8000
 37    int main()
 38    {
 39        struct sockaddr_in servaddr;
 40        char buf[MAXLINE];
 41        int sockfd, n;
 42        sockfd = Socket(AF_INET, SOCK_STREAM, 0);
 43        bzero(&servaddr, sizeof(servaddr));
 44        servaddr.sin_family = AF_INET;
 45        inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
 46        servaddr.sin_port = htons(SERV_PORT);
 47        Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
 48        while (fgets(buf, MAXLINE, stdin) != NULL) {
 49            Write(sockfd, buf, strlen(buf));
 50            n = Read(sockfd, buf, MAXLINE);
 51            if (n == 0)
 52                printf("the other side has been closed.\n");
 53            else
 54                Write(STDOUT_FILENO, buf, n);
 55        }
 56        Close(sockfd);
 57        return 0;
 58    }

分别使用以下语句编译服务器端程序与客户端程序：

gcc poll_s.c wrap.c -o server
gcc poll_c.c wrap.c -o client

程序编译完成后，先执行服务器程序，打开服务器，之后在一个终端运行客户端程序（记为客户端1），并在该终端中输入客户端需要发送的数据，此时客户端与服务器端中打印的信息分别如下：

客户端1：

hello
HELLO

服务器端：

received from 127.0.0.1 at PORT 60315

打开新的终端，在该终端中再次运行客户端程序（记为客户端2），并输入要发送的数据，此时终端2与服务器端中打印的信息分别如下：

客户端2：

itheima
ITHEIMA

服务器端：

received from 127.0.0.1 at PORT 53187
received from 127.0.0.1 at PORT 53191

由程序执行结果可知，案例4实现成功。