1 poll函数原型
#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
/**
功能：实现多路IO复用。
返回值：返回实际的满足事件的个数，负数为poll监听出错。
参1：fds，通常传的是一个pollfd类型的数组。
struct pollfd {
int fd; /* 文件描述符 */
short events; /* 监控的事件 */
short revents; /* 监控事件中满足条件返回的事件 */
};
其中事件宏events和revents的可能是：
POLLIN 普通或带外优先数据可读,即POLLRDNORM | POLLRDBAND
POLLRDNORM 数据可读
POLLRDBAND 优先级带数据可读
POLLPRI 高优先级可读数据
POLLOUT 普通或带外数据可写
POLLWRNORM 数据可写
POLLWRBAND 优先级带数据可写
POLLERR 发生错误
POLLHUP 发生挂起
POLLNVAL 描述字不是一个打开的文件
参2：fds是实际的监听(连接)个数，即client[]数组有效元素中最大元素下标，例如数组大小是目前只有3个连接，就传3，有1024个连接就传1024。并非传数组大小。
参3：超时返回，单位毫秒。其中timeout取不用值时的情况：
-1：阻塞等，#define INFTIM -1，Linux中没有定义此宏。
0：立即返回，不阻塞进程。
>0：等待指定毫秒数，如当前系统时间精度不够毫秒，向上取值。
如果不再监控某个文件描述符时，可以把pollfd中，fd设置为-1，poll不再监控此pollfd，下次返回时，把revents设置为0。
**/
2 思路剖析图
简单说几句，服务器通过poll函数，将lfd放在预先定义的数组第一个元素中，然后进行监听事件，当客户端进行连接时，poll将每个通信的描述符cfd放在struct pollfd数组即可。
3 poll的server代码实战
poll很简单，关于select和poll，epoll的优缺点在讲select时已经讲了。这里只回述poll，poll的缺点是不跨平台，不再局限与1024个连接，并且比select使用简单很多。但是实际上poll的并发数也并非很强大，所以也不建议深入。本篇讲完将重点讲述epoll，非常强大的IO复用函数，几乎所有Linux的并非都离不开它。
poll的实战代码。
poll.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 <ctype.h>
#include "wrap.h"/* 封装这Socket，Bind这些函数的出错处理 */
#define MAXLINE 80
#define SERV_PORT 8888
#define OPEN_MAX 1024/* poll的最大连接数，即数组大小 */
int main(){
int i, j, maxi, lfd, cfd, sockfd;/* maxi是实际的监听(连接)个数 */
ssize_t n;
char buf[MAXLINE], str[INET_ADDRSTRLEN];
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
struct pollfd client[OPEN_MAX];
int nready; /*接收poll返回值, 记录满足监听事件的fd个数*/
lfd = Socket(AF_INET, SOCK_STREAM, 0);
int opt = 1;
setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(lfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
Listen(lfd, 128);
client[0].fd = lfd; /* 要监听的第一个文件描述符 存入client[0]*/
client[0].events = POLLIN; /* lfd监听普通读事件 */
for (i = 1; i < OPEN_MAX; i++){ /* 用-1初始化client[]里剩下元素 0也是文件描述符,不能用 */
client[i].fd = -1;
}
maxi = 0; /* maxi是实际的监听(连接)个数，即client[]数组有效元素中最大元素下标 */
while(1)
{
nready = poll(client, maxi + 1, -1); /* 阻塞监听是否有客户端链接请求 */
if(nready < 0){
perr_exit("poll error");
}
/* lfd事件 */
if (client[0].revents & POLLIN) { /* lfd有读事件就绪，&实际上与==一样，只不过这里poll使用位与更好因为这样不需要记住具体数字，与revents定义的宏有关 */
clilen = sizeof(cliaddr);
cfd = Accept(lfd, (struct sockaddr *)&cliaddr, &clilen);/* 接收客户端请求 Accept 不会阻塞 */
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 = cfd; /* 往client[]数组空闲的位置添加cfd */
client[i].events = POLLIN; /* 设置cfd为监控读事件 */
break;
}
}
if (i > maxi){
maxi = i; /* 更新client[]中最大元素下标 */
}
if (i == OPEN_MAX){ /* 达到了最大客户端数 */
perr_exit("too many clients");
}
if (--nready == 0){
continue; /* 没有更多就绪事件时,继续回到poll阻塞 */
}
}
/* 通信事件 */
for (i = 1; i <= maxi; i++) /* 前面的if没满足,说明没有listenfd满足. 检测client[] 看是那个connfd就绪 */
{
if ((sockfd = client[i].fd) < 0)
{
continue;
}
if (client[i].revents & POLLIN)
{
if ((n = Read(sockfd, buf, MAXLINE)) < 0) {
/* connection reset by client */
if (errno == ECONNRESET) { /* 收到RST中断重置标志，需要断开连接 */
printf("client[%d] aborted connection\n", i);
Close(sockfd);
client[i].fd = -1; /* poll中不监控该文件描述符,直接置为-1即可,不用像select中那样移除 */
} else{
perr_exit("read error");
}
} else if (n == 0) { /* 说明客户端先关闭链接,同样关闭连接 */
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){/* 不能写在if外，即& POLLIN的if，否则第一次没有通信也--nready，会导致有问题 */
break;
}
}
}
}
return 0;
}
经过封装出错处理的wrap.h和wrap.c。
#ifndef __WRAP_H_
#define __WRAP_H_
void perr_exit(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
int Bind(int fd, const struct sockaddr *sa, socklen_t salen);
int Connect(int fd, const struct sockaddr *sa, socklen_t salen);
int Listen(int fd, int backlog);
int Socket(int family, int type, int protocol);
ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Write(int fd, const void *ptr, size_t nbytes);
int Close(int fd);
ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n);
ssize_t my_read(int fd, char *ptr);
ssize_t Readline(int fd, void *vptr, size_t maxlen);
#endif
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
void perr_exit(const char *s)
{
perror(s);
exit(-1);
}
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
int n;
again:
if ((n = accept(fd, sa, salenptr)) < 0) {
if ((errno == ECONNABORTED) || (errno == EINTR))
goto again;
else
perr_exit("accept error");
}
return n;
}
int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
int n;
if ((n = bind(fd, sa, salen)) < 0)
perr_exit("bind error");
return n;
}
int Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
int n;
if ((n = connect(fd, sa, salen)) < 0)
perr_exit("connect error");
return n;
}
int Listen(int fd, int backlog)
{
int n;
if ((n = listen(fd, backlog)) < 0)
perr_exit("listen error");
return n;
}
int Socket(int family, int type, int protocol)
{
int n;
if ((n = socket(family, type, protocol)) < 0)
perr_exit("socket error");
return n;
}
ssize_t Read(int fd, void *ptr, size_t nbytes)
{
ssize_t n;
again:
if ( (n = read(fd, ptr, nbytes)) == -1) {
if (errno == EINTR)
goto again;
else
return -1;
}
return n;
}
ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
ssize_t n;
again:
if ( (n = write(fd, ptr, nbytes)) == -1) {
if (errno == EINTR)
goto again;
else
return -1;
}
return n;
}
int Close(int fd)
{
int n;
if ((n = close(fd)) == -1)
perr_exit("close error");
return n;
}
/*参三: 应该读取的字节数*/
ssize_t Readn(int fd, void *vptr, size_t n)
{
size_t nleft; //usigned int 剩余未读取的字节数
ssize_t nread; //int 实际读到的字节数
char *ptr;
ptr = vptr;
nleft = n;
while (nleft > 0) {
if ((nread = read(fd, ptr, nleft)) < 0) {
if (errno == EINTR)
nread = 0;
else
return -1;
} else if (nread == 0)
break;
nleft -= nread;
ptr += nread;
}
return n - nleft;
}
ssize_t Writen(int fd, const void *vptr, size_t n)
{
size_t nleft;
ssize_t nwritten;
const char *ptr;
ptr = vptr;
nleft = n;
while (nleft > 0) {
if ( (nwritten = write(fd, ptr, nleft)) <= 0) {
if (nwritten < 0 && errno == EINTR)
nwritten = 0;
else
return -1;
}
nleft -= nwritten;
ptr += nwritten;
}
return n;
}
static ssize_t my_read(int fd, char *ptr)
{
static int read_cnt;
static char *read_ptr;
static char read_buf[100];
if (read_cnt <= 0) {
again:
if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {
if (errno == EINTR)
goto again;
return -1;
} else if (read_cnt == 0)
return 0;
read_ptr = read_buf;
}
read_cnt--;
*ptr = *read_ptr++;
return 1;
}
ssize_t Readline(int fd, void *vptr, size_t maxlen)
{
ssize_t n, rc;
char c, *ptr;
ptr = vptr;
for (n = 1; n < maxlen; n++) {
if ( (rc = my_read(fd, &c)) == 1) {
*ptr++ = c;
if (c == '\n')
break;
} else if (rc == 0) {
*ptr = 0;
return n - 1;
} else
return -1;
}
*ptr = 0;
return n;
}
编译命令：
gcc -g -Wall poll.c wrap.c -o poll #注意不能添加wrap.h进去编译，否则会出现socklen_t，ssize_t未定义，我们只需要让gcc自动在当前文件寻找头文件即可。
结果可以看到，我开了5个连接，都能成功通信，并且关闭了1和4后，我在其它连接(赖得再放图了)也能继续通信，说明代码是OK的。
3840
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
