关于epoll的示例

下午研究了一下epoll，参考了以下的博客综合写了一个例子。

http://blog.csdn.net/ljx0305/article/details/4065058

这篇文章中有一些和我从man上面查到的不相符合的地方，特此指出。

1)关于epoll_create

这个函数的size参数已经器用。更推荐使用的是epoll_create1(0)来代替普通的用法。另外epoll_create1(EPOLLCLOEXEC)表示生成的epoll fd具有“执行后关闭”特性。

2) epoll_ctl

这个函数在指定EPOLL_CTL_DEL时，为了与linux内核2.6.9之前相兼容，还是要让最后的参数指向一个非null变量。

另外，events.EPOLLONESHOT确实表示只监听一次事件，但是当我们监听完这次事件之后，如果还需要继续监听这个fd的话，只需要使用EPOLL_CTL_MOD修改event。

3) 关于实例代码

实例代码我运行了一下，感觉有点问题。后来参考了这篇文章（http://blog.chinaunix.net/uid-20583479-id-1920065.html）的说法，发现修改之后就可以实行了。关键点有这么几点，

1. EPOLLET其实比EPOLLLT高级，所以优先用。

2. 用EPOLLET的时候，按照man的讲法，是必须要使用非阻塞fd，另外，必须要考虑EAGAIN。

先上服务器代码

#include <iostream>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

using namespace std;

#define MAXLINE 5
#define OPEN_MAX 100
#define LISTENQ 20
#define SERV_PORT 5000
#define INFTIM 1000

void setnonblocking(int sock)
{
    int opts;
    opts=fcntl(sock,F_GETFL);
    if(opts<0)
    {
        perror("fcntl(sock,GETFL)");
        return;
    }
    opts = opts|O_NONBLOCK;
    if(fcntl(sock,F_SETFL,opts)<0)
    {
        perror("fcntl(sock,SETFL,opts)");
        return;
    }
}

void CloseAndDisable(int sockid, epoll_event ee)
{
    close(sockid);
    ee.data.fd = -1;
}

