Libevent的bufferevent事件(三)
一、什么是bufferevent事件
bufferevent实际上也是一个event，只不过比普通的event高级一些，它的内部有两个缓冲区，以及一个文件描述符(网络套接字)。我们都知道一个网络套接字有读和写两个缓冲区，bufferevent同样也带有两个缓冲区，还有就是libevent事件驱动的核心回调函数，那么四个缓冲区以及触发回调的关系如下所示：
有三个回调函数：
- 读回调：当bufferevent将底层读缓冲区的数据读到自身的读缓冲区时触发读事件回调
- 写回调：当bufferevent将自身写缓冲区的数据写到底层写缓冲区的时候触发写事件回调
- 事件回调：当bufferevent绑定的socket连接，断开或者异常的时候触发事件回调
二、主要使用的函数
1.bufferevent_socket_new函数
struct bufferevent *bufferevent_socket_new(struct event_base *base, evutil_socket_t fd, int options);
bufferevent_socket_new对已经存在的socket创建bufferevent事件，参数说明：
- base：对应根节点
- fd：文件描述符
- options：bufferevent的选项
- BEV_OPT_CLOSE_ON_FREE：释放bufferevent自动关闭底层接口
- BEV_OPT_THREADSTAFE：使bufferevent能够在多线程下是安全的
返回值：新建节点的地址
2.bufferevent_socket_connect函数
int bufferevent_socket_connect(struct bufferevent *bev, struct sockaddr *serv, int socklen);
bufferevent_socket_connect封装了底层的socket与connect接口，通过调用此函数，可以将bufferevent事件与通信的socket进行绑定，参数如下：
- bev：需要提前初始化的bufferevent事件
- serv：对端的ip地址，端口，协议的结构指针
- socklen：描述serv的长度
3.bufferevent_free函数
void bufferevent_free(struct bufferevent *bufev);
释放bufferevent
4. bufferevent_setcb函数
void bufferevent_setcb(struct bufferevent *bufev, bufferevent_data_cb readcb, bufferevent_data_cb writecb, bufferevent_event_cb eventcb, void *cbarg);
bufferevent_setcb用于设置bufferevent的回调函数，readcb，writecb，eventcb分别对应了读回调，写回调，事件回调，cbarg代表回调函数的参数。回调函数的原型：
typedef void (*bufferevent_data_cb)(struct bufferevent *bev, void *ctx); //读写回调 typedef void (*bufferevent_event_cb)(struct bufferevent *bev, short what, void *ctx); //事件回调
what对应的事件：
- BEV_EVENT_EOF：对方关闭连接
- BEV_EVENT_ERROR：出错
- BEV_EVENT_TIMEOUT：超时
- BEV_EVENT_CONNECTED：建立连接成功
5.bufferevent_write函数
int bufferevent_write(struct bufferevent *bufev, const void *data, size_t size);
bufferevent_write是将data的数据写到bufferevent的写缓冲区。
6.bufferevent_write_buffer函数
int bufferevent_write_buffer(struct bufferevent *bufev, struct evbuffer *buf);
bufferevent_write_buffer 是将数据写到写缓冲区另外一个写法，实际上bufferevent的内部的两个缓冲区结构就是struct evbuffer。
7.bufferevent_read函数
size_t bufferevent_read(struct bufferevent *bufev, void *data, size_t size);
bufferevent_read 是将bufferevent的读缓冲区数据读到data中，同时将读到的数据从bufferevent的读缓冲清除。
8.bufferevent_read_buffer函数
int bufferevent_read_buffer(struct bufferevent *bufev, struct evbuffer *buf);
bufferevent_read_buffer 将bufferevent读缓冲数据读到buf中，接口的另外一种。
9.bufferevent_enable和bufferevent_disable函数
int bufferevent_enable(struct bufferevent *bufev, short event); //EV_READ、EV_WRITE int bufferevent_disable(struct bufferevent *bufev, short event); //EV_READ、EV_WRITE
bufferevent_enable与bufferevent_disable是设置事件是否生效，如果设置为disable，事件回调将不会被触发。
三、链接监听器(evconnlistener)
链接监听器封装了底层的socket通信相关函数，比如socket，bind，listen，accept这几个函数。链接监听器创建后实际上相当于调用了socket，bind，listen，此时等待新的客户端连接到来，如果有新的客户端连接，那么内部先进行accept处理，然后调用用户指定的回调函数。
1.evconnlistener_new_bind函数
函数原型：
struct evconnlistener *evconnlistener_new_bind(struct event_base *base, evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,const struct sockaddr *sa, int socklen);
evconnlistener_new_bind是在当前没有套接字的情况下对链接监听器进行初始化，看最后2个参数实际上就是bind使用的关键参数，backlog是listen函数的关键参数（略有不同的是，如果backlog是-1，那么监听器会自动选择一个合适的值，如果填0，那么监听器会认为listen函数已经被调用过了），ptr是回调函数的参数，cb是有新连接之后的回调函数，但是注意这个回调函数触发的时候，链接器已经处理好新连接了，并将与新连接通信的描述符交给回调函数。
参数如下：
- base：base根节点
- cb：提取cfd后调用的回调
- ptr：传给回调的参数
- backlog：-1
- sa：绑定的地址信息
- socklen：sa的大小
Flags 需要参考几个值：
- LEV_OPT_LEAVE_SOCKETS_BLOCKING ：文件描述符为阻塞的
- LEV_OPT_CLOSE_ON_FREE： 释放时自动关闭
- LEV_OPT_REUSEABLE： 端口复用
- LEV_OPT_THREADSAFE： 分配锁，线程安全
返回值：链接监听器的地址
2. evconnlistener_new函数
函数原型：
struct evconnlistener *evconnlistener_new(struct event_base *base,evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,evutil_socket_t fd);
evconnlistener_new函数与前一个函数不同的地方在与后2个参数，使用本函数时，认为socket已经初始化好，并且bind完成，甚至也可以做完listen，所以大多数时候，我们都可以使用第一个函数。
3.回调函数evconnlistener_cb
typedef void (*evconnlistener_cb)(struct evconnlistener *evl, evutil_socket_t fd, struct sockaddr *cliaddr, int socklen, void *ptr);
主要回调函数fd参数会与客户端通信的描述符，并非是等待连接的监听的那个描述符，所以cliaddr对应的也是新连接的对端地址信息，已经是accept处理好的。
参数如下：
- 链接监听器的地址
- fd：cfd
- cliaddr：客户端的地址信息
- ptr：evconnlistener_new_bind传过来的参数
4.evconnlistener_free函数
函数原型：
void evconnlistener_free(struct evconnlistener *lev);
释放链接监听器
5.evconnlistener_enable函数
函数原型：
int evconnlistener_enable(struct evconnlistener *lev);
使链接监听器生效
6.evconnlistener_disable函数
函数原型：
int evconnlistener_disable(struct evconnlistener *lev);
使链接监听器失效
四、示例演示
bufferevent实现Server端代码：
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <signal.h>
#include <sys/socket.h>
#include <event2/bufferevent.h>
#include <event2/buffer.h>
#include <event2/listener.h>
#include <event2/util.h>
#include <event2/event.h>
static const char MESSAGE[] = "Hello, World!\n";
static const int PORT = 8000;
static void listener_cb(struct evconnlistener *, evutil_socket_t,struct sockaddr *, int socklen, void *);
static void conn_readcb(struct bufferevent *bev, void *user_data);
static void conn_writecb(struct bufferevent *, void *);
static void conn_eventcb(struct bufferevent *, short, void *);
static void signal_cb(evutil_socket_t, short, void *);
int main() {
struct event_base *base;
struct evconnlistener *listener;
struct event *signal_event;
struct sockaddr_in sin = {0};
base = event_base_new();//创建evnet_base根节点
if (!base) {
fprintf(stderr, "Could not initialize libevent!\n");
return 1;
}
sin.sin_family = AF_INET;
sin.sin_port = htons(PORT);
//创建链接侦听器
listener = evconnlistener_new_bind(base, listener_cb, (void *)base,
LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, -1,
(struct sockaddr*)&sin,
sizeof(sin));
if (!listener) {
fprintf(stderr, "Could not create a listener!\n");
return 1;
}
//创建信号触发的节点
signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base);
//将信号节点上树
if (!signal_event || event_add(signal_event, NULL)<0) {
fprintf(stderr, "Could not create/add a signal event!\n");
return 1;
}
//循环监听
event_base_dispatch(base);
evconnlistener_free(listener);//释放链接侦听器
event_free(signal_event);//释放信号节点
event_base_free(base);//释放event_base根节点
printf("done\n");
return 0;
printf("Hello World!\n");
return 0;
}
static void listener_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *sa, int socklen, void *user_data) {
struct event_base *base = user_data;
struct bufferevent *bev;
//将fd上树，新建一个buffevent节点
bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
if (!bev) {
fprintf(stderr, "Error constructing bufferevent!");
event_base_loopbreak(base);
return;
}
//设置回调函数
bufferevent_setcb(bev, conn_readcb, conn_writecb, conn_eventcb, NULL);
bufferevent_enable(bev, EV_WRITE | EV_READ);//设置写事件使能
//bufferevent_disable(bev, EV_READ);//设置读事件非使能
//bufferevent_write(bev, MESSAGE, strlen(MESSAGE));
}
static void conn_readcb(struct bufferevent *bev, void *user_data) {
char buffer[1024] = {0};
int n = bufferevent_read(bev, buffer, sizeof(buffer));
printf("buffer=%s\n", buffer);
bufferevent_write(bev, buffer, n);
}
static void conn_writecb(struct bufferevent *bev, void *user_data) {
struct evbuffer *output = bufferevent_get_output(bev);
if (evbuffer_get_length(output) == 0) {
//printf("flushed answer\n");
//bufferevent_free(bev);//释放节点，自动关闭
}
}
static void conn_eventcb(struct bufferevent *bev, short events, void *user_data) {
if (events & BEV_EVENT_EOF) {
printf("Connection closed.\n");
} else if (events & BEV_EVENT_ERROR) {
printf("Got an error on the connection: %s\n",
strerror(errno));/*XXX win32*/
}
/* None of the other events can happen here, since we haven't enabled
* timeouts */
bufferevent_free(bev);
}
static void signal_cb(evutil_socket_t sig, short events, void *user_data) {
struct event_base *base = user_data;
struct timeval delay = { 2, 0 };
printf("Caught an interrupt signal; exiting cleanly in two seconds.\n");
event_base_loopexit(base, &delay);//退出循环监听
}
bufferevent实现客户端代码：
//bufferevent建立客户端的过程
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <event.h>
#include <event2/bufferevent.h>
#include <event2/buffer.h>
#include <event2/util.h>
#define PORT 8000
int tcp_connect_server(const char* server_ip, int port);
void cmd_msg_cb(int fd, short events, void* arg);
void server_msg_cb(struct bufferevent* bev, void* arg);
void event_cb(struct bufferevent *bev, short event, void *arg);
int main(int argc, char** argv) {
//创建根节点
struct event_base *base = event_base_new();
//创建并且初始化buffer缓冲区
struct bufferevent* bev = bufferevent_socket_new(base, -1,
BEV_OPT_CLOSE_ON_FREE);
//监听终端输入事件 设置标准输入的监控,设置回调是 cmd_msg_cb
struct event* ev_cmd = event_new(base, STDIN_FILENO,
EV_READ | EV_PERSIST,
cmd_msg_cb, (void*)bev);
printf("001\n");
//上树 开始监听标准输入的读事件
event_add(ev_cmd, NULL);
struct sockaddr_in server_addr;
memset(&server_addr, 0, sizeof(server_addr) );
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(PORT);
server_addr.sin_addr.s_addr= inet_addr("127.0.0.1");
//连接到 服务器ip地址和端口 初始化了 socket文件描述符 socket+connect
bufferevent_socket_connect(bev, (struct sockaddr *)&server_addr,
sizeof(server_addr));
//设置buffer的回调函数 主要设置了读回调 server_msg_cb ,传入参数是标准输入的读事件
bufferevent_setcb(bev, server_msg_cb, NULL, event_cb, (void*)ev_cmd);
bufferevent_enable(bev, EV_READ | EV_PERSIST);
printf("002\n");
event_base_dispatch(base);//循环等待
event_free(ev_cmd);
bufferevent_free(bev);
event_base_free(base);
printf("finished \n");
return 0;
}
//终端输入回调
void cmd_msg_cb(int fd, short events, void* arg) {
char msg[1024];
int ret = read(fd, msg, sizeof(msg));
if( ret < 0 )
{
perror("read fail ");
exit(1);
}
//得到bufferevent指针,目的是为了写到bufferevent的写缓冲区
struct bufferevent* bev = (struct bufferevent*)arg;
//把终端的消息发送给服务器端
bufferevent_write(bev, msg, ret);
}
void server_msg_cb(struct bufferevent* bev, void* arg) {
printf("001\n");
char msg[1024];
size_t len = bufferevent_read(bev, msg, sizeof(msg));
msg[len] = '\0';
printf("002\n");
printf("recv %s from server\n", msg);
}
void event_cb(struct bufferevent *bev, short event, void *arg) {
if (event & BEV_EVENT_EOF)
printf("connection closed\n");
else if (event & BEV_EVENT_ERROR)
printf("some other error\n");
else if ( event & BEV_EVENT_CONNECTED) {
printf("the client has connected to server\n");
return ;
}
//这将自动close套接字和free读写缓冲区
bufferevent_free(bev);
//释放event事件 监控读终端
struct event *ev = (struct event*)arg;
event_free(ev);
exit(0);
}
