echo server,采用epoll模型,先读后写

 

  1. #include <iostream> 
  2. #include <sys/socket.h>  
  3. #include <sys/epoll.h>  
  4. #include <netinet/in.h>  
  5. #include <arpa/inet.h>  
  6. #include <fcntl.h>  
  7. #include <unistd.h>  
  8. #include <stdio.h>  
  9. #include <errno.h>  
  10. using namespace std; 
  11.  
  12. #define MAXLINE 512  
  13. #define OPEN_MAX 100  
  14. #define LISTENQ 20  
  15. #define SERV_PORT  9876 
  16. #define INFTIM 1000  
  17.  
  18. void setnonblocking(int sock)  
  19. {  
  20.     int opts;  
  21.     opts=fcntl(sock,F_GETFL);  
  22.  
  23.     if(opts<0)  
  24.     {  
  25.         perror("fcntl(sock,GETFL)");  
  26.         exit(1);  
  27.     }  
  28.  
  29.     opts = opts | O_NONBLOCK;  
  30.  
  31.     if(fcntl(sock,F_SETFL,opts)<0)  
  32.     {  
  33.         perror("fcntl(sock,SETFL,opts)");  
  34.         exit(1);  
  35.     }  
  36. }  
  37.  
  38.  
  39.  
  40.  
  41. /* 
  42.    假如发送端流量大于接收端的流量 
  43.    (意思是epoll所在的程序读比转发的socket要快), 
  44.    由于是非阻塞的socket,那么send()函数虽然返回, 
  45.    但实际缓冲区的数据并未真正发给接收端, 
  46.    这样不断的读和发, 
  47.    当缓冲区满后会产生EAGAIN错误(参考man send),同时, 
  48.    不理会这次请求发送的数据.所以, 
  49.    需要封装socket_send()的函数用来处理这种情况, 
  50.    该函数会尽量将数据写完再返回,返回-1表示出错。 
  51.    在socket_send()内部,当写缓冲已满(send()返回-1,且errno为EAGAIN), 
  52.    那么会等待后再重试.这种方式并不很完美, 
  53.    在理论上可能会长时间的阻塞在socket_send()内部, 
  54.    但暂没有更好的办法. 
  55.  
  56.  */ 
  57.  
  58. ssize_t socket_send(int sockfd, const char* buffer, size_t buflen) 
  59.     ssize_t tmp; 
  60.     size_t total = buflen; 
  61.     const char *p = buffer; 
  62.  
  63.     while(1) 
  64.     { 
  65.         tmp = send(sockfd, p, total, 0); 
  66.         if(tmp < 0) 
  67.         { 
  68.             // 当send收到信号时,可以继续写,但这里返回-1. 
  69.             if(errno == EINTR) 
  70.                 //return -1;zxd 
  71.                 continue
  72.  
  73.             // 当socket是非阻塞时,如返回此错误,表示写缓冲队列已满, 
  74.             // 在这里做延时后再重试. 
  75.             if(errno == EAGAIN) 
  76.             { 
  77.                 usleep(1000); 
  78.                 continue
  79.             } 
  80.  
  81.             return -1; 
  82.         } 
  83.  
  84.         if((size_t)tmp == total) 
  85.             return buflen; 
  86.  
  87.         total -= tmp; 
  88.         p += tmp; 
  89.     } 
  90.  
  91.     return tmp; 
  92.  
  93.  
  94. void epoll_ctl_err_show()   
  95. {   
  96.     std::cout << "error at epoll_ctl" << std::endl;   
  97.     if(EBADF == errno)   
  98.     {   
  99.         std::cout << "error at epoll_ctl, error  is EBADF" << std::endl;   
  100.     }   
  101.     else if(EEXIST == errno)   
  102.     {   
  103.         std::cout << "error at epoll_ctl, error  is EEXIST" << std::endl;   
  104.     }   
  105.     else if(EINVAL == errno)   
  106.     {   
  107.         std::cout << "error at epoll_ctl, error  is EINVAL" << std::endl;   
  108.     }   
  109.     else if(ENOENT == errno)   
  110.     {   
  111.         std::cout << "error at epoll_ctl, error  is ENOENT" << std::endl;   
  112.     }   
  113.     else if(ENOMEM == errno)   
  114.     {   
  115.         std::cout << "error at epoll_ctl, error  is ENOMEM" << std::endl;   
  116.     }   
  117.     else if(ENOSPC == errno)   
  118.     {   
  119.         std::cout << "error at epoll_ctl, error  is ENOSPC" << std::endl;   
  120.     }   
  121.       
  122. }  
  123.  
  124. int main()  
  125. {  
  126.     int i, maxi, listenfd, connfd, sockfd, epfd, nfds;  
  127.     ssize_t n;  
  128.     char line[MAXLINE];  
  129.     socklen_t clilen;  
  130.  
  131.     struct epoll_event ev,events[20]; //声明epoll_event结构体的变量, ev用于注册事件, events数组用于回传要处理的事件  
  132.     epfd=epoll_create(256); //生成用于处理accept的epoll专用的文件描述符, 指定生成描述符的最大范围为256  
  133.  
  134.     struct sockaddr_in clientaddr;  
  135.     struct sockaddr_in serveraddr;  
  136.  
  137.     listenfd = socket(AF_INET, SOCK_STREAM, 0);  
  138.  
  139.     setnonblocking(listenfd); //把用于监听的socket设置为非阻塞方式  
  140.  
  141.     ev.data.fd=listenfd; //设置与要处理的事件相关的文件描述符  
  142.     ev.events=EPOLLIN | EPOLLET; //设置要处理的事件类型  
  143.     epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev); //注册epoll事件 
  144.  
  145.     bzero(&serveraddr, sizeof(serveraddr));  
  146.     serveraddr.sin_family = AF_INET;  
  147.     char *local_addr="127.0.0.1";  
  148.     inet_aton(local_addr,&(serveraddr.sin_addr)); 
  149.     serveraddr.sin_port=htons(SERV_PORT);  //或者htons(SERV_PORT);  
  150.  
  151.     bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));  
  152.  
  153.     listen(listenfd, LISTENQ);  
  154.  
  155.     maxi = 0;  
  156.  
  157.     for( ; ; ) {  
  158.         nfds=epoll_wait(epfd, events, 20, -1); //等待epoll事件的发生  
  159.          
  160.  
  161.         for(i=0;i<nfds;++i) //处理所发生的所有事件  
  162.         {  
  163.             if(events[i].data.fd==listenfd)    /**监听事件**/ 
  164.             {  
  165.                 //循环accept 
  166.                 while((connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen)) > 0) 
  167.                 { 
  168.                     setnonblocking(connfd); //把客户端的socket设置为非阻塞方式 
  169.  
  170.                     char *str = inet_ntoa(clientaddr.sin_addr);  
  171.                     std::cout<<"connect from "<<str<<std::endl;  
  172.  
  173.                     ev.data.fd=connfd; //设置用于读操作的文件描述符  
  174.                     ev.events=EPOLLIN | EPOLLET; //设置用于注测的读操作事件  
  175.                     epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev); //注册ev事件  
  176.                 } 
  177.             }  
  178.             else if(events[i].events&EPOLLIN)     /**读事件**/ 
  179.             {  
  180.                 //fprintf(stderr, "EPOLLIN................%d\n", maxi++); 
  181.                 if ( (sockfd = events[i].data.fd) < 0)  
  182.                 { 
  183.                     continue;  
  184.                 } 
  185.                 memset(line, 0, MAXLINE); 
  186.                 n = 0; 
  187.                 int nread = 0; 
  188.                 while((nread= read(sockfd, line + n, MAXLINE)) > 0) 
  189.                 { 
  190.                     n += nread; 
  191.                 }//读到EAGAIN,说明读完了 
  192.  
  193.  
  194.                 if(nread == -1 && errno != EAGAIN) 
  195.                 { 
  196.                     epoll_ctl_err_show(); 
  197.                     std::cout<<"readline error"<<std::endl; 
  198.                     close(sockfd); //关闭一个文件描述符,那么它会从epoll集合中自动删除 
  199.                     //描述符关闭后,后面的邋邋邋邋EPOLLOUT设置了,但不起作用了 
  200.                     events[i].data.fd = -1;  
  201.                 } 
  202.  
  203.                 //这里要加上判断,nread为0时,说明客户端已经关闭 
  204.                 //此时,需要关闭描述符,否则在/proc/id/fd下能看到描述符会一直存在 
  205.                 if(nread == 0) 
  206.                 { 
  207.                     close(sockfd); 
  208.                     continue
  209.                 } 
  210.  
  211.  
  212.                 ev.data.fd=sockfd; //设置用于写操作的文件描述符  
  213.                 ev.events=EPOLLOUT | EPOLLET; //设置用于注测的写操作事件  
  214.                 epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev); //修改sockfd上要处理的事件为EPOLLOUT  
  215.             }  
  216.             else if(events[i].events & EPOLLOUT)    /**写事件**/ 
  217.             {  
  218.                 sockfd = events[i].data.fd;  
  219.                 //write(sockfd, line, n); orig 
  220.  
  221.                 int iRet = socket_send(sockfd, line, strlen(line) + 1); 
  222.                 if(iRet == -1 || iRet != strlen(line) + 1) 
  223.                 { 
  224.                     perror("write error!"); 
  225.                 }/*zxd*/ 
  226.  
  227.                 ev.data.fd=sockfd; //设置用于读操作的文件描述符  
  228.                 ev.events=EPOLLIN | EPOLLET; //设置用于注册的读操作事件  
  229.                 epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev); //修改sockfd上要处理的事件为EPOLIN  
  230.             }  
  231.         }  
  232.     }  

