Knowledge Sharing

linux网络编程-多路I/O转接服务器:poll

发表于 更新于 分类于

poll

为拓展监听的上限，可以使用poll

poll函数原型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);

/*
fds				监听的文件描述符数组
nfds 			监控数组中有多少文件描述符需要被监控    
timeout 		毫秒级等待
    -1：阻塞等，#define INFTIM -1 		Linux中没有定义此宏
    0：立即返回，不阻塞进程
    >0：等待指定毫秒数，如当前系统时间精度不够毫秒，向上取值
返回值:返回满足对应监听事件的文件描述符总个数;
*/

struct pollfd {
    int fd; /* 待监听的文件描述符 */
    short events; /*待监听的文件描述符对应的监听事件->POLLIN,POLLOUT,POLLERR*/
    short revents; /*returned events:传入时给0,如果满足对应事件的话被置为非零->POLLIN,POLLOUT,POLLERR*/
};

POLLIN			普通或带外优先数据可读,即POLLRDNORM | POLLRDBAND
POLLRDNORM		数据可读
POLLRDBAND		优先级带数据可读
POLLPRI 		高优先级可读数据
POLLOUT			普通或带外数据可写
POLLWRNORM		数据可写
POLLWRBAND		优先级带数据可写
POLLERR 		发生错误
POLLHUP 		发生挂起
POLLNVAL 		描述字不是一个打开的文件

如果不再监控某个文件描述符时，可以把pollfd中，fd设置为-1，poll不再监控此pollfd，下次返回时，把revents设置为0。

poll实现服务器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
/* server.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <poll.h>
#include <errno.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 9527
//可以突破select监听的1024限制
#define OPEN_MAX 1024 

int main(int argc, char *argv[])
{
	int i, j, maxi, listenfd, connfd, sockfd;
    /*poll函数返回值*/
	int nready;
	ssize_t n;
	char buf[MAXLINE], str[INET_ADDRSTRLEN];
	socklen_t clilen;
    /*创建结构体数组*/	
	struct pollfd client[OPEN_MAX]; 
    /*创建客户端地址结构和服务器地址结构*/
	struct sockaddr_in cliaddr, servaddr;

    /*得到监听套接字listenFd*/
	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, (struct sockaddr *)&servaddr, sizeof(servaddr));
	Listen(listenfd, 20);

	/*初始化第一个pollfd为监听套接字*/
	client[0].fd = listenfd;
	client[0].events = POLLRDNORM; 					/* listenfd监听普通读事件 */

	for (i = 1; i < OPEN_MAX; i++)
		client[i].fd = -1; 							/* 用-1初始化client[]里剩下元素 */
	maxi = 0; 										/* client[]数组有效元素中最大元素下标 */

	for ( ; ; ) {
        /*nready是有多少套接字有POLLIN请求*/
		nready = poll(client, maxi+1, -1); 			/* 阻塞 */
        /*如果listenFd的revents有POLLIN请求,则调用Accept函数得到connectFd*/
		if (client[0].revents & POLLRDNORM) { 		/* 有客户端连接请求 */
			clilen = sizeof(cliaddr);
			connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);
			printf("received from %s at PORT %d\n",
					inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
					ntohs(cliaddr.sin_port));
			for (i = 1; i < OPEN_MAX; i++) {
				if (client[i].fd < 0) {
					client[i].fd = connfd; 	/* 找到client[]中空闲的位置，存放accept返回的connfd */
					break;
				}
			}

			if (i == OPEN_MAX)
				perr_exit("too many clients");

			client[i].events = POLLRDNORM; 		/* 设置刚刚返回的connfd，监控读事件 */
			if (i > maxi)
				maxi = i; 						/* 更新client[]中最大元素下标 */
			if (--nready <= 0)
				continue; 						/* 没有更多就绪事件时,继续回到poll阻塞 */
		}
        /*开始从1遍历pollfd数组*/
		for (i = 1; i <= maxi; i++) { 			/* 检测client[] */
            /*到结尾了或者有异常*/
			if ((sockfd = client[i].fd) < 0)
				continue;
            /*第i个客户端有连接请求,进行处理*/
			if (client[i].revents & (POLLRDNORM | POLLERR)) {
				if ((n = Read(sockfd, buf, MAXLINE)) < 0) {
                    /*出错时进一步判断errno*/
					if (errno == ECONNRESET) { /* 当收到 RST标志时 */
						/* connection reset by client */
						printf("client[%d] aborted connection\n", i);
						Close(sockfd);
						client[i].fd = -1;
					} else {
						perr_exit("read error");
					}
				} else if (n == 0) {
                    /*read返回0,说明读到了结尾,关闭连接*/
					/* connection closed by client */
					printf("client[%d] closed connection\n", i);
					Close(sockfd);
					client[i].fd = -1;
				} else {
                    /*数据处理*/
					for (j = 0; j < n; j++)
						buf[j] = toupper(buf[j]);
						Writen(sockfd, buf, n);
				}
				if (--nready <= 0)
					break; 				/* no more readable descriptors */
			}
		}
	}
	return 0;
}

poll总结

优点:

  • 自带数组结构, 可以将监听事件集合和返回事件集合分开
  • 可以拓展监听上限, 超出1024的限制

缺点:

  • 不能跨平台, 只适合于Linux系统
  • 无法直接定位到满足监听事件的文件描述符, 编码难度较大