int main()
{
    int i, maxi, listenfd, connfd, sockfd,epfd,nfds, portnumber;
    char line[MAXLINE];
    socklen_t clilen;

    portnumber = 5000;

    //声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件

    struct epoll_event ev,events[20];
    //生成用于处理accept的epoll专用的文件描述符

    epfd=epoll_create(256);
    struct sockaddr_in clientaddr;
    struct sockaddr_in serveraddr;
    listenfd = socket(AF_INET, SOCK_STREAM, 0);

    memset(&serveraddr, 0, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serveraddr.sin_port=htons(portnumber);

    // bind and listen
    bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));
    listen(listenfd, LISTENQ);

    //设置与要处理的事件相关的文件描述符
    ev.data.fd=listenfd;
    //设置要处理的事件类型
    ev.events=EPOLLIN|EPOLLET;
    //ev.events=EPOLLIN;

    //注册epoll事件
    epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);

    maxi = 0;

    int bOut = 0;
    for ( ; ; )
    {
        if (bOut == 1)
            break;
        //等待epoll事件的发生

        nfds=epoll_wait(epfd,events,20,-1);
        //处理所发生的所有事件
        cout << "\nepoll_wait returns\n";

        for(i=0;i<nfds;++i)
        {
            if(events[i].data.fd==listenfd)//如果新监测到一个SOCKET用户连接到了绑定的SOCKET端口，建立新的连接。
            {
                connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen);
                if(connfd<0){
                    perror("connfd<0");
                    return (1);
                }
                

                char *str = inet_ntoa(clientaddr.sin_addr);
                cout << "accapt a connection from " << str << endl;
                //设置用于读操作的文件描述符

                setnonblocking(connfd);
                ev.data.fd=connfd;
                //设置用于注测的读操作事件

                ev.events=EPOLLIN | EPOLLET;
                //ev.events=EPOLLIN;

                //注册ev
                epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);
            }
            else if(events[i].events & EPOLLIN)//如果是已经连接的用户，并且收到数据，那么进行读入。
            {
                cout << "EPOLLIN" << endl;
                if ( (sockfd = events[i].data.fd) < 0)
                    continue;

                char * head = line;
                int recvNum = 0;
                int count = 0;
                bool bReadOk = false;
                while(1)
                {
                    // 确保sockfd是nonblocking的
                    recvNum = recv(sockfd, head + count, MAXLINE, 0);
                    if(recvNum < 0)
                    {
                        if(errno == EAGAIN)
                        {
                            // 由于是非阻塞的模式,所以当errno为EAGAIN时,表示当前缓冲区已无数据可读
                            // 在这里就当作是该次事件已处理处.
                            bReadOk = true;
                            break;
                        }
                        else if (errno == ECONNRESET)
                        {
                                // 对方发送了RST
                                CloseAndDisable(sockfd, events[i]);
                                cout << "counterpart send out RST\n";
                                break;
                         }
                        else if (errno == EINTR)
                        {
                            // 被信号中断
                            continue;
                        }
                        else
                        {
                            //其他不可弥补的错误
                            CloseAndDisable(sockfd, events[i]);
                            cout << "unrecovable error\n";
                            break;
                        }
                   }
                   else if( recvNum == 0)
                   {
                        // 这里表示对端的socket已正常关闭.发送过FIN了。
                        CloseAndDisable(sockfd, events[i]);
                        cout << "counterpart has shut off\n";
                        break;
                   }

                   // recvNum > 0
                    count += recvNum;
                   if ( recvNum == MAXLINE)
                   {
                       continue;   // 需要再次读取
                   }
                   else // 0 < recvNum < MAXLINE
                   {
                       // 安全读完
                       bReadOk = true;
                       break; // 退出while(1),表示已经全部读完数据
                   }
                }

                if (bReadOk == true)
                {
                    // 安全读完了数据
                    line[count] = '\0';

                    cout << "we have read from the client : " << line;
                    //设置用于写操作的文件描述符

                    ev.data.fd=sockfd;
                    //设置用于注测的写操作事件

                    ev.events = EPOLLOUT | EPOLLET;
                    //修改sockfd上要处理的事件为EPOLLOUT

                    epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
                }
            }
            else if(events[i].events & EPOLLOUT) // 如果有数据发送
            {
                const char str[] = "hello from epoll : this is a long string which may be cut by the net\n";
                memcpy(line, str, sizeof(str));
                cout << "Write " << line << endl;
                sockfd = events[i].data.fd;

                bool bWritten = false;
                int writenLen = 0;
                int count = 0;
                char * head = line;
                while(1)
                {
                        // 确保sockfd是非阻塞的
                        writenLen = send(sockfd, head + count, MAXLINE, 0);
                        if (writenLen == -1)
                        {
                            if (errno == EAGAIN)
                            {
                                // 对于nonblocking 的socket而言，这里说明了已经全部发送成功了
                                bWritten = true;
                                break;
                            }
                            else if(errno == ECONNRESET)
                            {
                                // 对端重置,对方发送了RST
                                CloseAndDisable(sockfd, events[i]);
                                cout << "counterpart send out RST\n";
                                break;
                            }
                            else if (errno == EINTR)
                            {
                                // 被信号中断
                                continue;
                            }
                            else
                            {
                                // 其他错误
                            }
                        }

                        if (writenLen == 0)
                        {
                            // 这里表示对端的socket已正常关闭.
                            CloseAndDisable(sockfd, events[i]);
                            cout << "counterpart has shut off\n";
                            break;
                        }

                        // 以下的情况是writenLen > 0
                        count += writenLen;
                        if (writenLen == MAXLINE)
                        {
                            // 可能还没有写完
                            continue;
                        }
                        else // 0 < writenLen < MAXLINE
                        {
                            // 已经写完了
                            bWritten = true;
                            break; // 退出while(1)
                        }
                }

                if (bWritten == true)
                {
                    //设置用于读操作的文件描述符
                    ev.data.fd=sockfd;

                    //设置用于注测的读操作事件
                    ev.events=EPOLLIN | EPOLLET;

                    epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
                }
            }
        }
    }
    return 0;
}

注意以下几点：

1. #14设定为5是故意的，为了测试后续的输入和输出

2. 整个服务器的功能是先读取字符串，然后向对方写内容。

3. #110处设置通信socket为非阻塞。

4. 注意#130~#183的读干净缓冲区的read。

5. 注意#213~#264的完全写完所需要传送内容的write。

6. 关于EPOLLET，epoll_wait只有在socket状态发生变化的时候才会返回。所以要对fd进行循环accept,read, write;知直到socket的缓冲区空（read, accept)或者填满(write)为止。

 7. 下面是客户端实验代码

int
main(int argc, char **argv)
{
    int                    sockfd;
    char                recvline[MAXLINE + 1];
    struct sockaddr_in    servaddr;

    if (argc != 2)
        err_quit("usage: a.out <IPaddress>");

    if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
        err_sys("socket error");

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port   = htons(5000);   
    if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0)
        err_quit("inet_pton error for %s", argv[1]);

    if (connect(sockfd, (SA *) &servaddr, sizeof(servaddr)) < 0)
        err_sys("connect error");

    char input[100];
    while (fgets(input, 100, stdin) != EOF)
    {
        write(sockfd, input, strlen(input));

        int n = 0;
        int count = 0;
        while (1)
        {
            n = read(sockfd, recvline + count, MAXLINE);
            if (n == MAXLINE)
            {
                count += n;
                continue;
            }
            else 
                break;
        }
        printf("%s\n", recvline);
    }
    exit(0);
}