Linux--高级I/O（select、poll、epoll）

一、五种I/O模型

1.1、阻塞I/O

阻塞I/O：在内核将数据准备好之前，系统调用会一直等待，所有的套接字，默认都是阻塞方式。

举例：张三拿了一根鱼竿在荷塘旁边钓鱼，张三钓鱼的方式是一直看着鱼竿直到有鱼上钩。

1.2、非阻塞I/O

非阻塞I/O：如果内核还未将数据准备好，系统调用仍然会直接返回，并且返回EWOULDBLOCK错误码。非阻塞I/O往往需要程序员循环的方式反复尝试读写文件描述符，这个过程称为轮询。这对CPU来说是较大的浪费，一般在特定场景下使用。

举例：李四拿了一根鱼竿在荷塘旁边钓鱼，但是李四钓鱼的方式是过特定的时间看看有无鱼上钩。

1.3、信号驱动I/O

信号驱动I/O：内核将数据准备好的时候，使用SIGIO信号通知应用程序进行I/O操作。

举例：王五拿了一根鱼竿在荷塘旁边钓鱼，但是王五钓鱼的方式王五鱼竿上有个铃铛，当有鱼上钩是铃铛会响，所以王五就会知道。

1.4、I/O多路复用

I/O多路复用：虽然看似I/O多路复用和阻塞I/O类似，实际上最核心在于IO多路复用能够同时等待多个文件描述符的就绪状态。

举例：赵六是个有钱人拿了一批鱼竿在荷塘旁边钓鱼，赵六的调用方式就是使用一批鱼竿同时进行钓鱼，那么赵六能够调到鱼的概率就大大的增加了。

1.5、异步I/O

异步I/O：由内核在数据拷贝完成时（拷贝到用户空间），通知应用程序（而信号驱动是告诉应用程序何时可以开始拷贝数据）。

举例：田七是个更有钱的人他直接让别人去钓鱼，钓好之后直接通知他就可以了。和王五不同的是王五不需要等何时有鱼，而需要自己把鱼掉起来。

1.6、总结

任何I/O过程中，都包含两个步骤：

第一阶段：等待数据准备。
第二阶段：将数据从内核拷贝到用户空间。

而且在实际的应用场景中，等待数据准备所消耗的时间往往都远远高于拷贝的时间。让I/O更高效，最核心的方法就是让等待的时间尽量的少。

二、同步通信 vs 异步通信

同步和异步所关注的是消息通信机制。

同步：就是在发出一个调用时，在没有得到结果之前，该调用就不返回. 但是一旦调用返回，就得到返回值了。换句话说，调用过程需要自己参与的就叫同步。
异步： 调用在发出之后，这个调用就直接返回了，所以没有返回结果; 换句话说，当一个异步过程调用发出后，调用者不会立刻得到结果; 而是在调用发出后， 被调用者通过状态、通知来通知调用者，或通过回调函数处理这个调用。换句话说，调用过程不需要自己参与的就叫异步。

三、阻塞 vs 非阻塞

阻塞和非阻塞关注的是程序在等待调用结果（消息和返回值）时的状态。

阻塞调用：指调用结果返回之前，当前线程会被挂起，调用线程只有在得到结果之后才会返回。
非阻塞调用：指在调用之后不会立刻得到结果，但是该调用不会阻塞当前线程。

四、阻塞I/O

4.1、fcntl

一个文件描述符，默认是阻塞的，我们可以通过fcntl函数设置为非阻塞的。

#include <unistd.h>
#include <fcntl.h>
int fcntl(int fd, int cmd, ... /* arg */ );

传入的cmd的值不同，后面追加的参数也不同。
fcntl函数有5种功能。：

复制一个现有的描述符（cmd=F_DUPFD）
获得/设置文件描述符标记(cmd=F_GETFD或cmd=F_SETFD)
获得/设置文件状态标记(cmd=F_GETFL或F_SETFL).
获得/设置异步I/O所有权(cmd=F_GETOWN或F_SETOWN).
获得/设置记录锁(cmd=F_GETLK,F_SETLK或F_SETLKW)

4.2、实现函数SetNoBlock

