• 1.libevent（框架，跨平台）的安装与编译使用
• 2. libevent的地基-event_base
• 2.1 libevent上述函数调用的练习
• 3等待事件产生-循环等待event_loop 相当于epool的while(1)
• 4.使用libevent库的步骤及主要的状态变化
• 5.使用libevent编写服务器具体的思路
• 6.使用libevent编写服务器代码的实现
• 7.自带buffer的事件-bufferevent
• • 7.1 bufferevent的相关函数
  • 7.3 链接监听器-evconnlistener
• 8.服务器端程序---链接监听器加bufferevent，libevent完成Hello word（读懂，从官方示例中摘取）
• 8.客户端代码--buffevent

1.libevent（框架，跨平台）的安装与编译使用

• 什么是libevent?

1.事件驱动, 高性能, 轻量级, 专注于网络
2.源代码精炼, 易读
3 跨平台
4 支持多种I/O多路复用技术, 如epoll select poll等
5 支持I/O和信号等事件

• 登录官方网站: http://libevent.org, 查看相关信息

- 如何安装具体见文档15 如何使用？

在linux上, 其实质就是epoll反应堆. libevent是事件驱动, epoll反应堆也是事件驱动, 当要监测的事件发生的时候, 就会调用事件对应的回调函数, 执行相应操作. 特别提醒: 事件回调函数是由用户开发的, 但是不是由用户显示去调用的, 而是由libevent去调用的
进入到libevent-2.0.22-stable/sample下, 可以查看一些示例源代码文件.
使用libevent库编写代码在编译程序的时候需要指定库名:-levent;
安装文件的libevent库文件所在路径:libevent-2.0.22-stable/.libs;
编写代码的时候用到event.h头文件, 或者直接参考sample目录下的源代码文件也可以.

#include <event2/event.h>

编译源代码文件(以hello-world.c文件为例)

gcc hello-world.c -levent

由于安装的时候已经将头文件和库文件拷贝到了系统头文件所在路径/usr/local/include和系统库文件所在路径/usr/local/lib, 所以这里编译的时候可以不用指定-I和-L.

编译示例代码hello-world.c程序:

gcc -o hello-world hello-world.c -levent

测试: 在另一个终端窗口进行测试, 输入: nc 127.1 9995, 然后回车立刻显示Hello, World!字符串.

2. libevent的地基-event_base

使用libevent 函数之前需要分配一个或者多个 event_base 结构体, 每个event_base结构体持有一个事件集合, 可以检测以确定哪个事件是激活的, event_base结构相当于epoll红黑树的树根节点, 每个event_base都有一种用于检测某种事件已经就绪的 “方法”(回调函数)

通常情况下可以通过event_base_new函数获得event_base结构。

相关函数说明:
1 struct event_base *event_base_new(void);    //event.h的L:337
  函数说明: 获得event_base结构
  参数说明: 无
  返回值: 
成功返回event_base结构体指针;
失败返回NULL;

2 void event_base_free(struct event_base *);   //event.h的L:561
	函数说明: 释放event_base指针

3 int event_reinit(struct event_base *base);  //event.h的L:349
	函数说明: 如果有子进程, 且子进程也要使用base, 则子进程需要对event_base重新初始化, 此时需要调用event_reinit函数.
函数参数: 由event_base_new返回的执行event_base结构的指针
返回值: 成功返回0, 失败返回-1

对于不同系统而言, event_base就是调用不同的多路IO接口去判断事件是否已经被激活,
   对于linux系统而言, 核心调用的就是epoll, 同时支持poll和select.

2.1 libevent上述函数调用的练习

//获取libevent支持的方法和当前系统使用的方法
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <event2/event.h>

int main()
{
	//获取当前系统支持的方法有哪些
	//const char **event_get_supported_methods(void);
	const char **p = event_get_supported_methods();
	int i = 0;
	while(p[i]!=NULL)
	{
		printf("[%s]  ", p[i++]);
	}
	printf("\n");
	
	//创建event_base结构体
	struct event_base *base = event_base_new();
	if(base==NULL)
	{
		printf("event_base_new error\n");
		return -1;
	}
	
	//const char * event_base_get_method(const struct event_base *base);
	printf("[%s]\n", event_base_get_method(base));
	
	//释放event_base节点
	event_base_free(base);
	return 0;
}

