66.poll函数原型分析
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
fds : 需要检测的文件描述符[数组],传入传出数组。
struct pollfd {
int fd; /* file descriptor */ //文件描述符
short events; /* requested events */ //监听事件POLLIN，POLLOUT，POLLERR
short revents; /* returned events */ //返回的事件，传入时为0，如果满足对应事件的话，返回非0.
};
nfds：监听数组的，实际有效监听个数。监控数组中需要监控的文件描述符数量。
timeout：毫秒级等待
-1：阻塞等，
0：立即返回，不阻塞进程
0: 等待指定毫秒数，如当前系统时间精度不够毫秒，向上取整。
返回值：成功，所有检测集合中，满足条件的总数。
-1，失败。
68.poll函数实现服务器
#include<sys/select.h>
#include<sys/time.h>
#include<sys/types.h>
#include<unistd.h>
#include"wrap.h"
#include<sys/socket.h>
#include<stdio.h>
#include<string.h>
#include<arpa/inet.h>
#include<pthread.h>
#include<ctype.h>
#include<fcntl.h>
#include<poll.h>
#define MAXLINE 80
#define PORT 8000
#define OPEN_MAX 1024
int main()
{
int i,j,maxi,lfd,cfd,sockfd;
int nready; //接收poll返回值，记录发生事件的文件描述符个数
ssize_t n;
char buf[MAXLINE],str[INET_ADDRSTRLEN];
socklen_t clie_len;
struct pollfd client[OPEN_MAX];
struct sockaddr_in cliaddr,servaddr;
lfd=Socket(AF_INET,SOCK_STREAM,0);
int opt=1;
setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_port=htons(PORT);
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
Bind(lfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
Listen(lfd,128);
client[0].fd=lfd;
client[0].events=POLLIN;
for(int i=1;i<OPEN_MAX;i++)
{
client[i].fd=-1;
}
maxi=0;
while(1)
{
nready=poll(client,maxi+1,-1); //阻塞监听是否有客户端连接请求
if(client[0].revents & POLLIN)
{
printf("have a connect request\n");
clie_len=sizeof(cliaddr);
cfd=Accept(lfd,(struct sockaddr*)&cliaddr,&clie_len);
printf("success establishing connect request\n");
for(i=1;i<OPEN_MAX;i++)
{
if(client[i].fd<0)
{
client[i].fd=cfd; //找到client中空闲的位置，存放accept返回的cfd
client[i].events=POLLIN;
break;
}
}
if(i==OPEN_MAX) //达到了最大客户端数
{
perr_exit("too many clients");
}
if(i>maxi)
{
maxi=i; //更新client[]中最大元素下标
printf("maxi=%d\n",maxi);
}
// if(--nready<=0) //没有返回更多的就绪事件，
// {
// continue;
// }
}
printf("lfd success\n");
for(i=1;i<=maxi;i++)
{
printf("query cfd \n");
if((sockfd=client[i].fd)<0)
{
continue;
}
if(client[i].revents & POLLIN)
{
printf("have data to read\n");
if((n=Read(sockfd,buf,MAXLINE))<0)
{
if(errno==ECONNREFUSED) //受到RST标志
{
Close(sockfd);
client[i].fd=-1; //poll中不监控该文件描述符，
}
else{
perr_exit("read error");
}
}else if(n==0) //说明对端已经关闭
{
printf("read n= %ld bytes\n",n);
Close(sockfd);
client[i].fd=-1;
}else{
printf("read n bytes\n");
for(j=0;j<n;j++)
{
buf[j]=toupper(buf[j]);
}
Write(sockfd,buf,n);
Write(STDOUT_FILENO,buf,n);
}
if(--nready<=0)
{
break;
}
}
}
}
return 0;
}
关于read的用法：
>0 : 实际读到的字节数
=0：socket中，表示对端关闭，close()
-1： 如果 errno==EINTR 被异常中断，需要重启
如果 errno==EAGIN 或 EWOULDBLOCK 以非阻塞的方式读取数据，但是没有数据，需要再次读
如果 errno == ECONNRESET 说明连接被重置，需要close()，移除检测队列
其他：错误
68.poll总结
poll的优缺点：
优点
1.自带数组结构，可以将检测事件和返回事件分离，
2.可以拓展监听上限，可以超出1024个限制
缺点：
不能跨平台，linux
无法直接定义发生事件的文件描述符。
p71突破1024文件描述符设置
linux系统里，最大打开的文件句柄数（也即是打开文件数最大限制值），按约定的单个进程能够打开的最大文件句柄数量，默认大小为：1024。
突破1024文件描述符限制：《即使这样修改对select函数也没用》
cat /proc/sys/fs/file-max -->单个进程所能打开的最大文件个数，受硬件影响 (内核级别）)
ulimit -a -->当前用户下的进程，默认打开文件描述符个数。缺省为1024；(用户级最大限制)
ulimit -n 10000 -->修改打开的文件描述符个数。只能往下调，往上调需要注销然后生效。
修改：
用户级的永久修改方法：
打开 sudo vi /etc/security/limits.conf 写入：
soft nofile 65535 -->设置默认值，注销用户，使其生效。
hard nofile 10000 -->命令修改上限
72.73epoll_create和epoll_ctl和epoll_wait
epoll:
int epoll_create(int size)；//创建一颗用于检测的红黑树
size：创建的红黑树的检测节点数量(仅供内核参考)
返回值：指向新创建的红黑树的根节点的epfd；
-1 errno 失败
------------------------------------------------------------------------------------------------------------------------------------
int epoll_ctl(int epfd,int op,int fd,struft epoll_event*event);//操作用于检测的红黑树
epfd：epoll_create函数返回值，红黑数的根节点
op：对红黑树所做的操作
EPOLL_CTL_ADD ：将fd添加到检测的红黑树上
EPOLL_CTL_MOD：修改fd在红黑树上的检测事件
EPOLL_CTL_DEL： 将一个fd从红黑树上摘下
fd：待检测的fd
event：本质上是 struft epoll_event 结构体 的地址
struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};
events：EPOLLIN，EPOLLOUT，EPOLLRDHUP，对fd所要检测的事件。
data： 联合体；
typedef union epoll_data {
void *ptr; //回调函数，程序运行到这里，自动调用回调函数。
int fd; //对应检测事件的fd
uint32_t u32;
uint64_t u64;
} epoll_data_t;
返回值：成功0，失败-1 ，errno
--------------------------------------------------------------------------------------------------------------------------
//阻塞监听
int epoll_wait(int epfd, struct epoll_event *events,
int maxevents, int timeout);
epfd：epoll_create函数的返回值，
events：传出参数【数组】，满足检测事件的fd的结构体
maxevents：数组，元素总个数1024
struct epoll_event events[1024]
timeout：
-1：阻塞
0：不阻塞
>0:超时时间
返回值：
>0 ：满足监听的总个数，可以用作循环上限
0：没有fd满足监听事件。
-1：失败
代码实现：
#include<sys/select.h>
#include<sys/time.h>
#include<sys/types.h>
#include<unistd.h>
#include"wrap.h"
#include<sys/socket.h>
#include<stdio.h>
#include<string.h>
#include<arpa/inet.h>
#include<pthread.h>
#include<ctype.h>
#include<fcntl.h>
#include<sys/epoll.h>
#define MAXLINE 80
#define PORT 8000
#define OPEN_MAX 1024
int main()
{
int i,lfd,cfd,sockfd;
int n,num=0;
ssize_t nready,efd,res;
char buf[MAXLINE],str[INET_ADDRSTRLEN];
socklen_t clie_len;
struct sockaddr_in cliaddr,servaddr;
struct epoll_event tep,ep[OPEN_MAX];
lfd=Socket(AF_INET,SOCK_STREAM,0);
int opt=1;
setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_port=htons(PORT);
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
Bind(lfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
Listen(lfd,128);
efd=epoll_create(OPEN_MAX); //创建epoll红黑树，efd指向红黑树根节点
if(efd==-1)
{
perr_exit("epoll create error");
}
tep.events=EPOLLIN; //指定 lfd 的监听事件为读。
tep.data.fd=lfd;
res=epoll_ctl(efd,EPOLL_CTL_ADD,lfd,&tep); //将lfd及对应的结构体设置到树上，efd可找到该树。
if(res==-1)
{
perr_exit("epoll_ctl error");
}
while(1)
{
//epoll为server阻塞监听事件，ep为struct epoll_event 类型数组，open_max为数组容量，-1表示永久阻塞
nready=epoll_wait(efd,ep,OPEN_MAX,-1);
if(nready==-1)
{
perr_exit("epoll_wait error");
}
for(i=0;i<nready;i++)
{
if(!(ep[i].events & EPOLLIN)) //如果不是读事件，继续循环
{
continue;
}
if(ep[i].data.fd==lfd)
{
clie_len=sizeof(cliaddr);
cfd=Accept(lfd,(struct sockaddr*)&cliaddr,&clie_len);
printf("received from %s at port %d\n",inet_ntop(AF_INET,&cliaddr.sin_addr.s_addr,str,sizeof(str)),ntohs(cliaddr.sin_port));
printf("cfd %d --- client %d\n",cfd,++num);
tep.events=EPOLLIN;
tep.data.fd=cfd;
res=epoll_ctl(efd,EPOLL_CTL_ADD,cfd,&tep);
if(res==-1)
{
perr_exit("epoll ctl error");
}
}
else{
sockfd=ep[i].data.fd;
n=Read(sockfd,buf,MAXLINE);
if(n==0)
{
res=epoll_ctl(efd,EPOLL_CTL_DEL,sockfd,NULL);
if(res==1)
{
perr_exit("epoll_ctl error");
}
Close(sockfd);
printf("client [%d] closed connection \n",sockfd);
}else if(n<0)
{
perror("read n<0 error:");
res=epoll_ctl(efd,EPOLL_CTL_DEL,sockfd,NULL);
Close(sockfd);
}
else{
for(i=0;i<n;i++)
{
buf[i]=toupper(buf[i]);
}
Write(STDOUT_FILENO,buf,n);
Write(sockfd,buf,n);
}
}
}
}
Close(lfd);
}
75.ET和LT模式
ET模式，边沿触发：
缓冲区剩余未读尽的数据不会导致epoll_wait返回。
新的事件满足时，才会触发。
LT模式，水平触发：
缓冲区剩余未读尽的数据会导致epoll_wait返回。
//边沿触发模式
#include<sys/epoll.h>
#include<stdlib.h>
#include<stdio.h>
#include<errno.h>
#include<unistd.h>
#define MAXLINE 10
int main(int argc,char *argv[])
{
int efd,i;
int pfd[2];
pid_t pid;
char buf[MAXLINE],ch='a';
pipe(pfd);
pid=fork();
//子进程 写数据
if(pid==0)
{
close(pfd[0]);
while(1)
{
for(i=0;i<MAXLINE/2;i++)
{
buf[i]=ch;
}
buf[i-1]='\n';
ch++;
for(;i<MAXLINE;i++)
{
buf[i]=ch;
}
buf[i-1]='\n';
ch++;
write(pfd[1],buf,sizeof(buf));
sleep(5);
}
close(pfd[1]);
}else if(pid>0)
{
struct epoll_event event;
struct epoll_event revent[10];
int res,len;
close(pfd[1]);
efd=epoll_create(10);
event.data.fd=pfd[0];
event.events=EPOLLIN|EPOLLET; //ET边沿触发模式
//event.events=EPOLLIN; //LT水平触发模式
epoll_ctl(efd,EPOLL_CTL_ADD,pfd[0],&event);
while(1)
{
res=epoll_wait(efd,revent,10,-1);
printf("res = %d\n",res);
if(revent[0].data.fd==pfd[0])
{
len=read(pfd[0],buf,MAXLINE/2);
write(STDOUT_FILENO,buf,len);
}
}
close(pfd[0]);
close(efd);
}else{
perror("fork");
exit(-1);
}
}
76.网络中的ET和LT模式
。。。略。。。
77.epoll的ET非阻塞模式
epoll的ET模式，高效模式，但是只支持非阻塞模式。
readn调用的阻塞，比如设定读500个字符，但是只读到498，完事儿阻塞了，等另剩下的2个字符，然而在server代码里，一旦read变为readn阻塞了，进程就会阻塞在readn函数上，因为epoll_wait因为readn的阻塞不会循环执行，读不到新数据。有点死锁的意思，差俩字符所以阻塞，因为阻塞，读不到新字符。
如果将通信的文件描述符设置为非阻塞，就不会阻塞在readn函数上，等有数据重新进来了，epoll_wait重新触发，重新readn。
#include<sys/select.h>
#include<sys/time.h>
#include<sys/types.h>
#include<unistd.h>
#include"wrap.h"
#include<sys/socket.h>
#include<stdio.h>
#include<string.h>
#include<arpa/inet.h>
#include<pthread.h>
#include<ctype.h>
#include<fcntl.h>
#include<sys/epoll.h>
#define MAXLINE 80
#define PORT 8000
int main()
{
int i,lfd,cfd,sockfd;
int n,num=0;
int flag;
ssize_t nready,efd,res;
char buf[MAXLINE],str[INET_ADDRSTRLEN];
struct sockaddr_in cliaddr,servaddr;
socklen_t clie_len;
clie_len=sizeof(cliaddr);
lfd=Socket(AF_INET,SOCK_STREAM,0);
int opt=1;
setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_port=htons(PORT);
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
Bind(lfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
Listen(lfd,128);
///
struct epoll_event event; //ctl添加事件到红黑树中
struct epoll_event res_event[10]; //wait,返回检测到发生的事件
int res,len;
efd=epoll_create(10); //创建一颗红黑树
cfd=Accept(lfd,(struct sockaddr*)&cliaddr,&clie_len);
//读数据非阻塞。套接字文件描述符设置为非阻塞状态
flag=fcntl(cfd,F_GETFL); //修改cfd为非阻塞读
flag|=O_NONBLOCK;
fcntl(cfd,F_SETFL,flag);
//构建节点
event.data.fd=cfd;
event.events=EPOLLIN|EPOLLET; //ET边沿触发，默认是水平触发
epoll_ctl(efd,EPOLL_CTL_ADD,cfd,&event); //将节点添加到红黑树上
while(1)
{
printf("epoll_wait begin\n");
res=epoll_wait(efd,res_event,10,-1); //最多10个，非阻塞监听。
printf("epoll_wait end res %d\n",res);
if(res_event[0].data.fd==cfd)
{
//读到数据了才会一直读，
while((len=read(cfd,buf,MAXLINE/2))>0)
{
write(STDOUT_FILENO,buf,len);
}
}
}
return 0;
}
77.epoll的优缺点
优点：高效
缺点：不能跨平台，只能在linux操作系统中使用。
对比 ET 和 LT
水平触发模式（LT）：客户端写入500个字节到服务端，服务器读取300字节，然后读取剩下200字节
边沿触发模式（ET）：客户端写入500个字节到服务端，不需要全部读，只需要读200字节。
举例：属性信息，存储在文件头值中。
80epoll反应堆
epoll反应堆模型 ：ET模型+非阻塞+void*ptr，自动调用回调函数
event：本质上是 struft epoll_event 结构体 的地址
struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};
events：EPOLLIN，EPOLLOUT，EPOLLRDHUP，对fd所要检测的事件。
data： 联合体；(共同体)
typedef union epoll_data {
void *ptr; //
int fd; //对应检测事件的fd
uint32_t u32;
uint64_t u64;
} epoll_data_t;
联合体：共同体，共同使用一块内存空间。可以用ptr取代fd。
struct evt{
int fd;
void (*func)(int a);//回调函数
}*ptr;
回调函数：满足的时候自动调用。
原来：
socket bind listen –
epoll_create 创建检测 红黑树 – 返回 epfd（红黑树的根节点） –
epoll_ctl()向树上添加一个需要检测的fd –
epoll_wait检测事件 – 检测的fd有事件产生 – 返回 有事件发生的数组 – 判断返回数组中的fd，–
如果是lfd满足 – Accpet –
如果是cfd满足 – read() – 小->大 – write回去。
**反应堆：**不仅要监听cfd的读事件，还要监听cfd的写事件。
epoll反应堆模型 ：ET模型+非阻塞、轮询+void*ptr，自动调用回调函数
socket bind listen –
epoll_create 创建检测 红黑树 – 返回 epfd（红黑树的根节点） –
epoll_ctl()向树上添加一个需要检测的fd –
epoll_wait检测事件 – 对应检测的fd有事件产生 – 返回 有事件发生的数组 –
如果是lfd满足 – Accpet –
如果是cfd满足 – read() – 小->大 –
将cfd从检测的红黑树上摘下 -- 检测epollout -- 回调函数 -- 调用epoll_ctl(ADD)重新放到红黑树上监听写事件 -- 等待epoll_wait返回 -- 说明cfd可写 – write回去 – （epoll_ctl()函数检测 cfd 的写事件）
将cfd从检测的红黑树上摘下 – – 检测epollin – epoll_wait监听-- 调用epoll_ctl(ADD)重新放到红黑树上监听读事件（epoll_ctl()函数检测 cfd 的读事件 ）
/*
*epoll基于非阻塞I/O事件驱动，反应堆模型
*/
/*
*epoll基于非阻塞I/O事件驱动，反应堆模型
*/
#include <stdio.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#define MAX_EVENTS 1024 //监听上限数
#define BUFLEN 4096
#define SERV_PORT 8080
void recvdata(int fd, int events, void *arg);
void senddata(int fd, int events, void *arg);
/* 描述就绪文件描述符相关信息 */
//void *ptr里就是传的这个结构，
struct myevent_s {
int fd; //要监听的文件描述符
int events; //对应的监听事件
void *arg; //泛型参数
void (*call_back)(int fd, int events, void *arg); //回调函数
int status; //是否在监听:1->在红黑树上(监听), 0->不在(不监听)
char buf[BUFLEN];
int len;
long last_active; //记录每次加入红黑树 g_efd 的时间值
};
int g_efd; //全局变量, 保存epoll_create返回的文件描述符
struct myevent_s g_events[MAX_EVENTS+1]; //自定义结构体类型数组. +1-->listen fd
/*将结构体 myevent_s 成员变量 初始化*/
//eventset(&g_events[MAX_EVENTS], lfd, acceptconn, &g_events[MAX_EVENTS]);
void eventset(struct myevent_s *ev, int fd, void (*call_back)(int, int, void *), void *arg)
{
ev->fd = fd;
ev->call_back = call_back;
ev->events = 0; //这个阶段还未初始化。
ev->arg = arg;
ev->status = 0; //状态信息，是否在监听树上。
memset(ev->buf, 0, sizeof(ev->buf)); //buf进行初始化。
ev->len = 0;
ev->last_active = time(NULL); //调用eventset函数的时间
return;
}
/* 向 epoll监听的红黑树 添加一个 文件描述符 */
//eventadd(efd, EPOLLIN, &g_events[MAX_EVENTS]); //
void eventadd(int efd, int events, struct myevent_s *ev)
{
struct epoll_event epv = {0, {0}};
int op;
epv.data.ptr = ev;
epv.events = ev->events = events; //EPOLLIN 或 EPOLLOUT
if (ev->status == 0) { //已经在红黑树 g_efd 里
op = EPOLL_CTL_ADD; //将其加入红黑树 g_efd, 并将status置1
ev->status = 1;
}
if (epoll_ctl(efd, op, ev->fd, &epv) < 0) //实际添加/修改
printf("event add failed [fd=%d], events[%d]\n", ev->fd, events);
else
printf("event add OK [fd=%d], op=%d, events[%0X]\n", ev->fd, op, events);
return ;
}
/* 从epoll 监听的 红黑树中删除一个 文件描述符*/
void eventdel(int efd, struct myevent_s *ev)
{
struct epoll_event epv = {0, {0}};
if (ev->status != 1) //不在红黑树上
return ;
//epv.data.ptr = ev;
epv.data.ptr = NULL;
ev->status = 0; //修改状态
epoll_ctl(efd, EPOLL_CTL_DEL, ev->fd, &epv); //从红黑树 efd 上将 ev->fd 摘除
return ;
}
/* 当有文件描述符就绪, epoll返回, 调用该函数 与客户端建立链接 */
void acceptconn(int lfd, int events, void *arg)
{
struct sockaddr_in cin; //要连接的客户端的地址结构
socklen_t len = sizeof(cin);
int cfd, i;
if ((cfd = accept(lfd, (struct sockaddr *)&cin, &len)) == -1) {
if (errno != EAGAIN && errno != EINTR) {
/* 暂时不做出错处理 */
}
printf("%s: accept, %s\n", __func__, strerror(errno));
return ;
}
do {
for (i = 0; i < MAX_EVENTS; i++) //从全局数组g_events中找一个空闲元素
if (g_events[i].status == 0) //寻找一个空闲的 //类似于select中找值为-1的元素
break; //跳出 for
if (i == MAX_EVENTS) {
printf("%s: max connect limit[%d]\n", __func__, MAX_EVENTS);//__func__：当前函数的名字 __LINE__行号
break; //跳出do while(0) 不执行后续代码
}
int flag = 0;
if ((flag = fcntl(cfd, F_SETFL, O_NONBLOCK)) < 0) { //将cfd也设置为非阻塞
printf("%s: fcntl nonblocking failed, %s\n", __func__, strerror(errno));
break;
}
/* 给cfd设置一个 myevent_s 结构体, 回调函数 设置为 recvdata */
eventset(&g_events[i], cfd, recvdata, &g_events[i]);
eventadd(g_efd, EPOLLIN, &g_events[i]); //将cfd添加到红黑树g_efd中,监听读事件
} while(0);
printf("new connect [%s:%d][time:%ld], pos[%d]\n",
inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), g_events[i].last_active, i);
return ;
}
//read -- recv；read应用场景更加广泛，recv只能应用于网络
//write -- send;
void recvdata(int fd, int events, void *arg)
{
struct myevent_s *ev = (struct myevent_s *)arg;
int len;
//recv参数： flag==0 相当于read函数。
len = recv(fd, ev->buf, sizeof(ev->buf), 0); //读文件描述符, 数据存入myevent_s成员buf中
eventdel(g_efd, ev); //将该节点从红黑树上摘除
if (len > 0) {
ev->len = len;
ev->buf[len] = '\0'; //手动添加字符串结束标记
printf("C[%d]:%s\n", fd, ev->buf);
eventset(ev, fd, senddata, ev); //设置该 fd 对应的回调函数为 senddata
eventadd(g_efd, EPOLLOUT, ev); //将fd加入红黑树g_efd中,监听其写事件
} else if (len == 0) {
close(ev->fd);
/* ev-g_events 地址相减得到偏移元素位置 */
printf("[fd=%d] pos[%ld], closed\n", fd, ev-g_events);
} else {
close(ev->fd);
printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
}
return;
}
void senddata(int fd, int events, void *arg)
{
struct myevent_s *ev = (struct myevent_s *)arg;
int len;
len = send(fd, ev->buf, ev->len, 0); //直接将数据 回写给客户端。未作处理
eventdel(g_efd, ev); //从红黑树g_efd中移除
if (len > 0) {
printf("send[fd=%d], [%d]%s\n", fd, len, ev->buf);
eventset(ev, fd, recvdata, ev); //将该fd的 回调函数改为 recvdata
eventadd(g_efd, EPOLLIN, ev); //从新添加到红黑树上， 设为监听读事件
} else {
close(ev->fd); //关闭链接
printf("send[fd=%d] error %s\n", fd, strerror(errno));
}
return ;
}
/*创建 socket, 初始化lfd */
void initlistensocket(int efd, short port)
{
struct sockaddr_in sin;
int lfd = socket(AF_INET, SOCK_STREAM, 0);
fcntl(lfd, F_SETFL, O_NONBLOCK); //将socket设为非阻塞
memset(&sin, 0, sizeof(sin)); //bzero(&sin, sizeof(sin))
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = htons(port);
bind(lfd, (struct sockaddr *)&sin, sizeof(sin));
listen(lfd, 20);
/* void eventset(struct myevent_s *ev, int fd, void (*call_back)(int, int, void *), void *arg); */
eventset(&g_events[MAX_EVENTS], lfd, acceptconn, &g_events[MAX_EVENTS]);
//最后一个参数和第一个参数相同，回调函数在调用的时候，将本身作为参数传入。
//设置回调函数，lfd --> acceptconn
// cfd --> revdata()
/* void eventadd(int efd, int events, struct myevent_s *ev) */
eventadd(efd, EPOLLIN, &g_events[MAX_EVENTS]); // 将lfd添加到efp黑红树中。
//将一个fd 添加到红黑树上，设置监听 read事件，还是监听 write事件。
return ;
}
int main(int argc, char *argv[])
{
unsigned short port = SERV_PORT;
if (argc == 2)
port = atoi(argv[1]); //使用用户指定端口.如未指定,用默认端口
g_efd = epoll_create(MAX_EVENTS+1); //创建红黑树,返回给全局 g_efd
if (g_efd <= 0)
printf("create efd in %s err %s\n", __func__, strerror(errno));
initlistensocket(g_efd, port); //初始化监听socket
struct epoll_event events[MAX_EVENTS+1]; //保存已经满足就绪事件的文件描述符数组
printf("server running:port[%d]\n", port);
int checkpos = 0, i;
while (1) {
/* 超时验证，每次测试100个链接，不测试listenfd 当客户端60秒内没有和服务器通信，则关闭此客户端链接 */
long now = time(NULL); //当前时间
for (i = 0; i < 100; i++, checkpos++) { //一次循环检测100个。 使用checkpos控制检测对象
if (checkpos == MAX_EVENTS)
checkpos = 0;
if (g_events[checkpos].status != 1) //不在红黑树 g_efd 上
continue;
long duration = now - g_events[checkpos].last_active; //客户端不活跃的世间
if (duration >= 60) {
close(g_events[checkpos].fd); //关闭与该客户端链接
printf("[fd=%d] timeout\n", g_events[checkpos].fd);
eventdel(g_efd, &g_events[checkpos]); //将该客户端 从红黑树 g_efd移除
}
}
/*监听红黑树g_efd, 将满足的事件的文件描述符加至events数组中, 1秒没有事件满足, 返回 0*/
int nfd = epoll_wait(g_efd, events, MAX_EVENTS+1, 1000);
if (nfd < 0) {
printf("epoll_wait error, exit\n");
break;
}
for (i = 0; i < nfd; i++) {
/*使用自定义结构体myevent_s类型指针, 接收 联合体data的void *ptr成员*/
struct myevent_s *ev = (struct myevent_s *)events[i].data.ptr; //名字太长了，这一步只是换个名字
//event.events=EPOLLIN|EPOLLET; //ET边沿触发模式
//event.events=EPOLLIN; //LT水平触发模式
//epoll中如何指定监听读事件还是写事件
//EPOLLIN：表示对应的文件描述符可读(包括对端socket正常关闭)。EPOLLOUT:表示对应的文件描述符可写
if ((events[i].events & EPOLLIN) && (ev->events & EPOLLIN)) { //读就绪事件
ev->call_back(ev->fd, events[i].events, ev->arg); //就是这里才调用回调函数的？？？
//lfd EPOLLIN 将回调函数需要的参数传入。
}
if ((events[i].events & EPOLLOUT) && (ev->events & EPOLLOUT)) { //写就绪事件
ev->call_back(ev->fd, events[i].events, ev->arg);
}
}
}
/* 退出前释放所有资源 */
return 0;
}
90.ctags的使用
查看代码的工具
查询本机是否安装
sudo aptitude show ctags
sudo aptitude show exuberant-ctags
安装命令
sudo apt-get install exuberant-ctags
生成一个tags文件，组织目录内所有的.c间函数调用关系
生成方法 1.在项目目录，ctags ./*.R
2.在任意一个文件内使用ctrl+p创建tags
命令：
ctrl + ] 光标放置于调用函数上，跳转至函数定义位置
ctrl + t 返回到此前跳转位置
ctrl + o 在屏幕左边列出文件列表，再次ctrl + o关闭
F4 在屏幕右边列出函数列表，再次F4关闭
2388
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