我们使用第三种功能，获取/设置文件状态标记，就可以将一个文件描述符设置为非阻塞。
基于fcntl，我们实现一个SetNoBlock函数，将文件描述符设置为非阻塞。

void SetNoBlock(int fd) {
	int fl = fcntl(fd, F_GETFL);
	if (fl < 0) {
		perror("fcntl");
		return;
	}
	fcntl(fd, F_SETFL, fl | O_NONBLOCK);
}

使用F_GETFL将当前文件描述符的属性获取出来（这是一个位图）
然后使用F_SETFL将文件描述符设置回去，设置回去的同时, 加上一个O_NONBLOCK参数

4.3、轮询方式读取标准输入

#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
#include<errno.h>

void SetNoBlock(int fd){
  int fl=fcntl(fd,F_GETFL);
  if(fl < 0){
    perror("fcntl");
    return;
  }
  fcntl(fd,F_SETFL,fl | O_NONBLOCK);
}

int main(){
  char c;
  SetNoBlock(0);
  while(1){
    sleep(1);
    ssize_t s = read(0,&c,1);
    if(s > 0){
      printf("%c\n",c);
    }else if(s < 0&&errno == EAGAIN){
        printf("read cond not okay!!\n");
    }else{
      printf("read error..\n");
    }
    printf("..........................\n");
  }
}

运行结果：

五、I/O多路转接之select

5.1、初始select

系统提供select函数来实现多路复用的输入和输出模型。

1、select系统调用是用来让我们程序监视多个文件描述符的状态变化的；
2、程序会停在select这里等待，直到被监视的文件描述符有一个或多个发生了状态变化；

总结：select的主要工作就是帮我们等，到时候我们就只需要从内核拷贝数据到用户进程。

5.2、select函数原型

#include <sys/select.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *timeout);

参数解释：

1、参数nfds是需要监视的最大的文件描述符值+1；
2、readfds,writefds,exceptfds分别对应于需要检测的可读文件描述符的集合，可写文件描述符的集 合及异常文件描述符的集合;这三个参数都是输入输出型参数。
3、参数timeout为结构timeval，用来设置select()的等待时间，输入输出型参数。

readfds&writefds&exceptfds：

1、fd_set是一个位图结构。这三个参数都是输入输出型参数。
2、我拿readfds这个参数作为举例：作为输入参数时：fd_set比特位的位置，代表哪一个文件描述符；比特位的内容：操作系统是否需要关心特定的文件描述符上面的读就绪事件。
3、作为输出参数时：fd_set比特位的位置，代表哪一个文件描述符；比特位的内容：哪些文件描述符上面的读事件已经就绪。
4、列如：输入时为1001 1100（操作系统帮我关心文件描述符2、3、4、7上面的读事件）。输出时为0000 1100（文件描述符2、3上面的读事件已经就绪）。

参数timeout取值:

NULL：则表示select()没有timeout， select将一直被阻塞，直到某个文件描述符上发生了事件;阻塞等待。
0：仅检测描述符集合的状态，然后立即返回，并不等待外部事件的发生。非阻塞等待。
特定的时间值：如果在指定的时间段里没有事件发生， select将超时返回。特定事件等待

关于fd_set结构：

其实这个结构就是一个整数数组, 更严格的说, 是一个 “位图”. 使用位图中对应的位来表示要监视的文件描述符。

提供了一组操作fd_set的接口, 来比较方便的操作位图。

void FD_CLR(int fd, fd_set *set);   // 用来清除描述词组set中相关fd 的位
int FD_ISSET(int fd, fd_set *set);  // 用来测试描述词组set中相关fd 的位是否为真
void FD_SET(int fd, fd_set *set);   // 用来设置描述词组set中相关fd的位
void FD_ZERO(fd_set *set);          // 用来清除描述词组set的全部位

time_val结构：
timeval结构用于描述一段时间长度，如果在这个时间内，需要监视的描述符没有事件发生则函数返回，返回值为0。

函数返回值：

1、执行成功则返回文件描述词状态已改变的个数。
2、如果返回0代表在描述词状态改变前已超过timeout时间，没有返回。
3、当有错误发生时则返回-1，错误原因存于errno，此时参数readfds， writefds, exceptfds和timeout的值变成不可预测。

