Libevent学习之旅

小瑞的学习笔记

已于 2024-08-01 12:46:03 修改

阅读量398

点赞数 1

分类专栏： linux 文章标签：学习服务器网络 c++ linux

于 2023-04-08 14:39:54 首次发布

本文链接：https://blog.csdn.net/m0_60529319/article/details/129983485

版权

linux 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

libevent是一个轻量级的开源网络库，支持多种I/O多路复用技术，如epoll、kqueue等。它采用Reactor模式，提供事件通知、IO缓存、定时器和信号等功能。文章介绍了如何在Linux下创建和管理事件，以及通过libevent实现一个回声服务器的详细步骤。

摘要由CSDN通过智能技术生成

文章目录

简介

简介

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  1024

struct 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 == 2
	ssize_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  1024

typedef 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_data
    struct 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'可以加入 所以-1
    if( 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 error
        return -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  1024

typedef 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);
}