poll_server

poll與select不同在於描述符存儲方式不同和參數類型不同。
1.結構體數組的管理：當每次有需要關心的描述符時，將其放入結構體中，每次有無效的描述符後，將其描述符置-1，下次poll函數會忽略它。當有新的描述符加入時，從頭遍歷結構體，將爲-1的元素設爲要關心的描述符事件狀態。切記：當新的描述符加到結構體數組末尾時要更新關心描述符個數，即poll第二個參數。
2.每次調用poll後，結構體元素revents會存儲就緒事件狀態，當每次重新調用poll之前時，系統會自己設置其爲0，重新監聽關心事件（不需要用戶重新置0）
3.poll中參數不是輸入，輸出型，因此timeout,struct pollfd *fds參數不需重置，nfds看情況（參照第一點），而select函數是輸入輸出類型，每次調用前需重置。

int poll（struct pollfd*fds， nfds_t nfds， int timeout）；

這個結構中fd表示文件描述符，events表示請求檢測的事件，revents表示檢測之後返回的事件，如果當某個文件描述符有狀態變化時，revents的值就不爲空。

struct pollfd結構如下

struct pollfd {
int fd;
short events;
short revents;
};

poll的基本事件都有：
POLLIN:當前有數據可讀 （服務器角度）
POLLOUT:當前有數據可輸出
POLLPRI:當前有緊急數據處理
若fds=-1,則poll()無效。

參數：

fds：存放需要被檢測狀態的Socket描述符；與select不同（select函數在調用之後，會清空檢測socket描述符的數組），每當調用這個函數之後，系統不會清空這個數組，而是將有狀態變化的描述符結構的revents變量狀態變化，操作起來比較方便；
nfds：用於標記數組fds中的struct pollfd結構元素的總數量；

函數返回值：

0：表示數組fds中有socket描述符的狀態發生變化，或可以讀取、或可以寫入、或出錯。並且返回的值表示這些狀態有變化的socket描述符的總數量；此時可以對fds數組進行遍歷，以尋找那些revents不空的socket描述符，然後判斷這個裏面有哪些事件以讀取數據。
=0：表示沒有socket描述符有狀態變化，並且調用超時。
<0：此時表示有錯誤發生，此時全局變量errno保存錯誤碼。

#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <poll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int startup(const char*ip, int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock < 0)
    {
        perror("socket");
        exit(-1);
    }
    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);
    if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    {
        perror("bind");
        exit(-1);
    }
    if(listen(sock, 10) < 0)
    {
        perror("listen");
        exit(-1);
    }
    return sock;
}
static void usage(const char* proc)
{
    printf("%s [local_ip] [local_port]\n", proc);
}
int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        return -1;
    }
    int listen_sock = startup(argv[1], atoi(argv[2]));
    int maxfd = 0;
    struct pollfd evs[2];
    evs[0].fd = listen_sock;//需要監測的文件描述符
    evs[0].events = POLLIN;
    evs[0].revents = 0;
    int timeout = 8000;
    int nums = sizeof(evs)/sizeof(evs[0]);
    struct sockaddr_in client;
    socklen_t len = sizeof(client);
    int i=1;
    for(; i<nums; i++)
    {
        evs[i].fd = -1;
    }
    while(1)
    {
        switch(poll(evs, maxfd+1, timeout))
        {
            case 0:
                printf("timeout...\n");
                break;
            case -1:
                perror("poll");
                break;
            default:
                {
                    for(i=0; i<nums; i++)
                    {//listen_sock的讀事件就緒，獲取客戶端fd
                        if((evs[i].fd == listen_sock) && (evs[i].revents)&POLLIN)
                        {
                            //獲取客戶端
                            int new_sock = accept(listen_sock, (struct sockaddr*)&client, &len);
                            if(new_sock < 0)
                            {//取數據失敗
                                perror("accept");
                                continue;
                            }
                            printf("get new client:[%s:%d]\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
                            //將獲取的客戶端new_sock放入poll結構體數組中，以便poll()監測
                            int j=1;
                            for(; j<nums; j++)
                            {
                                if(evs[j].fd == -1)
                                {//將new_sock添加進去
                                    evs[j].fd = new_sock;
                                    evs[j].events = POLLIN;
                                    evs[j].revents = 0;
                                    break;
                                }
                            }
                            if(j == nums)
                            {
                                close(new_sock);
                            }
                            if(j > maxfd)//更新有效文件描述符個數
                                maxfd = j;
                        }
                        else if((evs[i].fd>0) && (evs[i].revents)&POLLIN)
                        {//其他fd就緒，如：read, write...
                            char buf[1024];
                            ssize_t s = read(evs[i].fd, buf, sizeof(buf)-1);
                            if(s > 0)
                            {//讀成功
                                buf[s] = 0;
                                printf("client say# %s", buf);
                            }
                            //從標準輸入中獲取字符，寫給客戶端
                            ssize_t _s = read(0, buf, sizeof(buf)-1);
                            if(_s > 0)
                            {
                                write(evs[i].fd, buf, strlen(buf));
                            }
                            else if(s == 0)
                            {
                                printf("read done..., break\n");
                                //關閉該文件描述符，獲取其他有效的文件描述符
                                close(evs[i].fd);
                                int k = 1;
                                for(; k < nums; k++)
                                {
                                    if(evs[k].fd != -1 && (k!=i))
                                    {
                                        int tmp = evs[i].fd;
                                        evs[i].fd = evs[k].fd;
                                        evs[k].fd = tmp;
                                    }
                                }
                            }
                            else
                            {
                                perror("read");
                                continue；
                            }
                        }
                    }
            }
            break;
        }
    }
    return 0;
}