Linux网络编程 -- poll实现多路IO转接服务器

server.c

#include <poll.h>
#include <stdio.h>
#include <errno.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#include "wrap.h"

#define OPEN_MAX 1024
#define SERV_PORT 8888

int main()
{
    ssize_t n;
    int opt = 1;
    int i, j, maxi;
    int nready;               //接收poll返回值, 记录满足监听事件的fd个数
    int listenfd, connfd, sockfd;
    char buf[BUFSIZ], clie_IP[INET_ADDRSTRLEN];

    struct sockaddr_in clie_addr, serv_addr;
    socklen_t clie_addr_len;

    struct pollfd client[OPEN_MAX];


    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family= AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port= htons(SERV_PORT);

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

    client[0].fd = listenfd;    //要监听的第一个文件描述符listenfd 存入client[0]
    client[0].events = POLLIN;  //listenfd监听读事件
    maxi = 0;                   //client[]数组有效元素中最大元素下标

    for (i = 1; i < OPEN_MAX; ++i)
    {
        client[i].fd = -1;     //将存放客户端的文件描述符的数组初始化为 -1
    }

    while (1)
    {
        nready = poll(client, maxi+1, -1);  //阻塞监听是否有客户端连接请求

        //listenfd有读事件就绪->有新的客户端需要连接
        if (client[0].revents & POLLIN)     
        {
            clie_addr_len = sizeof(clie_addr);
            //接收客户端请求 此时Accept 不会阻塞
            connfd = Accept(listenfd, (struct sockaddr *)&clie_addr, &clie_addr_len);
            printf("received from %s at PORT %d\n",
                    inet_ntop(AF_INET, &clie_addr.sin_addr, clie_IP, sizeof(clie_IP)),
                    ntohs(clie_addr.sin_port));

            for (i = 1; i < OPEN_MAX; ++i)
            {
                if (client[i].fd < 0)
                {
                    client[i].fd = connfd;  //找到client[]中空闲的位置,存放accept返回的connfd
                    break;
                }
            }

            if (OPEN_MAX == i)
            {
                perr_exit("用户连接量过大");
            }
            client[i].events = POLLIN;      //设置刚刚返回的connfd,监听读事件

            if (i > maxi)
            {
                maxi = i;                   //更新client[]中最大元素下标
            }
            if (--nready <= 0)
            {
                continue;                   //没有更多就绪事件时,继续回到poll阻塞
            }
        }

        //前面的if没满足,说明没有listenfd满足. 检测client[] 看是哪个connfd就绪
        for (i = 1; i <= maxi; ++i)     //注意等号 临界条件
        {
            sockfd = client[i].fd;
            if (sockfd < 0)
            {
                continue;
            }

            if (client[i].revents & POLLIN)
            {
                n = Read(sockfd, buf, BUFSIZ);
                if (n < 0)
                {
                    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 (0 == n)    //说明客户端先关闭链接
                {
                    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]);
                    }

                    Write(sockfd, buf, n);
                }

                if (--nready <= 0)
                {
                    break;
                }
            }
        }
    }

    Close(listenfd);

    return 0;
}

wrap.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>

//输出错误信息并退出
void perr_exit(const char *str)
{
    perror(str);
    exit(-1);
}    

//创建套接字 带出错处理
int Socket(int family, int type, int protocol)
{
    int n;

    n = socket(family, type, protocol);
    if (n < 0)
    {
        perr_exit("socket error");
    }

    return n;
}


int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
    int n;

    n = bind(fd, sa, salen);
    if (n < 0)
    {
        perr_exit("bing error");
    }

    return n;
}

int Listen(int fd, int backlog)
{
    int n;

    n = listen(fd, backlog);
    if (n < 0)
    {
        perr_exit("listen error");
    }

    return n;
}

int Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
    int n;

    n = connect(fd, sa, salen);
    if (n < 0)
    {
        perr_exit("connect error");
    }

    return n;
}

int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
    int n;

again:
    n = accept(fd, sa, salenptr);
    if (n < 0)
    {
        if (errno == ECONNABORTED || errno == EINTR)
        {
            goto again;
        }
        else
        {
            perr_exit("accept error");
        }
    }

    return n;
}

ssize_t Read(int fd, void *ptr, size_t nbytes)
{
    ssize_t n;

again:
    n = read(fd, ptr, nbytes);
    if (-1 == n)
    {
        if (EINTR == errno)
        {
            goto again;
        }
        else
        {
            return -1;
        }
    }

    return n;
}

ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
    ssize_t n;

again:
    n = write(fd, ptr, nbytes);
    if (-1 == n)
    {
        if (EINTR == errno)
        {
            goto again;
        }
        else
        {
            return -1;
        }
    }

    return n;
}

int Close(int fd)
{
    int n;

    n = close(fd);
    if (-1 == n)
    {
        perr_exit("close error");
    }

    return n;
}