我们可以根据返回值来做一些判断操作，是否可以进行文件描述符的处理。

错误值：

1、EBADF 文件描述词为无效的或该文件已关闭
2、EINTR 此调用被信号所中断
3、EINVAL 参数n 为负值。
4、ENOMEM 核心内存不足

5.3、理解select执行过程

理解select模型关键在于理解fd_set，为方便说明取fd_set长度为1字节， fd_set中的每一bit可以对应一个文件描述符fd。则1字节长的fd_set最大可以对应8个fd。

1、执行fd_set set; FD_ZERO(&set);则set用位表示是0000,0000。
2、若fd＝ 5,执行FD_SET(fd,&set);后set变为0001,0000(第5位置为1) 。
3、若再加入fd＝ 2， fd=1,则set变为0001,0011。
4、执行select(6,&set,0,0,0)阻塞等待。则操作系统检测文件描述符<=5上面的读事件是否就绪。
5、若fd=1,fd=2上都发生可读事件，则select返回，此时set变为0000,0011。注意：没有事件发生的fd=5被清空。

5.4、socket上的就绪事件

读就绪：

1、socket内核中, 接收缓冲区中的字节数, 大于等于低水位标记SO_RCVLOWAT. 此时可以无阻塞的读该文件描述符, 并且返回值大于0;
2、socket TCP通信中, 对端关闭连接, 此时对该socket读, 则返回0;
3、监听的socket上有新的连接请求;
4、socket上有未处理的错误。

写就绪：

1、socket内核中, 发送缓冲区中的可用字节数(发送缓冲区的空闲位置大小), 大于等于低水位标SO_SNDLOWAT, 此时可以无阻塞的写, 并且返回值大于0;
2、socket的写操作被关闭(close或者shutdown). 对一个写操作被关闭的socket进行写操作, 会触发SIGPIPE信号;
3、socket使用非阻塞connect连接成功或失败之后;
4、socket上有未读取的错误;

异常就绪：

socket上收到带外数据. 关于带外数据, 和TCP紧急模式相关(回忆TCP协议头中, 有一个紧急指针的字段),

5.5、select使用示例

//Sock.hpp 工具类
#pragma once
#include<iostream>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<stdlib.h>
#include<strings.h>
#include<sys/select.h>
#include<algorithm>

#define BACKLOG 5


class Sock{
public:
  static int Socket(){
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0){
      printf("create socket error..\n");
      exit(1);
    }
    return sock;
  }

  static void Bind(int port,int sock){
    struct sockaddr_in local;
    bzero(&local,sizeof(local));
    local.sin_family = AF_INET;
    local.sin_addr.s_addr = htonl(INADDR_ANY);
    local.sin_port = htons(port);
    if(bind(sock,(sockaddr*)&local,sizeof(local)) < 0){
      printf("bind error...\n");
      exit(2);
    }
  }

  static void Listen(int sock){
    if(listen(sock,BACKLOG) < 0){
      printf("listen error...\n");
      exit(3);
    }    
  } 
  static void SetSockOpt(int sock){
    int op=1;
    setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&op,sizeof(op));
  }
  static int Accept(int lsock){
    struct sockaddr_in remote;
    socklen_t len=sizeof(remote);
    int sock=accept(lsock,(sockaddr*)&remote,&len);
    return sock;
  }
};

//selectServer.hpp
#include"Sock.hpp"

#define PORT 8081
#define NUM (sizeof(fd_set)*8)
#define DFL_FD -1

using namespace std;


class selectServer{
private:
  int port;
  int lsock;
  int fd_arrays[NUM];

public:
  selectServer(int _port = PORT):port(_port),lsock(-1){

  }

