简介

libevent是一个轻量级的开源的高性能的事件触发的网络库，适用于windows、linux、bsd等多种平台，内部使用select、epoll、kqueue等系统调用管理事件机制。

特点：

• 跨平台，支持Windows、Linux、BSD和Mac OS;
• 支持多种I/O多路复用技术（epoll、poll、dev/poll、select和kqueue等），在不同的操作系统下，做了多路复用模型的抽象，可以选择使用不同的模型，通过事件函数提供服务;
• 支持I/O，定时器和信号等事件;

采用Reactor模式;
libevent是一个典型的reactor模式的实现。

• 普通的函数调用机制：程序调用某个函数，函数执行，程序等待，函数将结果返回给调用程序（如果含有函数返回值的话），也就是顺序执行的。
• Reactor模式的基本流程：应用程序需要提供相应的接口并且注册到reactor反应器上，如果相应的事件发生的话，那么reactor将自动调用相应的注册的接口函数（类似于回调函数）通知你，所以libevent是事件触发的网络库。

libevent的功能

• Libevent提供了事件通知，io缓存事件，定时器，超时，异步解析dns，事件驱动的http server以及一个rpc框架。
• 事件通知：当文件描述符可读可写时将执行回调函数。
• IO缓存：缓存事件提供了输入输出缓存，能自动的读入和写入，用户不必直接操作io。
• 定时器：libevent提供了定时器的机制，能够在一定的时间间隔之后调用回调函数。
• 信号：触发信号，执行回调。
• 异步的dns解析：libevent提供了异步解析dns服务器的dns解析函数集。
• 事件驱动的http服务器：libevent提供了一个简单的，可集成到应用程序中的HTTP服务器。
• RPC客户端服务器框架：libevent为创建RPC服务器和客户端创建了一个RPC框架，能自动的封装和解封数据结构。

Linux下libevent主要API介绍

创建事件集

• struct event_base *event_base_new(void);

创建事件

• 参数: event_base_new的返回值 , 监听文件句柄 , 监听事件 , 回调函数 , 回调函数参数
• struct event event_new
  (struct event_base ,evutil_socket_t ,short ,event_callback_fn, void*)

添加事件

• 参数 :event_new的返回值 , 定时器
• int event_add(struct event * ev,const struct timeval* timeout)

删除事件

• 参数 :event_new的返回值
• int event_del(struct event *)

事件循环

• int event_base_loop(struct event_base *base, int flags)

• 参数:事件集

• int event_base_dispatch(struct event_base *event_base) //持续监听,这个常用

回声服务器的实现1

如果将文件设置成非阻塞，即便发现内容为空，也不会阻塞等待而是会直接返回