3等待事件产生-循环等待event_loop 相当于epool的while(1)

• 循环等待

int event_base_dispatch(struct event_base *base);   //event.h的L:364
函数说明: 进入循环等待事件
参数说明:由event_base_new函数返回的指向event_base结构的指针
调用该函数, 相当于没有设置标志位的event_base_loop。程序将会一直运行, 直到没有需要检测的事件了, 或者被结束循环的API终止。

• 循环退出

int event_base_loopexit(struct event_base *base, const struct timeval *tv);
int event_base_loopbreak(struct event_base *base);
struct timeval {
	long    tv_sec;                    
	long    tv_usec;            
};

两个函数的区别是如果正在执行激活事件的回调函数, 那么event_base_loopexit将在事件回调执行结束后终止循环（如果tv时间非NULL, 那么将等待tv设置的时间后立即结束循环）, 而event_base_loopbreak会立即终止循环。

4.使用libevent库的步骤及主要的状态变化

1.创建根节点–event_base_new
2.设置监听时间和数据可读可写的时间回调函数
设置了时间对应的回调函数以后，当事件产生的时候会自动调用回调函数
3.事件循环----event_base_dispach
相当于while(1)，在循环内部等待事件的发生，若有事件发生则会触发事件对应的回调函数。
4.释放根节点—event_base_free
释放由event_base_new和event_new创建的资源，分别调用event_base_free和event_free函数。

• 事件驱动实际上是libevent的核心思想, 本小节主要介绍基本的事件event。
  主要的状态转化：

• 上图中专有名词的解释：

无效的指针: 此时仅仅是定义了 struct event *ptr；
非未决：相当于创建了事件, 但是事件还没有处于被监听状态, 类似于我们使用epoll的时候定义了struct epoll_event ev并且对ev的两个字段进行了赋值, 但是此时尚未调用epoll_ctl对事件上树.
未决：就是对事件开始监听, 暂时未有事件产生。相当于调用epoll_ctl对要监听的事件上树, 但是没有事件产生.
激活：代表监听的事件已经产生, 这时需要处理, 相当于调用epoll_wait函数有返回, 当事件被激活以后, libevent会调用该事件对应的回调函数.

libevent的事件驱动对应的结构体为struct event, 对应的函数在图上也比较清晰, 下面介绍一下主要的函数:

typedef void (*event_callback_fn)(evutil_socket_t fd, short events, void *arg);
struct event *event_new(struct event_base *base, evutil_socket_t fd, short events, event_callback_fn cb, void *arg);
函数说明: event_new负责创建event结构指针, 同时指定对应的地基base, 		  还有对应的文件描述符, 事件, 以及回调函数和回调函数的参数。
参数说明：
base: 对应的根节点--地基
fd: 要监听的文件描述符
events:要监听的事件
	  	#define  EV_TIMEOUT    0x01   //超时事件
#define  EV_READ       0x02    //读事件
#define  EV_WRITE      0x04    //写事件
#define  EV_SIGNAL     0x08    //信号事件
#define  EV_PERSIST     0x10    //周期性触发
#define  EV_ET         0x20    //边缘触发, 如果底层模型支持设置										 则有效, 若不支持则无效.
若要想设置持续的读事件则： EV_READ | EV_PERSIST
cb 回调函数, 原型如下：
typedef void (*event_callback_fn)(evutil_socket_t fd, short events, void *arg);
注意: 回调函数的参数就对应于event_new函数的fd, event和arg

#define evsignal_new(b, x, cb, arg)             \                                                                    
      event_new((b), (x), EV_SIGNAL|EV_PERSIST, (cb), (arg))

