採用epoll實現echo server和client

 echo server，採用epoll模型，先讀後寫

 

#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>
using namespace std;

#define MAXLINE 512
#define OPEN_MAX 100
#define LISTENQ 20
#define SERV_PORT  9876
#define INFTIM 1000

void setnonblocking(int sock)
{
    int opts;
    opts=fcntl(sock,F_GETFL);

    if(opts<0)
    {
        perror("fcntl(sock,GETFL)");
        exit(1);
    }

    opts = opts | O_NONBLOCK;

    if(fcntl(sock,F_SETFL,opts)<0)
    {
        perror("fcntl(sock,SETFL,opts)");
        exit(1);
    }
}




/*
   假如發送端流量大於接收端的流量
   (意思是epoll所在的程序讀比轉發的socket要快),
   由於是非阻塞的socket,那麼send()函數雖然返回,
   但實際緩衝區的數據並未真正發給接收端,
   這樣不斷的讀和發，
   當緩衝區滿後會產生EAGAIN錯誤(參考man send),同時,
   不理會這次請求發送的數據.所以,
   需要封裝socket_send()的函數用來處理這種情況,
   該函數會盡量將數據寫完再返回，返回-1表示出錯。
   在socket_send()內部,當寫緩衝已滿(send()返回-1,且errno爲EAGAIN),
   那麼會等待後再重試.這種方式並不很完美,
   在理論上可能會長時間的阻塞在socket_send()內部,
   但暫沒有更好的辦法.

 */

ssize_t socket_send(int sockfd, const char* buffer, size_t buflen)
{
    ssize_t tmp;
    size_t total = buflen;
    const char *p = buffer;

    while(1)
    {
        tmp = send(sockfd, p, total, 0);
        if(tmp < 0)
        {
            // 當send收到信號時,可以繼續寫,但這裏返回-1.
            if(errno == EINTR)
                //return -1;zxd
                continue;

            // 當socket是非阻塞時,如返回此錯誤,表示寫緩衝隊列已滿,
            // 在這裏做延時後再重試.
            if(errno == EAGAIN)
            {
                usleep(1000);
                continue;
            }

            return -1;
        }

        if((size_t)tmp == total)
            return buflen;

        total -= tmp;
        p += tmp;
    }

    return tmp;
}


void epoll_ctl_err_show()
{
    std::cout << "error at epoll_ctl" << std::endl;
    if(EBADF == errno)
    {
        std::cout << "error at epoll_ctl, error  is EBADF" << std::endl;
    }
    else if(EEXIST == errno)
    {
        std::cout << "error at epoll_ctl, error  is EEXIST" << std::endl;
    }
    else if(EINVAL == errno)
    {
        std::cout << "error at epoll_ctl, error  is EINVAL" << std::endl;
    }
    else if(ENOENT == errno)
    {
        std::cout << "error at epoll_ctl, error  is ENOENT" << std::endl;
    }
    else if(ENOMEM == errno)
    {
        std::cout << "error at epoll_ctl, error  is ENOMEM" << std::endl;
    }
    else if(ENOSPC == errno)
    {
        std::cout << "error at epoll_ctl, error  is ENOSPC" << std::endl;
    }

}

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

    struct epoll_event ev,events[20]; //聲明epoll_event結構體的變量, ev用於註冊事件, events數組用於回傳要處理的事件
    epfd=epoll_create(256); //生成用於處理accept的epoll專用的文件描述符, 指定生成描述符的最大範圍爲256

    struct sockaddr_in clientaddr;
    struct sockaddr_in serveraddr;

    listenfd = socket(AF_INET, SOCK_STREAM, 0);

    setnonblocking(listenfd); //把用於監聽的socket設置爲非阻塞方式

    ev.data.fd=listenfd; //設置與要處理的事件相關的文件描述符
    ev.events=EPOLLIN | EPOLLET; //設置要處理的事件類型
    epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev); //註冊epoll事件

    bzero(&serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    char *local_addr="127.0.0.1";
    inet_aton(local_addr,&(serveraddr.sin_addr));
    serveraddr.sin_port=htons(SERV_PORT);  //或者htons(SERV_PORT);

    bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));

    listen(listenfd, LISTENQ);

    maxi = 0;

    for( ; ; ) {
        nfds=epoll_wait(epfd, events, 20, -1); //等待epoll事件的發生


        for(i=0;i<nfds;++i) //處理所發生的所有事件
        {
            if(events[i].data.fd==listenfd)    /**監聽事件**/
            {
                //循環accept
                while((connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen)) > 0)
                {
                    setnonblocking(connfd); //把客戶端的socket設置爲非阻塞方式

                    char *str = inet_ntoa(clientaddr.sin_addr);
                    std::cout<<"connect from "<<str<<std::endl;

                    ev.data.fd=connfd; //設置用於讀操作的文件描述符
                    ev.events=EPOLLIN | EPOLLET; //設置用於注測的讀操作事件
                    epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev); //註冊ev事件
                }
            }
            else if(events[i].events&EPOLLIN)     /**讀事件**/
            {
                //fprintf(stderr, "EPOLLIN................%d\n", maxi++);
                if ( (sockfd = events[i].data.fd) < 0)
                {
                    continue;
                }
                memset(line, 0, MAXLINE);
                n = 0;
                int nread = 0;
                while((nread= read(sockfd, line + n, MAXLINE)) > 0)
                {
                    n += nread;
                }//讀到EAGAIN，說明讀完了


                if(nread == -1 && errno != EAGAIN)
                {
                    epoll_ctl_err_show();
                    std::cout<<"readline error"<<std::endl;
                    close(sockfd); //關閉一個文件描述符，那麼它會從epoll集合中自動刪除
                    //描述符關閉後，後面的邋邋邋邋EPOLLOUT設置了，但不起作用了
                    events[i].data.fd = -1;
                }

                //這裏要加上判斷，nread爲0時，說明客戶端已經關閉
                //此時，需要關閉描述符，否則在/proc/id/fd下能看到描述符會一直存在
                if(nread == 0)
                {
                    close(sockfd);
                    continue;
                }


                ev.data.fd=sockfd; //設置用於寫操作的文件描述符
                ev.events=EPOLLOUT | EPOLLET; //設置用於注測的寫操作事件
                epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev); //修改sockfd上要處理的事件爲EPOLLOUT
            }
            else if(events[i].events & EPOLLOUT)    /**寫事件**/
            {
                sockfd = events[i].data.fd;
                //write(sockfd, line, n); orig

                int iRet = socket_send(sockfd, line, strlen(line) + 1);
                if(iRet == -1 || iRet != strlen(line) + 1)
                {
                    perror("write error!");
                }/*zxd*/

                ev.data.fd=sockfd; //設置用於讀操作的文件描述符
                ev.events=EPOLLIN | EPOLLET; //設置用於註冊的讀操作事件
                epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev); //修改sockfd上要處理的事件爲EPOLIN
            }
        }
    }
}