  void InitServer(){
    lsock = Sock::Socket();
    Sock::SetSockOpt(lsock);
    Sock::Bind(port,lsock);
    Sock::Listen(lsock);
    
    for(int i = 0;i < NUM;i++){
      fd_arrays[i] = DFL_FD;
    }
    fd_arrays[0] = lsock;
  }
  void AddFD2Array(int sock){
    for(int i = 0;i < NUM;i++){
      if(fd_arrays[i] == DFL_FD){
        fd_arrays[i] = sock;
        break;
      }
    }
  } 
  void DelFdFromArray(int index){
    if(index >= 0&&index < NUM){
      fd_arrays[index] = DFL_FD;
    }
  }
  void HandlerEvents(fd_set *readfds){
    for(int i = 0;i < NUM;i++){
      if(fd_arrays[i] == DFL_FD){
        continue;
      }
      if(FD_ISSET(fd_arrays[i],readfds)){
        //read ready
        if(fd_arrays[i] == lsock){
          //new link
          int sock = Sock::Accept(lsock);
          cout<<"get a new link"<<endl;
          if(sock > 0){
            AddFD2Array(sock);
          }

        }else{
          //read data ready
          char buf[1024];
          ssize_t s = recv(fd_arrays[i],buf,sizeof(buf),0);
          if(s > 0){
            buf[s] = 0;
            cout<<"client #";
            printf("%s\n",buf);
          }else if(s == 0){
            //remote close fd
            cout<<"client quit.."<<endl;
            close(fd_arrays[i]);
            DelFdFromArray(i);
          }else{
            cout<<"read error"<<endl;
          }
        }
      }
    }
  }
  void Start(){
    int max_fd = DFL_FD;
    while(true){
      fd_set readfd;
      FD_ZERO(&readfd);
      cout<<"fd_arrays :";
      for(int i = 0;i <NUM;i++){
        if(fd_arrays[i] != DFL_FD){
          FD_SET(fd_arrays[i],&readfd);
          if(fd_arrays[i] > max_fd)
            max_fd = fd_arrays[i];
          cout<<fd_arrays[i]<<' ';
        }
      }
      cout<<endl;
     // struct timeval time = {2,0};
      switch(select(max_fd+1,&readfd,nullptr,nullptr,nullptr)){
        case 0:
          cout<<"timeout..."<<endl;
          break;
        case -1:
          cout<<"select wait fail..."<<endl;
          break;
        default:
          HandlerEvents(&readfd);
          break;
      }
    }
  }
  ~selectServer(){
    if(lsock > 0){
      close(lsock);
    }
  }
};

//main.cc
#include"selectServer.hpp"

int main(){
  selectServer *server = new selectServer;
  server->InitServer();
  server->Start();
  delete server;
  return 0;
}

//Makefile
bin=server
src=main.cc
cc=g++
FLAGS=-std=c++11

$(bin):$(src)
	$(cc) $^ -o $@ $(FLAGS)

clean:
	rm -f $(bin)

5.6、select的特点

• 1、可监控的文件描述符个数取决于sizeof(fd_set)的值，对于我的服务器sizeof(fd_set)=128，每个bit表示一个文件描述符，则我的服务器上支持的最大文件描述符是128*8=1024；

• 2、将fd加入select监控集中的同时，还要再使用一个数据结构array保存放到select监控集中的fd。

  • 作用一：用于在select 返回后， array作为源数据和fd_set进行FD_ISSET判断。
  • 作用二：select返回后会把以前加入的但并无事件发生的fd清空，则每次开始select前都要重新从array取得fd逐一加入fd_set监控集中，扫描array的同时取得fd最大值maxfd，用于select的第一个参数。

5.7、select的缺点

1、每次调用select，都需要手动设置fd集合，从接口使用角度来说非常不便。
2、每次调用select，都需要把fd集合从用户态到内核态，这个开销在fd很多时会很大。
3、同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也会很大。
4、select支持的文件描述符数量是有上限的。

六、I/O多路转接之poll

6.1、poll的函数原型

#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);

struct pollfd {
     int   fd;         /* file descriptor */
     short events;     /* requested events */	//用户告诉操作系统帮用户关心什么事件
     short revents;    /* returned events */	//操作系统通知用户什么事件就绪
};

参数说明：

1、fds是一个poll函数监听的结构体列表。每一个元素中，包含了三部分内容：文件描述符，监听的事件集合，返回的事件集合。
2、nfds是fds数组的长度。
3、timeout表示poll函数的超时时间，单位是毫秒(ms)，timeout=-1：阻塞等待；timeout=0：阻塞等待；timueout>0：特定的等待时间。

