利用epoll函数实现服务器

使用epoll（本质是一棵监听红黑树）主要在于记住三个函数的调用，以及相应参数、返回值等

int epoll_create(int size); 创建一棵监听红黑树 返回根节点

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

epfd监听红黑树的树根
op对红黑树所要进行的操作 ：
EPOLL_CTL_ADD 添加fd到 监听红黑树

		EPOLL_CTL_MOD 修改fd在 监听红黑树上的监听事件。

		EPOLL_CTL_DEL 将一个fd 从监听红黑树上摘下（取消监听）

fd 待监听的描述符
event： 本质 struct epoll_event 结构体 地址
成员 events：

			EPOLLIN / EPOLLOUT / EPOLLERR

		成员 data： 联合体（共用体）：

			int fd;	  对应监听事件的 fd

			void *ptr； 

			uint32_t u32;

			uint64_t u64;		

	返回值：成功 0； 失败： -1 errno

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

epfd：epoll_create 函数的返回值。 epfd根节点

	events：传出参数，【数组】， 满足监听条件的 那些 fd 结构体。

	maxevents：数组 元素的总个数。 1024
			
		struct epoll_event evnets[1024]
	timeout：

		-1: 阻塞

		0： 不阻塞

		>0: 超时时间 （毫秒）

	返回值：

		> 0: 满足监听的 总个数。 可以用作循环上限。

		0： 没有fd满足监听事件

		-1：失败。 errno

epoll实现多路IO转接思路：

lfd = socket（）; 监听连接事件lfd
bind();
listen();

int epfd = epoll_create(1024); epfd, 监听红黑树的树根。

struct epoll_event tep, ep[1024]; tep, 用来设置单个fd属性， ep 是 epoll_wait() 传出的满足监听事件的数组。

tep.events = EPOLLIN; 初始化 lfd的监听属性。
tep.data.fd = lfd

epoll_ctl(epfd， EPOLL_CTL_ADD, lfd, &tep); 将 lfd 添加到监听红黑树上。

while (1) {

ret = epoll_wait(epfd， ep，1024， -1);			实施监听

for (i = 0; i < ret; i++) {
	
	if (ep[i].data.fd == lfd) {				// lfd 满足读事件，有新的客户端发起连接请求

		cfd = Accept();

		tep.events = EPOLLIN;				初始化  cfd的监听属性。
		tep.data.fd = cfd;

		epoll_ctl(epfd， EPOLL_CTL_ADD, cfd, &tep);

	} else {						cfd 们 满足读事件， 有客户端写数据来。

		n = read(ep[i].data.fd, buf, sizeof(buf));

		if ( n == 0) {

			close(ep[i].data.fd);

			epoll_ctl(epfd， EPOLL_CTL_DEL, ep[i].data.fd , NULL);	// 将关闭的cfd，从监听树上摘下。

		} else if （n > 0） {

			小--大
			write(ep[i].data.fd, buf, n);
		}
	}
}

1.#include <stdio.h>  
2.#include <unistd.h>  
3.#include <stdlib.h>  
4.#include <string.h>  
5.#include <arpa/inet.h>  
6.#include <sys/epoll.h>  
7.#include <errno.h>  
8.#include <ctype.h>  
9.  
10.#include "wrap.h"  
11.  
12.#define MAXLINE 8192  
13.#define SERV_PORT 8000  
14.  
15.#define OPEN_MAX 5000  
16.  
17.int main(int argc, char *argv[])  
18.{  
19.    int i, listenfd, connfd, sockfd;  
20.    int  n, num = 0;  
21.    ssize_t nready, efd, res;  
22.    char buf[MAXLINE], str[INET_ADDRSTRLEN];  
23.    socklen_t clilen;  
24.  
25.    struct sockaddr_in cliaddr, servaddr;  
26.    struct epoll_event tep, ep[OPEN_MAX];       //tep: epoll_ctl参数  ep[] : epoll_wait参数  
27.  
28.    listenfd = Socket(AF_INET, SOCK_STREAM, 0);  
29.    int opt = 1;  
30.    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));      //端口复用  
31.    bzero(&servaddr, sizeof(servaddr));  
32.    servaddr.sin_family = AF_INET;  
33.    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
34.    servaddr.sin_port = htons(SERV_PORT);  
35.    Bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));  
36.    Listen(listenfd, 20);  
37.  
38.    efd = epoll_create(OPEN_MAX);               //创建epoll模型, efd指向红黑树根节点  
39.    if (efd == -1)  
40.        perr_exit("epoll_create error");  
41.  
42.    tep.events = EPOLLIN;   
43.    tep.data.fd = listenfd;           //指定lfd的监听时间为"读"  
44.  
45.    res = epoll_ctl(efd, EPOLL_CTL_ADD, listenfd, &tep);    //将lfd及对应的结构体设置到树上,efd可找到该树  
46.    if (res == -1)  
47.        perr_exit("epoll_ctl error");  
48.  
49.    for ( ; ; ) {  
50.        /*epoll为server阻塞监听事件, ep为struct epoll_event类型数组, OPEN_MAX为数组容量, -1表永久阻塞*/  
51.        nready = epoll_wait(efd, ep, OPEN_MAX, -1);   
52.        if (nready == -1)  
53.            perr_exit("epoll_wait error");  
54.  
55.        for (i = 0; i < nready; i++) {  
56.            if (!(ep[i].events & EPOLLIN))      //如果不是"读"事件, 继续循环  
57.                continue;  
58.  
59.            if (ep[i].data.fd == listenfd) {    //判断满足事件的fd是不是lfd              
60.                clilen = sizeof(cliaddr);  
61.                connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);    //接受链接  
62.  
63.                printf("received from %s at PORT %d\n",   
64.                        inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),   
65.                        ntohs(cliaddr.sin_port));  
66.                printf("cfd %d---client %d\n", connfd, ++num);  
67.  
68.                tep.events = EPOLLIN; tep.data.fd = connfd;  
69.                res = epoll_ctl(efd, EPOLL_CTL_ADD, connfd, &tep);      //加入红黑树  
70.                if (res == -1)  
71.                    perr_exit("epoll_ctl error");  
72.  
73.            } else {                                                    //不是lfd,   
74.                sockfd = ep[i].data.fd;  
75.                n = Read(sockfd, buf, MAXLINE);  
76.  
77.                if (n == 0) {                                           //读到0,说明客户端关闭链接  
78.                    res = epoll_ctl(efd, EPOLL_CTL_DEL, sockfd, NULL);  //将该文件描述符从红黑树摘除  
79.                    if (res == -1)  
80.                        perr_exit("epoll_ctl error");  
81.                    Close(sockfd);                                      //关闭与该客户端的链接  
82.                    printf("client[%d] closed connection\n", sockfd);  
83.  
84.                } else if (n < 0) {                                     //出错  
85.                    perror("read n < 0 error: ");  
86.                    res = epoll_ctl(efd, EPOLL_CTL_DEL, sockfd, NULL);  //摘除节点  
87.                    Close(sockfd);  
88.  
89.                } else {                                                //实际读到了字节数  
90.                    for (i = 0; i < n; i++)  
91.                        buf[i] = toupper(buf[i]);                       //转大写,写回给客户端  
92.  
93.                    Write(STDOUT_FILENO, buf, n);  
94.                    Writen(sockfd, buf, n);  
95.                }  
96.            }  
97.        }  
98.    }  
99.    Close(listenfd);  
100.    Close(efd);  
101.  
102.    return 0;  
103.}