文章目录
- libevent封装的框架思想
- 常用函数分析
- 使用fifo的读写
- 未决和非未决
- bufferevent特性
- bufferevent函数
- 客户端和服务器连接和监听
- libevent实现socket通信
libevent封装的框架思想
libevent框架：
1. 创建 event_base (乐高底座)
2. 创建 事件evnet
3. 将事件 添加到 base上
4. 循环监听事件满足
5. 释放 event_base
1. 创建 event_base (乐高底座)
struct event_base *event_base_new(void);
struct event_base *base = event_base_new();
2. 创建 事件evnet
常规事件 event --> event_new();
bufferevent --> bufferevent_socket_new();
3. 将事件 添加到 base上
int event_add(struct event *ev, const struct timeval *tv)
4. 循环监听事件满足
int event_base_dispatch(struct event_base *base);
event_base_dispatch(base);
5. 释放 event_base
event_base_free(base);
常用函数分析
创建事件event：
struct event *ev；
struct event *event_new(struct event_base *base，evutil_socket_t fd，short what，event_callback_fn cb; void *arg);
base： event_base_new()返回值。
fd： 绑定到 event 上的 文件描述符
what：对应的事件（r、w、e）
在 EV_READ 一次 读事件
EV_WRTIE 一次 写事件
EV_PERSIST 持续触发。 结合 event_base_dispatch 函数使用，生效。
cb：一旦事件满足监听条件，回调的函数。
typedef void (*event_callback_fn)(evutil_socket_t fd, short, void *)
arg： 回调的函数的参数。
返回值：成功创建的 event
事件event操作：
添加事件到 event_base
int event_add(struct event *ev, const struct timeval *tv);
ev: event_new() 的返回值。
tv：为NULL，不会超时。意为：一直等到事件被触发，回调函数会被调用。
为非0，等待期间，检查事件没有被触发，时间到，回调函数依旧会被调用。
将事件从base上拿下
int event_del(struct event *ev);
ev: event_new() 的返回值。
释放事件
int event_free(struct event *ev);
ev: event_new() 的返回值。
使用fifo的读写
read.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
#include <event2/event.h>
// 对操作处理函数
void read_cb(evutil_socket_t fd, short what, void *arg)
{
// 读管道
char buf[1024] = {0};
int len = read(fd, buf, sizeof(buf));
printf("read event: %s \n", what & EV_READ ? "Yes" : "No");
printf("data len = %d, buf = %s\n", len, buf);
sleep(1);
}
// 读管道
int main(int argc, const char* argv[])
{
unlink("myfifo");
//创建有名管道
mkfifo("myfifo", 0664);
// open file
//int fd = open("myfifo", O_RDONLY | O_NONBLOCK);
int fd = open("myfifo", O_RDONLY);
if(fd == -1)
{
perror("open error");
exit(1);
}
// 创建个event_base
struct event_base* base = NULL;
base = event_base_new();
// 创建事件
struct event* ev = NULL;
ev = event_new(base, fd, EV_READ | EV_PERSIST, read_cb, NULL);
// 添加事件
event_add(ev, NULL);
// 事件循环
event_base_dispatch(base); // while（1） { epoll();}
// 释放资源
event_free(ev);
event_base_free(base);
close(fd);
return 0;
}
write.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
#include <event2/event.h>
// 对操作处理函数
void write_cb(evutil_socket_t fd, short what, void *arg)
{
// write管道
char buf[1024] = {0};
static int num = 0;
sprintf(buf, "hello,world-%d\n", num++);
write(fd, buf, strlen(buf)+1);
sleep(1);
}
// 写管道
int main(int argc, const char* argv[])
{
// open file
//int fd = open("myfifo", O_WRONLY | O_NONBLOCK);
int fd = open("myfifo", O_WRONLY);
if(fd == -1)
{
perror("open error");
exit(1);
}
// 写管道
struct event_base* base = NULL;
base = event_base_new();
// 创建事件
struct event* ev = NULL;
// 检测的写缓冲区是否有空间写
//ev = event_new(base, fd, EV_WRITE , write_cb, NULL);
ev = event_new(base, fd, EV_WRITE | EV_PERSIST, write_cb, NULL);
// 添加事件
event_add(ev, NULL);
// 事件循环
event_base_dispatch(base);
// 释放资源
event_free(ev);
event_base_free(base);
close(fd);
return 0;
}
未决和非未决
非未决: 没有资格被处理
未决： 有资格被处理，但尚未被处理
event_new --> event ---> 非未决 --> event_add --> 未决 --> dispatch() && 监听事件被触发 --> 激活态
--> 执行回调函数 --> 处理态 --> 非未决 event_add && EV_PERSIST --> 未决 --> event_del --> 非未决
bufferevent特性
带缓冲区的事件 bufferevent
#include <event2/bufferevent.h>
读：有数据-->读回调函数被调用-->bufferevent_read()-->读数据
写：使用bufferevent_write()-->向写缓冲中写数据-->该缓冲区有数据自动写出-->写完，回调函数被调用
bufferevent函数
创建、销毁bufferevent：
struct bufferevent *ev；
struct bufferevent *bufferevent_socket_new(struct event_base *base, evutil_socket_t fd, enum bufferevent_options options);
base： event_base
fd: 封装到bufferevent内的 fd
options：BEV_OPT_CLOSE_ON_FREE
返回： 成功创建的 bufferevent事件对象。
void bufferevent_socket_free(struct bufferevent *ev);
给bufferevent设置回调：
对比event： event_new( fd, callback ); event_add() -- 挂到 event_base 上。
bufferevent_socket_new（base,fd） bufferevent_setcb（ callback ）
void bufferevent_setcb(struct bufferevent * bufev,
bufferevent_data_cb readcb,
bufferevent_data_cb writecb,
bufferevent_event_cb eventcb,
void *cbarg );
bufev： bufferevent_socket_new() 返回值
readcb： 设置 bufferevent 读缓冲，对应回调 read_cb{ bufferevent_read() 读数据 }
writecb： 设置 bufferevent 写缓冲，对应回调 write_cb { } -- 给调用者，发送写成功通知。 可以 NULL
eventcb： 设置 事件回调。 也可传NULL
events： BEV_EVENT_CONNECTED
cbarg： 上述回调函数使用的 参数。
event回调函数类型
typedef void (*bufferevent_event_cb)(struct bufferevent *bev, short events, void *ctx);
void event_cb(struct bufferevent *bev, short events, void *ctx)
{
...
}
read 回调函数类型：
typedef void (*bufferevent_data_cb)(struct bufferevent *bev, void*ctx);
void read_cb(struct bufferevent *bev, void *cbarg )
{
.....
bufferevent_read(); --- read();
}
bufferevent_read()函数的原型：
size_t bufferevent_read(struct bufferevent *bev, void *buf, size_t bufsize);
write 回调函数类型：
int bufferevent_write(struct bufferevent *bufev, const void *data, size_t size);
启动、关闭 bufferevent的 缓冲区：
默认：新建的bufferevent的写缓冲是 enable、读缓冲是 disable
void bufferevent_enable(struct bufferevent *bufev, short events); 启动
通常用来启动bufferevent的read缓冲
void bufferevent_disable(struct bufferevent *bufev, short events); 禁用
events： EV_READ、EV_WRITE、EV_READ|EV_WRITE
void bufferevent_get_enabled(struct bufferevent *bufev);
获取缓冲区的禁用状态，需要借助&来得到
客户端和服务器连接和监听
客户端：
socket();connect(fd,addr,addr_len);
int bufferevent_socket_connect(struct bufferevent *bev, struct sockaddr *address, int addrlen);
bev: bufferevent 事件对象（其中封装了fd）
address、addresslen：等同于 connect() 的第二个参数和第三个参数
创建监听服务器：
#include<event2/listener.h>
//这个函数相当于socket、bind、listen、accept的作用
struct evconnlistener *evconnlistener_new_bind (
struct event_base *base,
evconnlistener_cb cb,
void *ptr,
unsigned flags,
int backlog,
const struct sockaddr *sa,
int socklen);
base： event_base
cb: 回调函数。 一旦被回调，说明在其内部应该与客户端完成数据读写操作，进行通信。
ptr： 回调函数的参数
flags： 可识别的标志
LEV_OPT_CLOSE_ON_FREE：释放bufferevent时关闭底层传输端口。
这将关闭底层套接字、释放底层bufferevent等
LEV_OPT_REUSEABLE：端口服用
backlog： listen()的第2个参数。 -1 表最大值
sa：服务器自己的地址结构体
socklen：服务器自己的地址结构体大小。
返回值：成功创建的监听器。
回调函数类型：
typedef void(*evconnlistner_cb)(
struct evconnlistener *listener,
evutil_socket_t sock,
struct sockaddr* addr,
int len,
void *ptr);
listener: evconnlistener_new_bind函数返回值
sock: 用于通信的文件描述符
addr: 客户端的IP+端口
len: addr的len
ptr: 外部ptr传递进来的值
释放监听服务器:
void evconnlistener_free(struct evconnlistener *lev);
libevent实现socket通信
服务器端
server.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <event2/event.h>
#include <event2/listener.h>
#include <event2/bufferevent.h>
// 读缓冲区回调
void read_cb(struct bufferevent *bev, void *arg)
{
char buf[1024] = {0};
bufferevent_read(bev, buf, sizeof(buf));
printf("client say: %s\n", buf);
char *p = "我是服务器, 已经成功收到你发送的数据!";
// 发数据给客户端
bufferevent_write(bev, p, strlen(p)+1);
sleep(1);
}
// 写缓冲区回调
void write_cb(struct bufferevent *bev, void *arg)
{
printf("I'm服务器, 成功写数据给客户端,写缓冲区回调函数被回调...\n");
}
// 事件
void event_cb(struct bufferevent *bev, short events, void *arg)
{
if (events & BEV_EVENT_EOF)
{
printf("connection closed\n");
}
else if(events & BEV_EVENT_ERROR)
{
printf("some other error\n");
}
bufferevent_free(bev);
printf("buffevent 资源已经被释放...\n");
}
void cb_listener(
struct evconnlistener *listener,
evutil_socket_t fd,
struct sockaddr *addr,
int len, void *ptr)
{
printf("connect new client\n");
struct event_base* base = (struct event_base*)ptr;
// 通信操作
// 添加新事件
struct bufferevent *bev;
bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
// 给bufferevent缓冲区设置回调
bufferevent_setcb(bev, read_cb, write_cb, event_cb, NULL);
bufferevent_enable(bev, EV_READ);
}
int main(int argc, const char* argv[])
{
// init server
struct sockaddr_in serv;
memset(&serv, 0, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_port = htons(9876);
serv.sin_addr.s_addr = htonl(INADDR_ANY);
struct event_base* base;
base = event_base_new();
// 创建套接字
// 绑定
// 接收连接请求
struct evconnlistener* listener;
listener = evconnlistener_new_bind(base, cb_listener, base,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,
36, (struct sockaddr*)&serv, sizeof(serv));
event_base_dispatch(base);
evconnlistener_free(listener);
event_base_free(base);
return 0;
}
客户端
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <event2/bufferevent.h>
#include <event2/event.h>
#include <arpa/inet.h>
void read_cb(struct bufferevent *bev, void *arg)
{
char buf[1024] = {0};
bufferevent_read(bev, buf, sizeof(buf));
printf("fwq say:%s\n", buf);
bufferevent_write(bev, buf, strlen(buf)+1);
sleep(1);
}
void write_cb(struct bufferevent *bev, void *arg)
{
printf("----------我是客户端的写回调函数,没卵用\n");
}
void event_cb(struct bufferevent *bev, short events, void *arg)
{
if (events & BEV_EVENT_EOF)
{
printf("connection closed\n");
}
else if(events & BEV_EVENT_ERROR)
{
printf("some other error\n");
}
else if(events & BEV_EVENT_CONNECTED)
{
printf("已经连接服务器...\\(^o^)/...\n");
return;
}
// 释放资源
bufferevent_free(bev);
}
// 客户端与用户交互，从终端读取数据写给服务器
void read_terminal(evutil_socket_t fd, short what, void *arg)
{
// 读数据
char buf[1024] = {0};
int len = read(fd, buf, sizeof(buf));
struct bufferevent* bev = (struct bufferevent*)arg;
// 发送数据
bufferevent_write(bev, buf, len+1);
}
int main(int argc, const char* argv[])
{
struct event_base* base = NULL;
base = event_base_new();
int fd = socket(AF_INET, SOCK_STREAM, 0);
// 通信的fd放到bufferevent中
struct bufferevent* bev = NULL;
bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
// init server info
struct sockaddr_in serv;
memset(&serv, 0, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_port = htons(9876);
inet_pton(AF_INET, "127.0.0.1", &serv.sin_addr.s_addr);
// 连接服务器
bufferevent_socket_connect(bev, (struct sockaddr*)&serv, sizeof(serv));
// 设置回调
bufferevent_setcb(bev, read_cb, write_cb, event_cb, NULL);
// 设置读回调生效
// bufferevent_enable(bev, EV_READ);
// 创建事件
struct event* ev = event_new(base, STDIN_FILENO, EV_READ | EV_PERSIST,
read_terminal, bev);
// 添加事件
event_add(ev, NULL);
event_base_dispatch(base);
event_free(ev);
event_base_free(base);
return 0;
}