events和revents的取值：

事件	描述	是否可作为输入（events）	是否可作为输出（revents）
POLLIN	数据可读（包括普通数据&优先数据）	是	是
POLLOUT	数据可写（普通数据&优先数据）	是	是
POLLRDNORM	普通数据可读	是	是
POLLRDBAND	优先级带数据可读（linux不支持）	是	是
POLLPRI	高优先级数据可读，比如TCP带外数据	是	是
POLLWRNORM	普通数据可写	是	是
POLLWRBAND	优先级带数据可写	是	是
POLLRDHUP	TCP连接被对端关闭，或者关闭了写操作，由GNU引入	是	是
POPPHUP	挂起	否	是
POLLERR	错误	否	是
POLLNVAL	文件描述符没有打开	否	是

其中events和revents都是short类型有16位，我们可以使用每一位代表特定的事件，可以通过events|事件名来进行设置。例如我们要设置读事件可以这样设置：events|=POLLIN;

以下是每个事件的定义：

返回结果：

1、返回值为小于0，表示出错；
2、返回值等于0，表示poll函数等待超时；
3、返回值大于0，表示poll监听的多少文件描述符准备就绪了。

6.2、poll的就绪条件

和select相同

6.3、poll的使用示例

#include<poll.h>
#include<unistd.h>
#include<stdlib.h>
#include<stdio.h>

using namespace std;

int main(){
  struct pollfd fds[1];
  fds[0].fd=0;
  fds[0].events=POLLIN;
  fds[0].revents=0;

  char buf[1024];
  cout<<"poll begin..."<<endl;
  while(true){
    switch(poll(fds,1,1000)){
      case 0:
        cout<<"timeout..."<<endl;
        break;
      case -1:
        cout<<"poll wait error"<<endl;
        break;
      default:
        if(fds[0].fd == 0&&(fds[0].revents&POLLIN)){
         // ssize_t s = read(fds[0].fd,buf,sizeof(buf)); 
         // if(s>0){
         //   buf[s]=0;
         //   cout<<buf<<endl;
         // }
          cout<<"data ready ok"<<endl;
        }
        break;
    }
  }
  return 0;
}

重点：如果没有将内核中数据取出，poll会一直处于事件就绪状态。

6.4、poll的优点

不同于select使用三个位图来表示三个fdset的方式，poll使用一个pollfd的指针来实现。

1、pollfd结构包含了要监视的event和发生的event，不再使用select“参数-值”传递的方式. 接口使用比select更方便。并且不需要在调用的时候都重新设置。
2、poll并没有最大数量限制 (但是数量过大后性能也是会下降)。

6.4、poll的缺点

poll监视的文件描述符增多时：

1、和select函数一样，poll返回后，需要轮询pollfd来获取就绪的文件描述符。
2、每次调用poll都需要把大量的pollfd结构从用户态拷贝到内核中。
3、同时连接的大量客户端在一段时刻可能只有很少处于就绪状态，因此随着监视的描述符数量增加时，其效率也会呈线性增长。

七、I/O多路转接之epoll

7.1、epoll相关系统调用

epoll_create：创建一个epoll模型

#include<epoll>
int epoll_create(int size);

自从linux2.6.8之后，size参数是被忽略的。
用完之后，必须调用close关闭。

epoll_ctl：事件注册函数

#include<epoll>
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);//

参数：

1、epfd：epoll_create创建的epoll模型的返回值。
2、op：表示动作，由三个宏来表示：

• 1、EPOLL_CTL_ADD ：注册新的fd到epfd中；
• 2、EPOLL_CTL_MOD ：修改已经注册的fd的监听事件；
• 3、EPOLL_CTL_DEL ：从epfd中删除一个fd。

3、fd：要监听的fd.
4、event：告诉内核需要监听哪些事件。

struct epoll_event结构如下：

events可以是下面几个宏的集合：

• EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；
• EPOLLOUT：表示对应的文件描述符可以写；
• EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；
• EPOLLERR：表示对应的文件描述符发生错误；
• EPOLLHUP：表示对应的文件描述符被挂断；
• EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的。
• EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里。

epoll_wait：收集在epoll监控事件中已经发生的事件

#include<epoll>
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout)

参数：

1、 events：在用户态创建的数组，epoll将已经发生的事件从内核态拷贝到用户态。(events不可以是空指针，内核只负责把数据复制到这个events数组中，不会去帮助我们在用户态中分配内存)。
2、 maxevents告之内核这个events有多大，这个 maxevents的值不能大于创建epoll_create()时的size。
3、参数timeout是超时时间 (毫秒， 0会立即返回， -1是永久阻塞)。
4、 如果函数调用成功，返回对应I/O上已准备好的文件描述符数目，如返回0表示已超时, 返回小于0表示函数失败。如果准备好的文件描述符数目大于maxevents，那么只会返回maxevents，多余的下次再返回。

7.2、epoll的工作原理

当某一进程调用epoll_create方法时， Linux内核会创建一个eventpoll结构体，这个结构体中有两个成员与epoll的使用方式密切相关。

struct eventpoll{
....
/*红黑树的根节点，这颗树中存储着所有添加到epoll中的需要监控的事件*/
struct rb_root rbr;
/*双链表中则存放着将要通过epoll_wait返回给用户的满足条件的事件*/
struct list_head rdlist;
....
};

1、每一个epoll对象都有一个独立的eventpoll结构体，用于存放通过epoll_ctl方法向epoll对象中添加进来的事件.
2、这些事件都会挂载在红黑树中，如此，重复添加的事件就可以通过红黑树而高效的识别出来(红黑树的插入时间效率是lgn，其中n为树的高度).
3、而所有添加到epoll中的事件都会与设备(网卡)驱动程序建立回调关系，也就是说，当响应的事件发生时会调用这个回调方法.
4、这个回调方法在内核中叫ep_poll_callback,它会将发生的事件添加到rdlist双链表中.
5、在epoll中，对于每一个事件，都会建立一个epitem结构体.

struct epitem{
	struct rb_node rbn;//红黑树节点
	struct list_head rdllink;//双向链表节点
	struct epoll_filefd ffd; //事件句柄信息
	struct eventpoll *ep; //指向其所属的eventpoll对象
	struct epoll_event event; //期待发生的事件类型
}

1、当调用epoll_wait检查是否有事件发生时，只需要检查eventpoll对象中的rdlist双链表中是否有epitem元素即可.
2、如果rdlist不为空，则把发生的事件复制到用户态，同时将事件数量返回给用户. 这个操作的时间复杂度是O(1).

7.3、epoll的优点

• 1、接口设计简单：虽然拆分成了三个函数，但是反而使用起来更加高效，不需要每次循环都设置关注文件描述符，也做到了输入输出参数分离。
• 2、数据拷贝轻量: 只在合适的时候调用 EPOLL_CTL_ADD 将文件描述符结构拷贝到内核中, 这个操作并不频繁(而select/poll都是每次循环都要进行拷贝)。
• 3、事件回调机制: 避免使用遍历, 而是使用回调函数的方式, 将就绪的文件描述符结构加入到就绪队列中,epoll_wait 返回直接访问就绪队列就知道哪些文件描述符就绪. 这个操作时间复杂度O(1). 即使文件描述符数目很多, 效率也不会受到影响。
• 4、没有数量限制: 文件描述符数目无上限。

7.4、epoll使用案例

服务器接受特定字符长度，然后给客户端返回。

//Sock.hpp
#pragma once
#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<unistd.h>
#include<stdlib.h>
#include<stdio.h>
#include<sys/epoll.h>
#include<strings.h>
#include<string.h>


#define BACKLOG 5
using namespace std;