对于server的实现,是先读后写的模式,以后再将sfd设成EPOLLIN|EPOLLOUT|EPOLLET的模式再实验一下。

epoll_wait在客户端关闭后会返回,EPOLLIN被激活,此时nread为0,因客户端已经关闭,所以需要把sfd关闭。

nread为-1且errno==EAGAIN,说明数据已经读完,设置EPOLLOUT。

与之对应的echo client,先写后读,采用epoll模式:

 

  1. #include "TCPUtility.h" 
  2. #include <netinet/in.h> 
  3. #include <sys/types.h> 
  4. #include <sys/socket.h> 
  5. #include <arpa/inet.h> 
  6. #include <sys/epoll.h> 
  7. #include <errno.h> 
  8. #include <string.h> 
  9. #include <fcntl.h> 
  10.  
  11.  
  12. #define BUFSIZE 512  
  13.  
  14.  
  15. void SetNonBlock(int fd) 
  16.     int flag = fcntl ( fd, F_GETFL, 0 ); 
  17.     fcntl ( fd, F_SETFL, flag | O_NONBLOCK ); 
  18.  
  19. int main(int argc, char** argv) 
  20.     int iRet = RET_OK; 
  21.  
  22.     if(4 != argc) 
  23.     { 
  24.         Debug_UserLog("Parameter: ServerIP Message ServerPort", RET_ERR); 
  25.         return RET_ERR; 
  26.     } 
  27.  
  28.     in_port_t i16_port = atoi(argv[3]); 
  29.     if(0 >= i16_port) 
  30.     { 
  31.         Debug_UserLog("port number is wrong", RET_ERR); 
  32.         return RET_ERR; 
  33.     } 
  34.  
  35.     int sk = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); 
  36.     if(-1 == sk) 
  37.     { 
  38.         Debug_SysLog("open socket failed!"); 
  39.         return RET_ERR; 
  40.     } 
  41.  
  42.  
  43.     struct sockaddr_in sa = {0}; 
  44.     sa.sin_family = AF_INET; 
  45.     sa.sin_port = htons(i16_port); 
  46.  
  47.     struct sockaddr_in *psa = &sa; 
  48.  
  49.     iRet = inet_pton(AF_INET, argv[1], &psa->sin_addr.s_addr); 
  50.     if(0 == iRet) 
  51.     { 
  52.         Debug_UserLog("inet_pton failed, invalid address!", RET_ERR); 
  53.         close(sk); 
  54.         return RET_ERR; 
  55.     } 
  56.     else if(iRet < 0) 
  57.     { 
  58.         Debug_SysLog("inet_pton failed"); 
  59.         close(sk); 
  60.         return RET_ERR; 
  61.     } 
  62.  
  63.     if(connect(sk, (struct sockaddr*)&sa, sizeof(sa)) < 0) 
  64.     { 
  65.         Debug_SysLog("connect failed"); 
  66.         close(sk); 
  67.         return RET_ERR; 
  68.     } 
  69.  
  70.     SetNonBlock(sk); 
  71.  
  72.     int efd;  
  73.     efd = epoll_create(10);  
  74.     if(efd == -1) 
  75.     { 
  76.         perror("epoll_create error!"); 
  77.         exit(1); 
  78.     } 
  79.  
  80.     struct epoll_event event; 
  81.     struct epoll_event events[10]; 
  82.  
  83.     event.events = EPOLLOUT | EPOLLIN | EPOLLET; 
  84.     event.data.fd = sk; 
  85.  
  86.     epoll_ctl(efd, EPOLL_CTL_ADD, sk, &event); 
  87.  
  88.  
  89.     getchar(); 
  90.     int loop = 0; 
  91.     while(1) 
  92.     { 
  93.         ssize_t numBytesRcvd = 0; 
  94.         char buffer[BUFSIZE] = {0}; 
  95.         int n = 0; 
  96.         int i = 0; 
  97.  
  98.         if(loop == 1) 
  99.         { 
  100.             break
  101.         } 
  102.   
  103.         n = epoll_wait(efd, events, 10, -1); 
  104.  
  105.         printf("%d\n", n); 
  106.  
  107.         for(i = 0; i < n; i++) 
  108.         { 
  109.             if(events[i].events & EPOLLOUT) 
  110.             { 
  111.                 printf("EPOLLOUT...............\n"); 
  112.                 snprintf(buffer, BUFSIZE, "i am process %d, just say: %s\n", getpid(), argv[2]); 
  113.  
  114.                 int n = strlen(buffer); 
  115.                 int nsend = 0; 
  116.  
  117.                 while(n > 0) 
  118.                 { 
  119.                     //nsend = send(events[i].data.fd, buffer + nsend, n, 0); 
  120.                     nsend = write(events[i].data.fd, buffer + nsend, n); 
  121.                     if(nsend < 0 && errno != EAGAIN) 
  122.                     { 
  123.  
  124.                         Debug_SysLog("send failed"); 
  125.                         close(events[i].data.fd); 
  126.                         return RET_ERR; 
  127.                     } 
  128.                     n -= nsend; 
  129.                 } 
  130.             } 
  131.  
  132.             if(events[i].events & EPOLLIN) 
  133.             { 
  134.                 printf("EPOLLIN...............\n"); 
  135.                 memset(buffer, 0, BUFSIZE); 
  136.  
  137.                 int len = strlen(buffer); 
  138.                 int n = 0; 
  139.                 int nrecv = 0; 
  140.  
  141.                 //while((nrecv = recv(events[i].data.fd, buffer + n, BUFSIZE - 1, 0)) > 0) 
  142.                 while(1){ 
  143.                     nrecv = read(events[i].data.fd, buffer + n, BUFSIZE - 1) ; 
  144.                     if(nrecv == -1 && errno != EAGAIN) 
  145.                     { 
  146.                         perror("read error!"); 
  147.                     } 
  148.                     if((nrecv == -1 && errno == EAGAIN) || nrecv == 0) 
  149.                     { 
  150.                         break
  151.                     } 
  152.                     n += nrecv; 
  153.                 } 
  154.                 loop = 1; 
  155.                 printf("%s\n", buffer); 
  156.             } 
  157.         } 
  158.     } 
  159.     close(sk); 
  160.     close(efd); 
  161.     return RET_OK;