int event_add(struct event *ev, const struct timeval *timeout);
函数说明: 将非未决态事件转为未决态, 相当于调用epoll_ctl函数(EPOLL_CTL_ADD), 开始监听事件是否产生, 相当于epoll的上树操作.
参数说明：
	ev: 调用event_new创建的事件
timeout: 限时等待事件的产生, 也可以设置为NULL, 没有限时。

int event_del(struct event *ev);
函数说明: 将事件从未决态变为非未决态, 相当于epoll的下树（epoll_ctl调用			EPOLL_CTL_DEL操作）操作。
参数说明: ev指的是由event_new创建的事件.

void event_free(struct event *ev);
函数说明: 释放由event_new申请的event节点。

5.使用libevent编写服务器具体的思路

编写一个基于event实现的tcp服务器
1 创建socket---socket()
2 设置端口复用---setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int))
3 绑定--bind()
4 设置监听--listen()
5 创建地基
	struct event_base *base = event_base_new()
6 创建lfd对应的事件
	struct event *ev = event_new(base, lfd, EV_READ|EV_PERSIST, conncb, base);
7 上event_base地基
	event_add(ev, NULL);
8 进入事件循环
	event_base_dispatch(base);
	
9 释放资源
	event_base_free(base);
	event_free(ev);
	
typedef void (*event_callback_fn)(evutil_socket_t fd, short events, void *arg);
//监听文件描述符对应的事件回调函数
void conncb(evutil_socket_t fd, short events, void *arg)
{
	struct event_base *base = (struct event_base *)arg;
	//接受新的连接
	int cfd = accept(fd, NULL, NULL);
	if(cfd>0)
	{
		//创建一个新的事件
		struct event *ev = event_new(base, cfd, EV_READ|EV_PERSIST, readcb, NULL);
		event_add(ev, NULL);
	}
}

//读客户端数据对应的回调函数
void readcb(evutil_socket_t fd, short events, void *arg)
{	
	//读数据
	n = read(fd, buf, sizeof(buf));
	if(n<=0)
	{
		//从base地基上删除该事件
		close(fd);
		event_del(ev);
		event_free(ev);
	}
	//发送数据给对方
	write(fd, buf, n);
}

bufferevent的读事件回调触发时机:
	当数据由内核的读缓冲区到bufferevent的读缓冲区的时候, 会触发bufferevent的
	读事件回调.需要注意的是: 数据有内核到bufferevent的过程不是用户程序执行的, 
	是有bufferevent内部操作的.
	
bufferevent的写事件回调触发时机:
	当用户程序将数据写到bufferevent的写缓冲区之后, bufferevent会自动将数据
	写到内核的写缓冲区,最终有内核程序将数据发送出去.
	
事件回调:
	当bufferevent绑定的socket连接, 断开或者异常的时候触发事件回调.

6.使用libevent编写服务器代码的实现

#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<event2/event.h>

void readcb(evutil_socket_t fd, short events, void *arg);
void conncb(evutil_socket_t fd, short events, void *arg);
struct event *connev = NULL; //如何实现

int main()
{
	//创建socket
	int lfd = socket(AF_INET,SOCK_STREAM,0);
	//设置端口复用
	int opt =1;

	setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(int));
	//绑定
	struct sockaddr_in serv;
	bzero(&serv,sizeof(serv));
	serv.sin_addr.s_addr = htonl(INADDR_ANY);
	serv.sin_port = htons(8888);
	serv.sin_family = AF_INET;
	bind(lfd,(struct sockaddr *)&serv,sizeof(serv));
	//监听
	listen(lfd,120);

	//创建event地基
	struct event_base *base = event_base_new();
	if(base == NULL)
	{
		printf("event_base_new erro\n");
		return -1;
	}
	//创建监听文件描述符的事件
	struct event *ev = event_new(base,lfd,EV_READ|EV_PERSIST,conncb,base);
	if(ev == NULL)
	{
		printf("event_new error\n");
		return -1;
	}
	//将新的事件上地基
	event_add(ev,NULL);
	//进入事件循环等待
	event_base_dispatch(base);

	//释放资源
	event_base_free(base);
	event_free(ev);
	
	close(lfd);
	return 0;
}
// typedef void(*event_callback_fn)(evutil_socket_t fd,short events,void *arg);