class Sock{
public:
  static int Socket(){
    int sock=socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0){
      cerr<<"create socket error.."<<endl;
      exit(1);
    }
    return sock;
  }

  static void Bind(int sock,int port){
    struct sockaddr_in local;
    bzero(&local,sizeof(local)); 
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = htonl(INADDR_ANY);
    if(bind(sock,(sockaddr*)&local,sizeof(local)) < 0){
      cerr<<"bind error..."<<endl;
      exit(2);
    }
  }

  static void Listen(int sock){
    if(listen(sock,BACKLOG) < 0){
      cerr<<"listen error.."<<endl;
      exit(3);
    }
  }
  static int Accept(int lsock){
    struct sockaddr_in peer;
    socklen_t len = sizeof(peer);
    int sock = accept(lsock,(sockaddr*)&peer,&len);
    return sock;
  }
  static void SetSockOpt(int sock){
    int op = 1;
    setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&op,sizeof(op));
  }
};
//EpollServer.hpp
#include"Sock.hpp"

#define PORT 8081
#define SIZE 64
class Bucket{
public:
  char buffer[20];
  int fd;
  size_t pos;
  Bucket(int sock):fd(sock),pos(0)
  {
    memset(buffer,0,sizeof(buffer));
  }
};

class EpollServer{
private:
  int port;
  int lsock;
  int epfd;
public:
  EpollServer(int _port = PORT):port(_port),lsock(-1){

  }

  void InitServer(){
    lsock = Sock::Socket();
    Sock::SetSockOpt(lsock);
    Sock::Bind(lsock,port);
    Sock::Listen(lsock);
    epfd = epoll_create(128);
    if(epfd < 0){
      cerr<<"create epoll error.."<<endl;
      exit(0);
    }
  }
  void AddEvent2Epoll(int sock,uint32_t event){
    struct epoll_event ev;
    ev.events = event;
    if(sock ==lsock){
      ev.data.ptr = nullptr;
    }else{
      ev.data.ptr = new Bucket(sock);
    }
    epoll_ctl(epfd,EPOLL_CTL_ADD,sock,&ev);
  }

  void DelFromEvent2Epoll(int sock){
    close(sock);
    epoll_ctl(epfd,EPOLL_CTL_DEL,sock,nullptr);
  }

  void HandlerEvents(struct epoll_event* revs,int size){
    for(int i = 0;i < size;i++){
      uint32_t ev = revs[i].events;
      if(ev & EPOLLIN){
        if(revs[i].data.ptr != nullptr){
          //link socket
          Bucket *bucket = (Bucket*)revs[i].data.ptr; 
          ssize_t s = recv(bucket->fd,bucket->buffer+bucket->pos,sizeof(bucket->buffer)-bucket->pos,0);
          if(s > 0){
            bucket->pos += s;
            cout<<bucket->buffer<<endl;
            if(bucket->pos >= sizeof(bucket->buffer)){
              struct epoll_event temp;
              temp.events = EPOLLOUT;
              temp.data.ptr = bucket;
              epoll_ctl(epfd,EPOLL_CTL_MOD,bucket->fd,&temp);
            }
          }else if(s==0){
            DelFromEvent2Epoll(bucket->fd);
            delete bucket;
          }else{

          }
        }else{
          //listen socket
          int sock = Sock::Accept(lsock);
          cout<<"get a new link.."<<endl;
          if(sock > 0){
            AddEvent2Epoll(sock,EPOLLIN);
          }
        }
      }else if(ev & EPOLLOUT){
        Bucket* bp=(Bucket*)revs[i].data.ptr;
        send(bp->fd,bp->buffer,sizeof(bp->buffer),0);
        DelFromEvent2Epoll(bp->fd);
        delete bp;
      }
    }
  }
  void Start(){
    AddEvent2Epoll(lsock,EPOLLIN);
    struct epoll_event revs[SIZE];
    while(true){
      int num = epoll_wait(epfd,revs,SIZE,-1);
      switch(num){
        case 0:
          cout<<"time out..."<<endl;
          break;
        case -1:
          cout<<"epoll_wait fail..."<<endl;
          break;
        default:
          HandlerEvents(revs,num);
          break;
      }
    }
  }

  ~EpollServer(){
    if(lsock >= 0){
      close(lsock);
    }
    close(epfd);
  }
};

//main.cc
#include"EpollServer.hpp"

int main(){
  EpollServer *server=new EpollServer();
  server->InitServer();
  server->Start();
  delete server;
  return 0;
}