多路IO複用--poll實現

函數參數說明

 int poll(struct pollfd *fds, nfds_t nfds, int timeout);
 struct pollfd {
               int   fd;         /* file descriptor */
               short events;     /* requested events */
               short revents;    /* returned events */
           };
           
Instructions on Linux: poll() performs a similar task to select(2): it waits for one of a set of file descriptors to become ready to perform I/O.
	POLLIN			普通或帶外優先數據可讀,即POLLRDNORM | POLLRDBAND
	POLLRDNORM		數據可讀
	POLLRDBAND		優先級帶數據可讀
	POLLPRI 		高優先級可讀數據
	POLLOUT			普通或帶外數據可寫
	POLLWRNORM		數據可寫
	POLLWRBAND		優先級帶數據可寫
	POLLERR 		發生錯誤
	POLLHUP 		發生掛起
	POLLNVAL 		描述字不是一個打開的文件

	nfds 			監控數組中有多少文件描述符需要被監控
timeout 		毫秒級等待
		-1：阻塞等，#define INFTIM -1 				Linux中沒有定義此宏
		=0：立即返回，不阻塞進程
		>0：等待指定毫秒數，如當前系統時間精度不夠毫秒，向上取值
		
如果不再監控某個文件描述符時，可以把pollfd中，fd設置爲-1，poll不再監控此pollfd，下次返回時，把revents設置爲0

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>
#define MAXLINE     80
#define SERV_PORT   6666
#define OPEN_MAX    1024

int main(int argc, char *argv[])
{
    int listenfd = 0;
    int connfd = 0;
    int sockfd = 0;
    int nready;
    char buf[MAXLINE],str[INET_ADDRSTRLEN];
    struct pollfd client[OPEN_MAX];

    listenfd = Socket(AF_INET,SOCK_STREAM,0);
    int opt = 1;
    setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
    struct sockaddr_in servaddr;
    bzero(&servaddr,sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(SERV_PORT);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    Bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr));
    Listen(listenfd,128);

    memset(&client,-1,OPEN_MAX);//用-1初始化client[].fd裏剩下元素

    client[0].fd = listenfd;
    client[0].events = POLLRDNORM;//listenfd 監聽普通讀事件
    int i = 0;
    nfds_t maxi = 0;   //client[]數組有效元素中最大元素下標
    for(;;)
    {
        nready = poll(client, maxi + 1, -1); //阻塞
        if(client[0].revents & POLLRDNORM)      //有客戶端鏈接請求
        {
            struct sockaddr_in clienaddr;
            ssize_t cliensize = sizeof(clienaddr);
            bzero(&clienaddr,sizeof(clienaddr));
            connfd = Accept(listenfd,(struct sockaddr *)&clienaddr,&cliensize);
            strcpy(str,inet_ntop(AF_INET,&clienaddr.sin_addr,str,sizeof(str)));
            printf("received from %s at port %d\n",str,ntohs(clienaddr.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;
            }
            if(--nready <= 0)
            {
                continue;
            }
        }
        for(i = 1; i <= maxi; i++)
        {
            sockfd = client[i].fd;
            if(sockfd < 0)
            {
                continue;
            }
            short int flag = POLLRDNORM | POLLERR;
            printf("client[%d].revents = 0x%x,flag = 0x%x,revents&flag = 0x%x\n",i,
                   client[i].revents,flag,(client[i].revents)&flag);
            if(client[i].revents & (POLLRDNORM | POLLERR))
            {
                printf("--------------------\n");
                memset(buf,0,sizeof(buf));
                ssize_t n = Read(sockfd,buf,MAXLINE);
                if(n < 0)
                {
                    if(errno == ECONNRESET) //當收到 RST標誌時
                    {
                        printf("client[%d] aborted connection\n",i);
                        Close(sockfd);
                        client[i].fd = -1;
                    }
                    else
                    {
                        perr_exit("read error");
                    }
                }
                else if(n == 0)
                {
                    printf("client[%d] closed connection\n",i);
                    Close(sockfd);
                    client[i].fd = -1;
                }
                else
                {
                    struct sockaddr_in sa;
                    int len = sizeof(sa);
                    if(!getpeername(sockfd, (struct sockaddr *)&sa, &len))
                    {
                        printf( "%s :%d-->%s\n", inet_ntoa(sa.sin_addr),ntohs(sa.sin_port),buf);
                    }
                    Write(sockfd,buf,n);//回射客戶端
                }
                if(--nready <= 0)
                {
                    break;
                }
            }
        }
    }
    return 0;
}