void conncb(evutil_socket_t fd,short events,void *arg)
{
	struct event_base *base = (struct event_base *)arg;
	int cfd = accept(fd,NULL,NULL);
	if(cfd>0)
	{
		//创建通讯文件描述符，对应的时间，并设置回调函数为readcb
		struct event *connev = event_new(base,cfd,EV_READ|EV_PERSIST,readcb,NULL);
		if(connev == NULL)
		{
			event_base_loopexit(base,NULL);
		}
		
		//将通信文件描述符对应的事件上event_base地基
		event_add(connev,NULL);
	
	}
}

// typedef void(*event_callback_fn)(evutil_socket_t fd,short events,void *arg)
void readcb(evutil_socket_t fd, short events, void *arg)
{
	int n;
	char buf[1024];
	memset(buf, 0x00, sizeof(buf));
	n = read(fd, buf, sizeof(buf));
	if(n<=0)
	{
		close(fd);
		//将通信文件描述符对应的事件从base地基上删除
		event_del(connev);
	}
	else
	{
		write(fd, buf, n);
	}
}

在其他终端窗口上使用nc命令进行测试: nc 127.1 8888, 多开几个终端窗口使用nc命令进行测试

• 发现问题:

当使用多个客户端(nc命令模拟客户端程序)进行测试的时候, 特别是当关闭所有客户端程序的时候, 若再次开启nc命令, 会发现异常.

• 解决办法:

可以将对应事件的文件描述符和事件做一个映射, 说的通俗一点就是可以将fd和event定义在一个结构体当中, 然后定义一个结构体数组, 这样可以使fd和event形成一个一对一的映射关系, 通过fd就可以找到event.
struct event_fd
{
evutil_socket_t fd;
struct event *ev;
}event[MAX];

7.自带buffer的事件-bufferevent

bufferevent实际上也是一个event, 只不过比普通的event高级一些, 它的内部有两个缓冲区, 以及一个文件描述符（网络套接字）。一个网络套接字有读和写两个缓冲区, bufferevent同样也带有两个缓冲区, 还有就是libevent事件驱动的核心回调函数, 那么四个缓冲区以及触发回调的关系如下：

• 三个回调函数的触发时机：
  
  一个bufferevent对应两个缓冲区, 三个回调函数, 分别是写回调, 读回调和事件回调。
• 各个回调函数的调用时机：

读回调 – 当bufferevent将底层读缓冲区的数据读到自身的读缓冲区时触发读事件回调.
写回调 – 当bufferevent将自身写缓冲的数据写到底层写缓冲区的时候触发写事件回调, 由于数据最终是写入了内核的写缓冲区中, 应用程序已经无法控制, 这个事件对于应用程序来说基本没什么用, 只是通知功能.
事件回调 – 当bufferevent绑定的socket连接, 断开或者异常的时候触发事件回调.

7.1 bufferevent的相关函数

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自动关闭底层接口(当bufferevent被释放以后, 文件描述符也随之被close)    
		BEV_OPT_THREADSAFE  -- 使bufferevent能够在多线程下是安全的

int bufferevent_socket_connect(struct bufferevent *bev, struct sockaddr *serv, int socklen);
函数说明: 该函数封装了底层的socket与connect接口, 通过调用此函数, 可以将bufferevent事件与通信的socket进行绑定, 参数如下：
	bev – 需要提前初始化的bufferevent事件
	serv – 对端(一般指服务端)的ip地址, 端口, 协议的结构指针
	socklen – 描述serv的长度
说明: 调用此函数以后, 通信的socket与bufferevent缓冲区做了绑定, 后面调用了bufferevent_setcb函数以后, 会对bufferevent缓冲区的读写操作的事件设置回调函数, 当往缓冲区中写数据的时候会触发写回调函数, 当数据从socket的内核缓冲区读到bufferevent读缓冲区中的时候会触发读回调函数.