對於server的實現，是先讀後寫的模式，以後再將sfd設成EPOLLIN|EPOLLOUT|EPOLLET的模式再實驗一下。

epoll_wait在客戶端關閉後會返回，EPOLLIN被激活，此時nread爲0，因客戶端已經關閉，所以需要把sfd關閉。

nread爲-1且errno==EAGAIN，說明數據已經讀完，設置EPOLLOUT。

與之對應的echo client，先寫後讀，採用epoll模式：

 

#include "TCPUtility.h"
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>


#define BUFSIZE 512


void SetNonBlock(int fd)
{
    int flag = fcntl ( fd, F_GETFL, 0 );
    fcntl ( fd, F_SETFL, flag | O_NONBLOCK );
}

int main(int argc, char** argv)
{
    int iRet = RET_OK;

    if(4 != argc)
    {
        Debug_UserLog("Parameter: ServerIP Message ServerPort", RET_ERR);
        return RET_ERR;
    }

    in_port_t i16_port = atoi(argv[3]);
    if(0 >= i16_port)
    {
        Debug_UserLog("port number is wrong", RET_ERR);
        return RET_ERR;
    }

    int sk = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(-1 == sk)
    {
        Debug_SysLog("open socket failed!");
        return RET_ERR;
    }


    struct sockaddr_in sa = {0};
    sa.sin_family = AF_INET;
    sa.sin_port = htons(i16_port);

    struct sockaddr_in *psa = &sa;

    iRet = inet_pton(AF_INET, argv[1], &psa->sin_addr.s_addr);
    if(0 == iRet)
    {
        Debug_UserLog("inet_pton failed, invalid address!", RET_ERR);
        close(sk);
        return RET_ERR;
    }
    else if(iRet < 0)
    {
        Debug_SysLog("inet_pton failed");
        close(sk);
        return RET_ERR;
    }

    if(connect(sk, (struct sockaddr*)&sa, sizeof(sa)) < 0)
    {
        Debug_SysLog("connect failed");
        close(sk);
        return RET_ERR;
    }

    SetNonBlock(sk);

    int efd;
    efd = epoll_create(10);
    if(efd == -1)
    {
        perror("epoll_create error!");
        exit(1);
    }

    struct epoll_event event;
    struct epoll_event events[10];

    event.events = EPOLLOUT | EPOLLIN | EPOLLET;
    event.data.fd = sk;

    epoll_ctl(efd, EPOLL_CTL_ADD, sk, &event);


    getchar();
    int loop = 0;
    while(1)
    {
        ssize_t numBytesRcvd = 0;
        char buffer[BUFSIZE] = {0};
        int n = 0;
        int i = 0;

        if(loop == 1)
        {
            break;
        }

        n = epoll_wait(efd, events, 10, -1);

        printf("%d\n", n);

        for(i = 0; i < n; i++)
        {
            if(events[i].events & EPOLLOUT)
            {
                printf("EPOLLOUT...............\n");
                snprintf(buffer, BUFSIZE, "i am process %d, just say: %s\n", getpid(), argv[2]);

                int n = strlen(buffer);
                int nsend = 0;

                while(n > 0)
                {
                    //nsend = send(events[i].data.fd, buffer + nsend, n, 0);
                    nsend = write(events[i].data.fd, buffer + nsend, n);
                    if(nsend < 0 && errno != EAGAIN)
                    {

                        Debug_SysLog("send failed");
                        close(events[i].data.fd);
                        return RET_ERR;
                    }
                    n -= nsend;
                }
            }

            if(events[i].events & EPOLLIN)
            {
                printf("EPOLLIN...............\n");
                memset(buffer, 0, BUFSIZE);

                int len = strlen(buffer);
                int n = 0;
                int nrecv = 0;

                //while((nrecv = recv(events[i].data.fd, buffer + n, BUFSIZE - 1, 0)) > 0)
                while(1){
                    nrecv = read(events[i].data.fd, buffer + n, BUFSIZE - 1) ;
                    if(nrecv == -1 && errno != EAGAIN)
                    {
                        perror("read error!");
                    }
                    if((nrecv == -1 && errno == EAGAIN) || nrecv == 0)
                    {
                        break;
                    }
                    n += nrecv;
                }
                loop = 1;
                printf("%s\n", buffer);
            }
        }
    }
    close(sk);
    close(efd);
    return RET_OK;
}