• 执行流程图
• 以下都是回调函数,当触发相应事件的时候就会回调函数
• 例如 accept_connection 函数 当读事件发送后,就会被调用
• 注意:服务器只有读事件
• 客户端:第一个事件是创建完毕后的写事件
  
  结果
  

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h> 
#include <unistd.h>
#include <event.h>
#include <event2/event.h>#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/stat.h>#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <assert.h>/* 回声服务器的实现 写完就读,读完就写*/typedef struct _ConnectStat  ConnectStat;#define BUFLEN  1024struct event_base * ev_base;struct _ConnectStat {struct event*  ev; // 用来保存fd在事件集上的事件int fd;char send_buf[BUFLEN];
};//echo 服务实现相关代码ConnectStat * stat_init(int fd);// 给fd进行赋值,并且给结构体开辟内存// 回调函数一定要符合格式要求// 创建客户端套接字,与客户端建立连接    读事件->写事件
void accept_connection(int fd, short events, void* arg);// 文件句柄 , 事件 , 参数// 向客户端发送欢迎                     写事件->读事件
void do_welcome_handler(int fd, short events, void* arg);// 参数:文件句柄 , 事件 , 参数// 读取客户端发送的数据                 读事件->写事件 
void do_echo_handler(int fd, short events, void *arg); // 读取// 向客户端发送已经处理好的数据         写事件->读事件
void do_echo_response(int fd, short events, void *arg);void usage(const char* argv)
{printf("%s:[ip][port]\\n", argv);
}/*如果将文件设置成非阻塞，即便发现内容为空，也不会阻塞等待而是会直接返回，
但是由于没有内容因此只能返回一个特殊数字-1，（数字0代表读到文件末尾），大于0就表示读到内容了*/
void set_nonblock(int fd)
{int fl = fcntl(fd, F_GETFL);fcntl(fd, F_SETFL, fl | O_NONBLOCK);
}int startup(char* _ip, int _port)  //创建一个套接字，绑定，检测服务器
{//sock//1.创建套接字int sock = socket(AF_INET, SOCK_STREAM, 0);if (sock < 0){perror("sock");exit(2);}int opt = 1;setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));//2.填充本地 sockaddr_in 结构体（设置本地的IP地址和端口）struct sockaddr_in local;local.sin_port = htons(_port);local.sin_family = AF_INET;local.sin_addr.s_addr = inet_addr(_ip);//3.bind（）绑定if (bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0){perror("bind");exit(3);}//4.listen（）监听 检测服务器if (listen(sock, 5) < 0){perror("listen");exit(4);}return sock;    //这样的套接字返回
}ConnectStat * stat_init(int fd) {ConnectStat * temp = NULL;temp = (ConnectStat *)malloc(sizeof(ConnectStat));if (!temp) {fprintf(stderr, "malloc failed. reason: %m\\n");return NULL;}memset(temp, '\\0', sizeof(ConnectStat));temp->fd = fd;//temp->status = 0;
}// 欢迎别人连接  arg就是ConnectStat类型
void do_welcome_handler(int fd, short events, void* arg){const char * WELCOME= "Welcome.\\n";int wlen = strlen(WELCOME);int n ;ConnectStat * stat = (ConnectStat *)(arg);if( (n = write(fd, "Welcome.\\n",wlen)) != wlen ){if(n<=0){fprintf(stderr, "write failed[len:%d], reason: %s\\n",n,strerror(errno));}else fprintf(stderr, "send %d bytes only ,need to send %d bytes.\\n",n,wlen);}else {// 设置事件属性// 参数: 对应文件描述符的事件 , 读事件 , 回调函数 , 回调函数参数event_set(stat->ev, fd, EV_READ, do_echo_handler, (void *)stat);stat->ev->ev_base = ev_base;//修改节点的时候ev_base被置空所以必须重置事件集合  设置红黑树event_add(stat->ev, NULL);// 把事件重写加入}
}// 处理客户端发来的数据
void do_echo_handler(int fd, short events, void *arg) {ConnectStat * stat = (ConnectStat *)(arg);char * p = NULL;assert(stat!=NULL);p = stat->send_buf; // 指向ConnectStat中send_buf,自己就不需要分配内存了*p++ = '-'; // 先添加一个 '->'*p++ = '>';// 此时 p-stat->send_buf == 2ssize_t _s = read(fd, p, BUFLEN-(p-stat->send_buf)-1); //减去 2字节"->" +字符结束符.if (_s > 0){*(p+_s) = '\\0';// 给字符串最后加上'\\0'printf("receive from client: %s\\n", p);if(!strncasecmp(p, "quit", 4)){//退出.event_free(stat->ev);//自动解除监听事件，释放event  从红黑树上摘除节点// 资源处理close(fd);free(stat);return ;}// 修改节点event_set(stat->ev, fd, EV_WRITE, do_echo_response, (void *)stat);stat->ev->ev_base = ev_base;//必须重置事件集合event_add(stat->ev, NULL);}else if (_s == 0)  //client:close{fprintf(stderr,"Remote connection[fd: %d] has been closed\\n", fd);event_free(stat->ev);//自动解除监听事件，释放event close(fd);free(stat);}else //err occurred.  出错处理暂时忽略{fprintf(stderr,"read faield[fd: %d], reason:%s [%d]\\n",fd , strerror(errno), _s);}
}// 把处理好的数据发送给客户端  改为监听读事件
void do_echo_response(int fd, short events, void *arg) {ConnectStat * stat = (ConnectStat *)(arg);int len = strlen(stat->send_buf);int _s = write(fd, stat->send_buf, len);if(_s>0){event_set(stat->ev, fd, EV_READ, do_echo_handler, (void *)stat);stat->ev->ev_base = ev_base;//必须重置事件集合event_add(stat->ev, NULL);}else if(_s==0){fprintf(stderr,"Remote connection[fd: %d] has been closed\\n", fd);event_free(stat->ev);//自动解除监听事件，释放event close(fd);free(stat);}else {fprintf(stderr,"read faield[fd: %d], reason:%s [%d]\\n",fd ,_s ,strerror(errno));}
}// 这里的参数fd可以区分每个客户端,arg可以用于保存客户端数据
// 当有客户端请求连接,就直接触发这个函数   改为监听写事件
void accept_connection(int fd, short events, void* arg){struct sockaddr_in peer;socklen_t len = sizeof(peer);int new_fd = accept(fd, (struct sockaddr*)&peer, &len);if (new_fd > 0){// 给stat分配内存并且给fd进行赋值ConnectStat *stat = stat_init(new_fd); // 初始化一个状态set_nonblock(new_fd);// 设置为非阻塞printf("new client: %s:%d\\n", inet_ntoa(peer.sin_addr), ntohs(peer.sin_port));// 参数: event_base_new的返回值 , 监听文件句柄 , 监听事件(往客户端写) , 回调函数 , 回调函数传入参数 // 一旦有事件来了就调用 do_welcome_handler 来处理请求struct event *ev = event_new(ev_base, new_fd, EV_WRITE, do_welcome_handler, (void *)stat);stat->ev = ev; // 创建完事件后,传入ConnectStat中// NULL:不进行超时处理event_add(ev, NULL);// 把节点加入红黑树}
}int main(int argc,char **argv){if (argc != 3)     //检测参数个数是否正确{usage(argv[0]);exit(1);}int listen_sock = startup(argv[1], atoi(argv[2]));      //创建一个绑定了本地 ip 和端口号的套接字描述符ev_base = event_base_new(); // 创建事件集ConnectStat * stat = stat_init(listen_sock); // 初始化一个状态// 创建节点// 参数: event_base_new的返回值 , 监听文件句柄 , 监听事件(读 | 只有有请求来了,就读) , 回调函数 , 回调函数传入参数 struct event* ev_listen = event_new(ev_base, listen_sock, EV_READ|EV_PERSIST, accept_connection, NULL);// 创建一个事件event_add(ev_listen, NULL);// 增加节点event_base_dispatch(ev_base);// 循环处理事件return 0;
}

回声服务器的实现2

需求：客户端从控制台逐行输入数据，按回车键后将数据发送给服务器端，服务器端收到请求后，再将收到的数据回传给客户端显示.

• 这里使用的接口可能和上一个不一样,但是可以达到相同效果
• 先看一下效果吧
  
  sever.c

evutil_make_socket_nonblocking(sockfd);// 设为非阻塞

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>#include <unistd.h>
#include <event.h>
#include <event2/event.h>
#include <assert.h> #define BUFLEN  1024typedef struct _ConnectStat {struct event*  ev; // 文件句柄对应事件char buf[BUFLEN];// 回传数据
}ConnectStat;//echo 服务实现相关代码
ConnectStat * stat_init(int fd, struct event *ev);// 客户端事件加入事件集
void accept_connection(int fd, short events, void* arg);// 读取客户端发送数据
void do_echo_request(int fd, short events, void *arg);// 向客户端发送数据
void do_echo_response(int fd, short events, void *arg);// 初始化
int tcp_server_init(int port, int listen_num);// port绑定的端口 listen_num支持的并发数量struct event_base* base;int main(int argc, char** argv)
{int listener = tcp_server_init(9999, 10);if( listener == -1 ){perror(" tcp_server_init error ");return -1;}base = event_base_new(); // 创建一个事件集//添加监听客户端请求连接事件// 参数: event_base_new的返回值 , 监听文件句柄 , 监听事件(读 | 持续监听) , 回调函数 , 回调函数传入参数 struct event* ev_listen = event_new(base, listener, EV_READ | EV_PERSIST,accept_connection, base);event_add(ev_listen, NULL);// 加入红黑树节点event_base_dispatch(base);// 循环处理事件return 0;
}ConnectStat * stat_init(int fd, struct event *ev) {ConnectStat * temp = NULL;temp = (ConnectStat *)malloc(sizeof(ConnectStat));if (!temp) {fprintf(stderr, "malloc failed. reason: %m\\n");return NULL;}memset(temp, '\\0', sizeof(ConnectStat));temp->ev = ev;}// 客户端事件加入事件集  把客户端设为读事件
void  accept_connection(int fd, short events, void* arg)
{evutil_socket_t sockfd;struct sockaddr_in client;socklen_t len = sizeof(client);sockfd = accept(fd, (struct sockaddr*)&client, &len );evutil_make_socket_nonblocking(sockfd);// 设为非阻塞printf("accept a client %d\\n", sockfd);struct event_base* base = (struct event_base*)arg; // arg 为事件集/第二种创建一个事件加入信号集///仅仅是为了动态创建一个event结构体struct event *ev = event_new(NULL, -1, 0, NULL, NULL);// 创建一个事件ConnectStat *stat = stat_init(sockfd, ev);//将动态创建的结构体作为event的回调参数// 参数:事件 事件集 客户端文件描述符 监听事件 回调函数 回调函数参数event_assign(ev, base, sockfd, EV_READ ,do_echo_request, (void*)stat);event_add(ev, NULL);// 加入节点
}// 读取客户端发送的数据
void do_echo_request(int fd, short events, void *arg)
{ConnectStat *stat = (ConnectStat *)arg;struct event *ev = stat->ev;char *msg = stat->buf;printf("do echo request ...\\n");int len = read(fd, msg, BUFLEN - 1);if( len <= 0 ){// 客户端关闭或者read出错都执行这个printf("connectin close or some error happen when read\\n");event_free(ev);close(fd);free(stat);return ;}msg[len] = '\\0';printf("recv from client<<<< %s\\n", msg);// 修改节点event_set(ev,  fd, EV_WRITE, do_echo_response, (void*)stat);ev->ev_base = base;        event_add(ev, NULL);//write(fd, reply_msg, strlen(reply_msg) );
}void do_echo_response(int fd, short events, void *arg) {ConnectStat * stat = (ConnectStat *)(arg);struct event *ev = NULL;assert(stat!=NULL);ev = stat->ev;int len = strlen(stat->buf);printf("write to client>>>> %s\\n", stat->buf);int _s = write(fd, stat->buf, len);if (_s > 0){printf("write successfully.\\n");}else if (_s == 0)  //client:close{fprintf(stderr,"Remote connection[fd: %d] has been closed\\n", fd);goto  ERR_EXIT;}else //err occurred.{fprintf(stderr,"read faield[fd: %d], reason:%s [%d]\\n",fd , strerror(errno), _s);goto  ERR_EXIT;}// 修改节点 属性 读事件event_set(ev,  fd, EV_READ, do_echo_request, (void*)stat);ev->ev_base = base;        event_add(ev, NULL);return ; // 这里一个要有return 不然就会执行下面代码ERR_EXIT:event_free(ev);close(fd);free(stat);      
}typedef struct sockaddr SA;
int tcp_server_init(int port, int listen_num)
{int errno_save;evutil_socket_t listener;// evutil_socket_t 相当于 int 使用这个evutil_socket_t支持跨平台;listener = socket(AF_INET, SOCK_STREAM, 0);if( listener == -1 )return -1;//允许多次绑定同一个地址。要用在socket和bind之间//等同于 int opt = 1;//setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));evutil_make_listen_socket_reuseable(listener); // 设置地址重用struct sockaddr_in sin;sin.sin_family = AF_INET;sin.sin_addr.s_addr = 0;sin.sin_port = htons(port);if( bind(listener, (SA*)&sin, sizeof(sin)) < 0 )goto error; // 跳转执行程序if( listen(listener, listen_num) < 0)goto error;//跨平台统一接口，将套接字设置为非阻塞状态/* 相当于void set_nonblock(int fd){int fl = fcntl(fd, F_GETFL);fcntl(fd, F_SETFL, fl | O_NONBLOCK);}*/evutil_make_socket_nonblocking(listener);return listener;error:errno_save = errno;evutil_closesocket(listener);errno = errno_save;return -1;
}

client.c

#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/util.h>int connect_server(const char* server_ip, int port);void cmd_read_data(int fd, short events, void* arg);
void socket_read_data(int fd, short events, void *arg);int main(int argc, char** argv)
{if( argc < 3 ){printf("please input 2 parameters\\n");return -1;}//两个参数依次是服务器端的IP地址、端口号int sockfd = connect_server(argv[1], atoi(argv[2]));if( sockfd == -1){perror("tcp_connect error ");return -1;}printf("connect to server successfully\\n");// 创建一个事件集合struct event_base* base = event_base_new();// 创建一个事件 读事件|只要有数据就读   一旦有数据来了就会调用socket_read_datastruct event *ev_sockfd = event_new(base, sockfd,EV_READ | EV_PERSIST,socket_read_data, NULL);event_add(ev_sockfd, NULL);//监听终端输入事件  当敲回车那一刻就会触发事件struct event* ev_cmd = event_new(base, STDIN_FILENO,EV_READ | EV_PERSIST, cmd_read_data,(void*)&sockfd);event_add(ev_cmd, NULL);event_base_dispatch(base);printf("finished \\n");return 0;
}// 读取控制台的数据 然后往 客户端文件描述符中写入
void cmd_read_data(int fd, short events, void* arg)
{char msg[1024];int ret = read(fd, msg, sizeof(msg)-1); // 确保最后一个 '\\0'可以加入 所以-1if( ret <= 0 ){perror("read fail ");exit(1);}int sockfd = *((int*)arg);if(msg[ret - 1]=='\\n') msg[ret - 1] = '\\0'; // 把换行符换成'\\0'else msg[ret] = '\\0';//把终端的消息发送给服务器端,客户端忽略性能考虑，直接利用阻塞方式发送  默认就是阻塞printf("write to server>>> [%s]\\n", msg);write(sockfd, msg, ret);
}void socket_read_data(int fd, short events, void *arg)
{char msg[1024];//为了简单起见，不考虑读一半数据的情况int len = read(fd, msg, sizeof(msg)-1);if( len == 0 ){printf("connection close. exit~\\n");exit(1);}else if(len < 0){perror("read fail ");return ;}msg[len] = '\\0';printf("recv from server<<<<< [%s] \\n", msg);
}typedef struct sockaddr SA;
int connect_server(const char* server_ip, int port)
{int sockfd, status, save_errno;struct sockaddr_in server_addr;memset(&server_addr, 0, sizeof(server_addr) );server_addr.sin_family = AF_INET;server_addr.sin_port = htons(port);status = inet_aton(server_ip, &server_addr.sin_addr);if( status == 0 ) //the server_ip is not valid value{errno = EINVAL;return -1;}sockfd = socket(PF_INET, SOCK_STREAM, 0);if( sockfd == -1 )return sockfd;status = connect(sockfd, (SA*)&server_addr, sizeof(server_addr) );if( status == -1 ){save_errno = errno;close(sockfd);errno = save_errno; //the close may be errorreturn -1;}//evutil_make_socket_nonblocking(sockfd);非阻塞一般用户服务器端,不用于客户端return sockfd;
}

使用libevent 缓冲区服务端

• 这个版本的服务器代码要相比于上一个版本少了50多行代码
• 这里把每一个新引入的API都做了注解
• 如果还有疑惑请查看 《libevent 中文文档》

先上结果

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>#include <unistd.h>
#include <event.h>
#include <event2/event.h>
#include<event2/listener.h>
#include <assert.h>#define BUFLEN  1024typedef struct _ConnectStat {struct bufferevent* bev;char buf[BUFLEN];
}ConnectStat;//echo 服务实现相关代码
ConnectStat * stat_init(int fd, struct bufferevent *bev);// 监听文件描述符，当有客户端请求连接的时候回调这个函数
void listener_cb(struct evconnlistener *listener, evutil_socket_t fd,  struct sockaddr *sock, int socklen, void *arg); // 接受客户端发来的数据
void do_echo_request(struct bufferevent* bev, void* arg);// 服务端把数据传送给客户端
void do_echo_handler(struct bufferevent* bev, void* arg);// 读数据或者写数据出错的时候调用
void event_cb(struct bufferevent *bev, short event, void *arg);int tcp_server_init(int port, int listen_num);struct event_base* base;int main(int argc, char** argv)
{struct sockaddr_in sin;  memset(&sin, 0, sizeof(struct sockaddr_in));  sin.sin_family = AF_INET;  sin.sin_port = htons(9999);  base = event_base_new();  /*LEV_OPT_REUSEABLE某些平台在默认情况下，关闭某监听套接字后，要过一会儿其他套接字才可以绑定到同一个端口。设置这个标志会让libevent标记套接字是可重用的，这样一旦关闭，可以立即打开其他套接字，在相同端口进行监听。*//*LEV_OPT_CLOSE_ON_FREE如果设置了这个选项，释放连接监听器会关闭底层套接字。*/// 参数：事件集，回调函数，回调函数参数，相当于listen的第二个参数，地址，地址长度struct evconnlistener *listener  = evconnlistener_new_bind(base, listener_cb, base,  LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE,  10, (struct sockaddr*)&sin,  sizeof(struct sockaddr_in));  event_base_dispatch(base); // 循环处理事件evconnlistener_free(listener);// 释放文件描述符event_base_free(base);// 释放事件集return 0;  
}ConnectStat * stat_init(int fd, struct bufferevent *bev) {ConnectStat * temp = NULL;temp = (ConnectStat *)malloc(sizeof(ConnectStat));if (!temp) {fprintf(stderr, "malloc failed. reason: %m\\n");return NULL;}memset(temp, '\\0', sizeof(ConnectStat));temp->bev = bev;}/*
一个新客户端连接上服务器此函数就会被调用,当此函数被调用时，libevent已经帮我们accept了这个客户端。
该客户端的文件描述符为fd
*/
void listener_cb(struct evconnlistener *listener, evutil_socket_t fd,  struct sockaddr *sock, int socklen, void *arg)  
{  printf("accept a client %d\\n", fd);  struct event_base *base = (struct event_base*)arg;  //创建一个缓冲区//作用:会把读的数据或者写的数据,会缓存起来//参数:事件集,监听文件描述符,当连接关闭的时候会释放资源  struct bufferevent *bev =  bufferevent_socket_new(base, fd,  BEV_OPT_CLOSE_ON_FREE);ConnectStat *stat = stat_init(fd, bev);	//当有数据可读或socket关闭时会调用回调函数//参数:bufferevent_socket_new的返回值,读回调函数,写回调函数,出错回调函数,回调函数的参数bufferevent_setcb(bev, do_echo_request, NULL, event_cb, stat);  // EV_READ：读事件  EV_PERSIST：持续做一件事   所以持续的读bufferevent_enable(bev, EV_READ | EV_PERSIST);  
}  void do_echo_request(struct bufferevent* bev, void* arg)
{ConnectStat *stat = (ConnectStat *)arg;char *msg = stat->buf;printf("do echo request ...\\n");/*这里读取字符串一定不会出错，因为这里是从 struct bufferevent创建的缓冲区中读取的若struct bufferevent读取失败，那么也不会执行到这里，直接调用event_cb函数*/size_t len = bufferevent_read(bev, msg, BUFLEN);msg[len] = '\\0';printf("recv from client<<<< %s\\n", msg);// 服务端把数据传送给客户端 do_echo_handler(bev, arg);}// 服务端把数据传送给客户端
void do_echo_handler(struct bufferevent* bev, void* arg){/* 处理数据操作 */ConnectStat *stat = (ConnectStat *)arg;char *msg = stat->buf;bufferevent_write(bev, msg, strlen(msg));// 写数据
}void event_cb(struct bufferevent *bev, short event, void *arg)
{ConnectStat *stat = (ConnectStat *)arg;if (event & BEV_EVENT_EOF)printf("connection closed\\n");else if (event & BEV_EVENT_ERROR)printf("some other error\\n");//这将自动close套接字和free读写缓冲区bufferevent_free(bev);free(stat);
}