poll服务器---多路连接之 poll

1.poll与select不同在于描述符存储方式不同和参数类型不同

• 结构体数组的管理：当每次有需要关心的描述符时，将其放入结构体中，每次有无效的描述符后，将其描述符置-1，下次poll函数会忽略它。当有新的描述符加入时，从头遍历结构体，将为-1的元素设为要关心的描述符事件状态。切记：当新的描述符加到结构体数组末尾时要更新关心描述符个数，即poll第二个参数。
• 每次调用poll后，结构体元素revents会存储就绪事件状态，当每次重新调用poll之前时，系统会自己设置其为0，重新监听关心事件（不需要用户重新置0）

2.poll函数

参数：
fds：存放需要被检测状态的Socket描述符；与select不同（select函数在调用之后，会清空检测socket描述符的数组），每当调用这个函数之后，系统不会清空这个数组，而是将有状态变化的描述符结构的revents变量状态变化，操作起来比较方便；
nfds：用于标记数组fds中的struct pollfd结构元素的总数量
timeout：与select中timeout含义相同，单位是毫秒

struct pollfd结构体：

fd：关心该文件描述符
events：关心该描述符的事件
revents：该描述符就绪的事件

poll的基本事件都有：
POLLIN:当前有数据可读 （服务器角度）
POLLOUT:当前有数据可输出
POLLPRI:当前有紧急数据处理
若fds=-1,则poll()无效。

返回值：

0：表示数组fds中有socket描述符的状态发生变化，或可以读取、或可以写入、或出错。并且返回的值表示这些状态有变化的socket描述符的总数量；此时可以对fds数组进行遍历，以寻找那些revents不空的socket描述符，然后判断这个里面有哪些事件以读取数据。
=0：表示没有socket描述符有状态变化，并且调用超时。
<0：此时表示有错误发生，此时全局变量errno保存错误码。

3.poll的优缺点

优点
（1）poll() 不要求开发者计算最大文件描述符加一的大小。
（2）poll() 在应付大数目的文件描述符的时候相比于select速度更快
（3）它没有最大连接数的限制，原因是它是基于链表来存储的。
缺点
（1）大量的fd的数组被整体复制于用户态和内核地址空间之间，而不管这样的复制是不是有意义。
（2）与select一样，poll返回后，需要轮询pollfd来获取就绪的描述符

4.poll服务器的实现

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

#define SIZE 1024
static void usage(const char* proc)
{
    printf("usage:%s [local_ip] [local_port\n]",proc);
}

int startup(char* ip,int port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock<0){
        perror("socket");
        exit(2);
    }

    struct sockaddr_in client;
    client.sin_family = AF_INET;
    client.sin_port = htons(port);
    client.sin_addr.s_addr = inet_addr(ip);

    if(bind(sock,(struct sockaddr*)&client,sizeof(client))<0){
        perror("bind");
        exit(3);
    }

    if(listen(sock,10)<0){
        perror("bind");
        exit(4);
    }
    return sock;
}

int main(int argc,char* argv[])
{
    if(argc!=3){
        usage(argv[0]);
        return 1;
    }

    int listen_sock = startup(argv[1],atoi(argv[2]));

    struct pollfd pd[SIZE];

    int i=0;
    for(;i<SIZE;++i){
        pd[i].fd=-1;
    }

    pd[0].fd = listen_sock;
    pd[0].events = POLLIN;
    pd[0].revents = 0;
    int timeout = 5000;
    while(1){

    switch(poll(pd,SIZE,timeout)){
        case -1:
            perror("poll");
            break;
        case 0:
            printf("timeout..\n");
            break;
        default:
            {
                i=0;
                for(;i<SIZE;++i){
                    if(i==0 && pd[0].revents & POLLIN){
                        struct sockaddr_in client;
                        socklen_t len = sizeof(client);
                        int new_sock = accept(listen_sock,(struct sockaddr*)&client,&len);
                        if(new_sock<0){
                            perror("accept");
                            exit(5);
                        }
                        printf("get a client:[%s:%d]\n",inet_ntoa(client.sin_addr),\
                                ntohs(client.sin_port));
                        int j=0;
                        for(j=1;j<SIZE;++j){
                            if(pd[j].fd<0){
                                break;
                            }//if
                        }//for
                            if(j==SIZE){
                                printf("pd is full\n");
                                break;
                            }else{
                                pd[j].fd = new_sock;
                                pd[j].events = POLLIN;
                            }//if
                    }else if(i!=0){
                        if(pd[i].revents & POLLOUT){
                            char buf[1024];
                            printf("Please Enter:");
                            fflush(stdout);
                            read(0,buf,sizeof(buf)-1);
                            write(pd[i].fd,buf,strlen(buf)-1);
                            pd[i].events = POLLIN;
                        }else if(pd[i].revents & POLLIN){
                            char msg[1024];
                            ssize_t s = read(pd[i].fd,msg,sizeof(msg)-1);
                            if(s<0){
                                perror("read");
                                exit(6);
                            }else if(s==0){
                                printf("clinet is quit\n");
                                close(pd[i].fd);
                                pd[i].fd = -1;
                            }else{
                                msg[s] = 0;
                                printf("client say:%s",msg);
                                pd[i].events = POLLOUT;
                            }//read
                        }else{
                        }//
                    }//else if
                }//for
            }//default
    }//switch
    }//while
    return 0;
}

客户端

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


static void usage(const char* proc)
{
    printf("usage:%s [local_ip] [local_proc]\n",proc);
}

int main(int argc,char* argv[])
{
    if(argc!=3){
        usage(argv[0]);
        exit(1);
    }

    int sock = socket(AF_INET,SOCK_STREAM,0);   

    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);

    if(connect(sock,(struct sockaddr*)&server,sizeof(server))<0){
        perror("connect");
        exit(2);
    }

    char buf[1024];
    while(1){
        printf("please enter#");
        fflush(stdout);

        int sfd = dup(1);
        close(1);
        dup2(sock,1);
        ssize_t s = read(0,buf,sizeof(buf)-1);  
        printf("%s",buf);
        dup2(sfd,STDOUT_FILENO);

        s = read(sock,buf,sizeof(buf)-1);
        buf[s] = 0;
        printf("server# %s",buf);

    //  ssize_t s = read(0,buf,sizeof(buf)-1);
    //  if(s<0){
    //      perror("read");
    //      exit(3);
    //  }
    //  write(sock,buf,strlen(buf));
    }
    return 0;
}

结果图：