c++每日八股文-----epoll实现多路IO转接

1、函数API

int epoll_create(int size);//创建一棵监听红黑树

size：创建红黑树监听节点的数量（仅供内核参考）
返回值：指向创建的红黑树的根节点的fd（文件描述符） 失败返回-1

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)//操作监听红黑树

epfd：epoll_create函数的返回值
op：对该监听红黑树所做的操作。
  EPOLL_CTL_ADD：添加fd到红黑树
  EPOLL_CTL_MOD：修改fd在监听红黑树上的监听事件。
  EPOLL_CTL_DEL：将一个fd从监听红黑树上摘下（取消监听）
fd：待监听的fd
event：本质是 struct epoll_event 的地址
  evetns：EPOLLIN/EPOLLOUT/EPOLLERR
  data:联合体
    fd：对应监听事件的fd
返回值：成功0 失败-1

 int epoll_wait(int epfd, struct epoll_event *events,
                      int maxevents, int timeout)       //阻塞监听

epfd：epoll_create函数的返回值。
events：（多了个s）传出参数，满足监听条件的fd。用来存内核得到时间的集合，可简单的看作数组
maxevents：数组的元素的总个数
timeout：-1：阻塞 ， 0：非阻塞 ， >0 : 超时时间（ms）。
返回值：>0 满足监听的总个数 可以用作循环上限。0 ：无监听事件 。 -1：错误。

**

2 代码实现

**

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


#define MAXLINE 80
#define SERV_PORT 6666
#define OPEN_MAX 1024


int main()
{

    int listenfd, connectfd, efd, socketfd;
    int ret, nready, maxi;
    int clit[OPEN_MAX];
    ssize_t n;
    char buf[MAXLINE], str[INET_ADDRSTRLEN];

    struct sockaddr_in serv_addr, clit_addr;
    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    socklen_t clitlen;

    //tel：epoll_ctl参数  ep[]:epoll_wait参数
    struct epoll_event tep, ep[OPEN_MAX]; 

    listenfd = socket(AF_INET, SOCK_STREAM, 0); 
    if (listenfd == -1){
        perror("socket error");
        exit(1);
    }

    ret = bind(listenfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    if (ret == -1){ 
        perror("bind error");
        exit(1);
    }

    listen(listenfd, 20);

    int k;
    for(k = 0; k < OPEN_MAX; k ++){
        clit[k] = -1;
    }
    maxi = -1;

    //创建epoll模型  efd指向红黑树根节点  OPEN_MAX红黑树监听节点的数量
    efd = epoll_create(OPEN_MAX);
    if (efd == -1){
        perror("epoll_create error");
        exit(1);
    }
    
    //lds监听模式为读 
    tep.events = EPOLLIN;
    tep.data.fd = listenfd;

    //将lfd以及对应的结构体设置到树上，efd可找到该i树
    ret = epoll_ctl(efd, EPOLL_CTL_ADD, listenfd, &tep);
    if (ret == -1){
        perror("epoll eror");
        exit(1);
    }

    int i = 0, j = 0;
    while(1){
        //阻塞监听 -1表示永久阻塞 
        nready = epoll_wait(efd, ep, OPEN_MAX, -1);
        if (nready == -1){
            perror("epoll_wait error");
            exit(1);
        }

        for (i = 0; i < nready; i ++){
            //如果不是读事件 继续循环
            if (!(ep[i].events & EPOLLIN)){
                continue;
            }
            //判断满足事件的fd是不是listenfd
            if (ep[i].data.fd == listenfd){
                clitlen = sizeof(clit_addr);
                //接受连接
                connectfd = accept(listenfd, (struct sockaddr *)&clit_addr, &clitlen);
                if (connectfd == -1){
                    perror("accept error");
                    exit(1);
                }

                tep.events = EPOLLIN;
                tep.data.fd = connectfd;

                ret = epoll_ctl(efd, EPOLL_CTL_ADD, connectfd,  &tep);
                if (ret == -1){
                    perror("epoll_ctl");
                    exit(1);
                }
            } else {
                socketfd = ep[i].data.fd;
                n = read(socketfd, buf, MAXLINE);

                //读到0 说明客户端关闭链接 将该文件描述符从红黑树中摘除 
                if (n == 0){
                    ret = epoll_ctl(efd, EPOLL_CTL_DEL, socketfd, NULL);
                    if (ret == -1){
                        perror("epoll_clt error");
                        exit (1);
                    }
                    close(socketfd);
                    printf("client[%d] closed conection\n", j);
                //不为0 进行小写转大写操作
                } else {
                    for(j = 0; j < n; j ++){
                        buf[j] = toupper(buf[j]);
                    }
                    write(socketfd, buf, n);
                    write(STDOUT_FILENO, buf, n);
                }       
            }
        }
    }    

close(listenfd);
close(efd);
return 0;
}