void bufferevent_free(struct bufferevent *bufev);
函数说明: 释放bufferevent

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--请求的过程中连接已经完成
int bufferevent_write(struct bufferevent *bufev, const void *data, size_t size);
	bufferevent_write是将data的数据写到bufferevent的写缓冲区

int bufferevent_write_buffer(struct bufferevent *bufev, struct evbuffer *buf);
	bufferevent_write_buffer 是将数据写到写缓冲区另外一个写法, 实际上bufferevent的内部的两个缓冲区结构就是struct evbuffer。

size_t bufferevent_read(struct bufferevent *bufev, void *data, size_t size);
	bufferevent_read 是将bufferevent的读缓冲区数据读到data中, 同时将读到的数据从bufferevent的读缓冲清除。

int bufferevent_read_buffer(struct bufferevent *bufev, struct evbuffer *buf);
	bufferevent_read_buffer 将bufferevent读缓冲数据读到buf中, 接口的另外一种。

int bufferevent_enable(struct bufferevent *bufev, short event);

int bufferevent_disable(struct bufferevent *bufev, short event);
	bufferevent_enable与bufferevent_disable是设置事件是否生效, 如果设置为disable, 事件回调将不会被触发。

7.3 链接监听器-evconnlistener

l链接监听器是封装了socket通信相关函数，比如socket，bind，listen，accept这几个函数。链接监听器创建后相当于调用了这几个函数等待新的客户端到来，然后调用用户指定的回调函数。函数原型：

需要加的头文件和相关的函数：

#include<event2/listener.h>

//函数说明
struct evconnlistener *evconnlistener_new_bind(struct event_base *base,
    evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,
const struct sockaddr *sa, int socklen);
函数说明: 
是在当前没有套接字的情况下对链接监听器进行初始化, 看最后2个参数实际上就是bind使用的关键参数, backlog是listen函数的关键参数（略有不同的是, 如果backlog是-1, 那么监听器会自动选择一个合适的值, 如果填0, 那么监听器会认为listen函数已经被调用过了）, ptr是回调函数的参数, cb是有新连接之后的回调函数, 但是注意这个回调函数触发的时候, 链接器已经处理好新连接了, 并将与新连接通信的描述符交给回调函数。flags 需要参考几个值：
	LEV_OPT_LEAVE_SOCKETS_BLOCKING   文件描述符为阻塞的
	LEV_OPT_CLOSE_ON_FREE            关闭时自动释放
	LEV_OPT_REUSEABLE                端口复用
	LEV_OPT_THREADSAFE               分配锁, 线程安全

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, 所以大多数时候, 我们都可以使用第一个函数。

两个函数的回调函数
typedef void (*evconnlistener_cb)(struct evconnlistener *evl, evutil_socket_t fd, struct sockaddr *cliaddr, int socklen, void *ptr);
回调函数fd参数是与客户端通信的描述符, 并非是等待连接的监听的那个描述符, 所以cliaddr对应的也是新连接的对端地址信息, 已经是accept处理好的。

void evconnlistener_free(struct evconnlistener *lev);
函数说明: 释放链接监听器

int evconnlistener_enable(struct evconnlistener *lev);
函数说明: 使链接监听器生效

int evconnlistener_disable(struct evconnlistener *lev);
函数说明: 使链接监听器失效

如果上述函数都较为了解了, 可以尝试去看懂hello-world.c的代码, 在安装包的sample目录下, 其中有涉及到信号的函数, 看看自己能否找到函数的原型在哪？实际上就是一个宏定义, 也是我们之前介绍的event_new函数, 只是对应一个信号事件而已, 处理机制略有不同。
#define evsignal_new(b, x, cb, arg)				\
	event_new((b), (x), EV_SIGNAL|EV_PERSIST, (cb), (arg))

8.服务器端程序—链接监听器加bufferevent，libevent完成Hello word（读懂，从官方示例中摘取）

具体的流程加代码

/*
  This exmple program provides a trivial server program that listens for TCP
  connections on port 9995.  When they arrive, it writes a short message to
  each client connection, and closes each connection once it is flushed.

  Where possible, it exits cleanly in response to a SIGINT (ctrl-c).
*/
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <signal.h>
#ifndef WIN32
#include <netinet/in.h>
# ifdef _XOPEN_SOURCE_EXTENDED
#  include <arpa/inet.h>
# endif
#include <sys/socket.h>
#endif

#include <event2/bufferevent.h>
#include <event2/buffer.h>
#include <event2/listener.h>
#include <event2/util.h>
#include <event2/event.h>
#include <ctype.h>

static const char MESSAGE[] = "Hello, World!\n";

static const int PORT = 9995;

static void listener_cb(struct evconnlistener *, evutil_socket_t,
    struct sockaddr *, int socklen, void *);
static void conn_writecb(struct bufferevent *, void *);
static void conn_readcb(struct bufferevent *, void *);
static void conn_eventcb(struct bufferevent *, short, void *);
static void signal_cb(evutil_socket_t, short, void *);

int
main(int argc, char **argv)
{
	struct event_base *base;   //地基
	struct evconnlistener *listener; //链接监听器
	struct event *signal_event;  //信号事件

	struct sockaddr_in sin;
#ifdef WIN32
	WSADATA wsa_data;
	WSAStartup(0x0201, &wsa_data);
#endif

	//创建地基---相当于epoll的树根(epoll_create)
	base = event_base_new();
	if (!base) {
		fprintf(stderr, "Could not initialize libevent!\n");
		return 1;
	}

	memset(&sin, 0, sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(PORT);

	//创建链接监听器--socket-bind-listen-accept
	//listener_cb: 回调函数
	//LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE: 设置端口复用, 当链接监听器释放的时候关闭套接字(监听文件描述符)
	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;
	}

	//设置SIGINT信号的事件回调
	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;
	}

	//进入等待事件循环---相当于while(1)
	event_base_dispatch(base);

	//释放资源
	evconnlistener_free(listener);
	event_free(signal_event);
	event_base_free(base);

	printf("done\n");
	return 0;
}


//listener: 链接监听器
//fd: 通信文件描述符
//sa和socklen: 客户端IP地址信息
//user_data: 参数
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;

	//创建bufferevent缓冲区
	//BEV_OPT_CLOSE_ON_FREE: bufferevent释放的时候自动关闭通信文件描述符
	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设置生效
	bufferevent_enable(bev, EV_WRITE);
	bufferevent_enable(bev, EV_READ);
	
	//使bufferevent设置无效
	//bufferevent_disable(bev, EV_READ);

	//bufferevent_write(bev, MESSAGE, strlen(MESSAGE));
}

static void
conn_readcb(struct bufferevent *bev, void *user_data)
{
	//size_t bufferevent_read(struct bufferevent *bufev, void *data, size_t size);
	char buf[1024];
	memset(buf, 0x00, sizeof(buf));
	//从bufferevent读数据
	int n = bufferevent_read(bev, buf, sizeof(buf));
	printf("n=[%d],buf==[%s]\n", n, buf);
	
	int i=0;
	for(i=0; i<n; i++)
	{
		buf[i] = toupper(buf[i]);
	}
	//往bufferevent的写缓冲区写数据
	//int bufferevent_write(struct bufferevent *bufev, const void *data, size_t size);
	bufferevent_write(bev, buf, n);//写bufferevent缓冲区会触发写事件回调
}

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

8.客户端代码–buffevent

//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>

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)
{
    if( argc < 3 )
    {
        //两个参数依次是服务器端的IP地址、端口号
        printf("please input 2 parameter\n");
        return -1;
    }
    //创建根节点
    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);
    //上树 开始监听标准输入的读事件
    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(atoi(argv[2]));
    //将ip地址转换为网络字节序
    inet_aton(argv[1], &server_addr.sin_addr);

    //连接到 服务器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);

    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)
{
    char msg[1024];

    size_t len = bufferevent_read(bev, msg, sizeof(msg));
    msg[len] = '\0';

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