和之前的《Libevent工作流程探究》一样，这里也是用一个例子来探究bufferevent的工作流程。具体的例子可以参考《Libevent使用例子，从简单到复杂》，这里就不列出了。其实要做的例子也就是bufferevent_socket_new、bufferevent_setcb、bufferevent_enable这几个函数。
因为本文会用到《 Libevent工作流程探究》中提到的说法，比如将一个event插入到event_base中。所以读者最好先读一下那篇博文。bufferevent结构体：
bufferevent其实也就是在event_base的基础上再进行一层封装，其本质还是离不开event和event_base，从bufferevent的结构体就可以看到这一点。
bufferevent结构体中有两个event，分别用来监听同一个fd的可读事件和可写事件。因为不用一个event同时监听可读和可写呢？这是因为监听可写是困难的， 下面会说到原因。读者也可以自问一下，自己之前有没有试过用最原始的event监听一个fd的可写。由于socket 是全双工的，所以在bufferevent结构体中，也有两个evbuffer成员，分别是读缓冲区和写缓冲区。 bufferevent结构体定义如下：//bufferevent_struct.h文件
struct bufferevent {
struct event_base *ev_base;
//操作结构体，成员有一些函数指针。类似struct eventop结构体
const struct bufferevent_ops *be_ops;
struct event ev_read;//读事件event
struct event ev_write;//写事件event
struct evbuffer *input;//读缓冲区
struct evbuffer *output; //写缓冲区
struct event_watermark wm_read;//读水位
struct event_watermark wm_write;//写水位
bufferevent_data_cb readcb;//可读时的回调函数指针
bufferevent_data_cb writecb;//可写时的回调函数指针
bufferevent_event_cb errorcb;//错误发生时的回调函数指针
void *cbarg;//回调函数的参数
struct timeval timeout_read;//读事件event的超时值
struct timeval timeout_write;//写事件event的超时值
/** Events that are currently enabled: currently EV_READ and EV_WRITE
are supported. */
short enabled;
};
如果看过Libevent的参考手册的话，应该还会知道bufferevent除了用于socket外，还可以用于socketpair 和 filter。如果用面向对象的思维，应从这个三个应用中抽出相同的部分作为父类，然后派生出三个子类。
Libevent虽然是用C语言写的，不过它还是提取出一些公共部分，然后定义一个bufferevent_private结构体，用于保存这些公共部分成员。从集合的角度来说，bufferevent_private应该是bufferevent的一个子集，即一部分。但在Libevent中，bufferevent确实bufferevent_private的一个成员。下面是bufferevent_private结构体。
//bufferevent-internal.h文件
struct bufferevent_private {
struct bufferevent bev;
//设置input evbuffer的高水位时，需要一个evbuffer回调函数配合工作
struct evbuffer_cb_entry *read_watermarks_cb;
/** If set, we should free the lock when we free the bufferevent. */
//锁是Libevent自动分配的，还是用户分配的
unsigned own_lock : 1;
...
//这个socket是否处理正在连接服务器状态
unsigned connecting : 1;
//标志连接被拒绝
unsigned connection_refused : 1;
//标志是什么原因把 读 挂起来
bufferevent_suspend_flags read_suspended;
//标志是什么原因把 写 挂起来
bufferevent_suspend_flags write_suspended;
enum bufferevent_options options;
int refcnt;// bufferevent的引用计数
//锁变量
void *lock;
};
新建一个bufferevent：
函数bufferevent_socket_new可以完成这个工作。
//bufferevent-internal.h文件
struct bufferevent_ops {
const char *type;//类型名称
off_t mem_offset;//成员bev的偏移量
//启动。将event加入到event_base中
int (*enable)(struct bufferevent *, short);
//关闭。将event从event_base中删除
int (*disable)(struct bufferevent *, short);
//销毁
void (*destruct)(struct bufferevent *);
//调整event的超时值
int (*adj_timeouts)(struct bufferevent *);
/** Called to flush data. */
int (*flush)(struct bufferevent *, short, enum bufferevent_flush_mode);
//获取成员的值。具体看实现
int (*ctrl)(struct bufferevent *, enum bufferevent_ctrl_op, union bufferevent_ctrl_data *);
};
//bufferevent_sock.c文件
const struct bufferevent_ops bufferevent_ops_socket = {
"socket",
evutil_offsetof(struct bufferevent_private, bev),
be_socket_enable,
be_socket_disable,
be_socket_destruct,
be_socket_adj_timeouts,
be_socket_flush,
be_socket_ctrl,
};
//由于有几个不同类型的bufferevent，而且它们的enable、disable等操作是不同的。所以
//需要的一些函数指针指明某个类型的bufferevent应该使用哪些操作函数。结构体bufferevent_ops_socket
//就应运而生。对于socket，其操作函数如上。
//bufferevent_sock.c文件
struct bufferevent *
bufferevent_socket_new(struct event_base *base, evutil_socket_t fd,
int options)
{
struct bufferevent_private *bufev_p;
struct bufferevent *bufev;
...//win32
//结构体内存清零，所有成员都为0
if ((bufev_p = mm_calloc(1, sizeof(struct bufferevent_private)))== NULL)
return NULL;
//如果options中需要线程安全，那么就会申请锁
//会新建一个输入和输出缓存区
if (bufferevent_init_common(bufev_p, base, &bufferevent_ops_socket,
options) < 0) {
mm_free(bufev_p);
return NULL;
}
bufev = &bufev_p->bev;
//设置将evbuffer的数据向fd传
evbuffer_set_flags(bufev->output, EVBUFFER_FLAG_DRAINS_TO_FD);
//将fd与event相关联。同一个fd关联两个event
event_assign(&bufev->ev_read, bufev->ev_base, fd,
EV_READ|EV_PERSIST, bufferevent_readcb, bufev);
event_assign(&bufev->ev_write, bufev->ev_base, fd,
EV_WRITE|EV_PERSIST, bufferevent_writecb, bufev);
//设置evbuffer的回调函数，使得外界给写缓冲区添加数据时，能触发
//写操作，这个回调对于写事件的监听是很重要的
evbuffer_add_cb(bufev->output, bufferevent_socket_outbuf_cb, bufev);
//冻结读缓冲区的尾部，未解冻之前不能往读缓冲区追加数据
//也就是说不能从socket fd中读取数据
evbuffer_freeze(bufev->input, 0);
//冻结写缓冲区的头部，未解冻之前不能把写缓冲区的头部数据删除
//也就是说不能把数据写到socket fd
evbuffer_freeze(bufev->output, 1);
return bufev;
}
留意函数里面的evbuffer_add_cb调用，后面会说到。
函数在最后面会冻结两个缓冲区。其实，虽然这里冻结了，但实际上Libevent在读数据或者写数据之前会解冻的读完或者写完数据后，又会马上冻结。这主要防止数据被意外修改。用户一般不会直接调用evbuffer_freeze或者evbuffer_unfreeze函数。一切的冻结和解冻操作都由Libevent内部完成。还有一点要注意，因为这里只是把写缓冲区的头部冻结了。所以还是可以往写缓冲区的尾部追加数据。同样，此时也是可以从读缓冲区读取数据。这个是必须的。因为在Libevent内部不解冻的时候，用户需要从读缓冲区中获取数据(这相当于从socket fd中读取数据)，用户也需要把数据写到写缓冲区中(这相当于把数据写入到socket fd中)。
在bufferevent_socket_new函数里面会调用函数bufferevent_init_common完成公有部分的初始化。
//bufferevent.c文件
int
bufferevent_init_common(struct bufferevent_private *bufev_private,
struct event_base *base,
const struct bufferevent_ops *ops,
enum bufferevent_options options)
{
struct bufferevent *bufev = &bufev_private->bev;
//分配输入缓冲区
if (!bufev->input) {
if ((bufev->input = evbuffer_new()) == NULL)
return -1;
}
//分配输出缓冲区
if (!bufev->output) {
if ((bufev->output = evbuffer_new()) == NULL) {
evbuffer_free(bufev->input);
return -1;
}
}
bufev_private->refcnt = 1;//引用次数为1
bufev->ev_base = base;
/* Disable timeouts. */
//默认情况下,读和写event都是不支持超时的
evutil_timerclear(&bufev->timeout_read);
evutil_timerclear(&bufev->timeout_write);
bufev->be_ops = ops;
/*
* Set to EV_WRITE so that using bufferevent_write is going to
* trigger a callback. Reading needs to be explicitly enabled
* because otherwise no data will be available.
*/
//可写是默认支持的
bufev->enabled = EV_WRITE;
#ifndef _EVENT_DISABLE_THREAD_SUPPORT
if (options & BEV_OPT_THREADSAFE) {
//申请锁。
if (bufferevent_enable_locking(bufev, NULL) < 0) {
/* cleanup */
evbuffer_free(bufev->input);
evbuffer_free(bufev->output);
bufev->input = NULL;
bufev->output = NULL;
return -1;
}
}
#endif
...//延迟调用的初始化，一般不需要用到
bufev_private->options = options;
//将evbuffer和bufferevent相关联
evbuffer_set_parent(bufev->input, bufev);
evbuffer_set_parent(bufev->output, bufev);
return 0;
}
代码中可以看到，默认是enable EV_WRITE的。
设置回调函数：
函数bufferevent_setcb完成这个工作。该函数相当简单，也就是进行一些赋值操作。
//bufferevent.c文件
void
bufferevent_setcb(struct bufferevent *bufev,
bufferevent_data_cb readcb, bufferevent_data_cb writecb,
bufferevent_event_cb eventcb, void *cbarg)
{
//bufferevent结构体内部有一个锁变量
BEV_LOCK(bufev);
bufev->readcb = readcb;
bufev->writecb = writecb;
bufev->errorcb = eventcb;
bufev->cbarg = cbarg;
BEV_UNLOCK(bufev);
}
如果不想设置某个操作的回调函数，直接设置为NULL即可。
令bufferevent可以工作:
相信读者也知道，即使调用了bufferevent_socket_new和bufferevent_setcb，这个bufferevent还是不能工作，必须调用bufferevent_enable。为什么会这样的呢？
如果看过之前的那些博文，相信读者知道，一个event能够工作，不仅仅需要new出来，还要调用event_add函数，把这个event添加到event_base中。在本文前面的代码中，并没有看到event_add函数的调用。所以还需要调用一个函数，把event添加到event_base中。函数bufferevent_enable就是完成这个工作的。
//bufferevent.c文件
int
bufferevent_enable(struct bufferevent *bufev, short event)
{
struct bufferevent_private *bufev_private =
EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
short impl_events = event;
int r = 0;
//增加引用并加锁
//增加引用是为了防止其他线程调用bufferevent_free，释放了bufferevent
_bufferevent_incref_and_lock(bufev);
//挂起了读，此时不能监听读事件
if (bufev_private->read_suspended)
impl_events &= ~EV_READ;
//挂起了写，此时不能监听写事情
if (bufev_private->write_suspended)
impl_events &= ~EV_WRITE;
bufev->enabled |= event;
//调用对应类型的enbale函数。因为不同类型的bufferevent有不同的enable函数
if (impl_events && bufev->be_ops->enable(bufev, impl_events) < 0)
r = -1;
//减少引用并解锁
_bufferevent_decref_and_unlock(bufev);
return r;
}
上面代码可以看到，最终会调用对应bufferevent类型的enable函数，对于socket bufferevent，其enable函数是be_socket_enable，代码如下：
//bufferevent.c文件
int
_bufferevent_add_event(struct event *ev, const struct timeval *tv)
{
if (tv->tv_sec == 0 && tv->tv_usec == 0)
return event_add(ev, NULL);
else
return event_add(ev, tv);
}
//bufferevent_sock.c文件
#define be_socket_add(ev, t) \
_bufferevent_add_event((ev), (t))
static int
be_socket_enable(struct bufferevent *bufev, short event)
{
if (event & EV_READ) {
if (be_socket_add(&bufev->ev_read,&bufev->timeout_read) == -1)
return -1;
}
if (event & EV_WRITE) {
if (be_socket_add(&bufev->ev_write,&bufev->timeout_write) == -1)
return -1;
}
return 0;
}
如果读者熟悉Libevent的超时事件，那么可以知道Libevent是在event_add函数里面确定一个event的超时的。上面代码也展示了这一点，如果读或者写event设置了超时(即其超时值不为0)，那么就会作为参数传给event_add函数。如果读者不熟悉的Libevent的超时事件的话，可以参考《超时event的处理》。
用户可以调用函数bufferevent_set_timeouts，设置读或者写事件的超时。代码如下：
//bufferevent.c文件
int
bufferevent_set_timeouts(struct bufferevent *bufev,
const struct timeval *tv_read,
const struct timeval *tv_write)
{
int r = 0;
BEV_LOCK(bufev);
if (tv_read) {
bufev->timeout_read = *tv_read;
} else {
evutil_timerclear(&bufev->timeout_read);
}
if (tv_write) {
bufev->timeout_write = *tv_write;
} else {
evutil_timerclear(&bufev->timeout_write);
}
if (bufev->be_ops->adj_timeouts)
r = bufev->be_ops->adj_timeouts(bufev);
BEV_UNLOCK(bufev);
return r;
}
//bufferevent_sock.c文件
static int
be_socket_adj_timeouts(struct bufferevent *bufev)
{
int r = 0;
//用户监听了读事件
if (event_pending(&bufev->ev_read, EV_READ, NULL))
if (be_socket_add(&bufev->ev_read, &bufev->timeout_read) < 0)
r = -1;
//用户监听了写事件
if (event_pending(&bufev->ev_write, EV_WRITE, NULL)) {
if (be_socket_add(&bufev->ev_write, &bufev->timeout_write) < 0)
r = -1;
}
return r;
}
从上面代码可以看到：用户不仅仅可以设置超时值，还可以修改超时值，也是通过这个函数进行修的。当然也是可以删除超时的，直接把超时参数设置成NULL即可。
至此，已经完成了bufferevent的初始化工作，只需调用event_base_dispatch函数，启动发动机就可以工作了。处理读事件：
现在来看一下，底层的socket fd接收数据后，bufferevent是怎么工作的。
读事件的水位：
在讲读事件之前，先来看一下水位问题，函数bufferevent_setwatermark可以设置读和写的水位。这里只讲解读事件的水位。
水位有两个：低水位和高水位。
低水位比较容易懂，就是当可读的数据量到达这个低水位后，才会调用用户设置的回调函数。比如用户想每次读取100字节，那么就可以把低水位设置为100。当可读数据的字节数小于100时，即使有数据都不会打扰用户(即不会调用用户设置的回调函数)。可读数据大于等于100字节后，才会调用用户的回调函数。
高水位是什么呢？其实，这和用户的回调函数没有关系。它的意义是：把读事件的evbuffer的数据量限制在高水位之下。比如，用户认为读缓冲区不能太大(太大的话，链表会很长)。那么用户就会设置读事件的高水位。当读缓冲区的数据量达到这个高水位后，即使socket fd还有数据没有读，也不会读进这个读缓冲区里面。一句话说，就是控制evbuffer的大小。
虽然控制了evbuffer的大小，但socket fd可能还有数据。有数据就会触发可读事件，但处理可读的时候，又会发现设置了高水位，不能读取数据evbuffer。socket fd的数据没有被读完，又触发……。这个貌似是一个死循环。实际上是不会出现这个死循环的，因为Libevent发现evbuffer的数据量到达高水位后，就会把可读事件给挂起来，让它不能再触发了。Libevent使用函数bufferevent_wm_suspend_read把监听读事件的event挂起来。下面看一下Libevent是怎么把一个event挂起来的。
//bufferevent-internal.h文件
#define bufferevent_wm_suspend_read(b) \
bufferevent_suspend_read((b), BEV_SUSPEND_WM)
//bufferevent.c文件
void
bufferevent_suspend_read(struct bufferevent *bufev, bufferevent_suspend_flags what)
{
struct bufferevent_private *bufev_private =
EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
BEV_LOCK(bufev);
if (!bufev_private->read_suspended)//不能挂多次
bufev->be_ops->disable(bufev, EV_READ);//实际调用be_socket_disable函数
bufev_private->read_suspended |= what;//因何而被挂起
BEV_UNLOCK(bufev);
}
//bufferevent_sock.c文件
static int
be_socket_disable(struct bufferevent *bufev, short event)
{
struct bufferevent_private *bufev_p =
EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
if (event & EV_READ) {
if (event_del(&bufev->ev_read) == -1)
return -1;
}
/* Don't actually disable the write if we are trying to connect. */
if ((event & EV_WRITE) && ! bufev_p->connecting) {
if (event_del(&bufev->ev_write) == -1)//删掉这个event
return -1;
}
return 0;
}
居然是直接删除这个监听读事件的event，真的是挂了!!!
看来不能随便设置高水位，因为它会暂停读。如果只想设置低水位而不想设置高水位，那么在调用bufferevent_setwatermark函数时，高水位的参数设为0即可。
那么什么时候取消挂起，让bufferevent可以继续读socket 数据呢？从高水位的意义来说，当然是当evbuffer里面的数据量小于高水位时，就能再次读取socket数据了。现在来看一下Libevent是怎么恢复读的。看一下设置水位的函数bufferevent_setwatermark吧，它进行了一些为高水位埋下了一个回调函数。对，就是evbuffer的回调函数。前一篇博文说到，当evbuffer里面的数据添加或者删除时，是会触发一些回调函数的。当用户移除evbuffer的一些数据量时，Libevent就会检查这个evbuffer的数据量是否小于高水位，如果小于的话，那么就恢复 读事件。
不说这么多了，上代码。
//bufferevent.c文件
void
bufferevent_setwatermark(struct bufferevent *bufev, short events,
size_t lowmark, size_t highmark)
{
struct bufferevent_private *bufev_private =
EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
BEV_LOCK(bufev);
if (events & EV_READ) {
bufev->wm_read.low = lowmark;
bufev->wm_read.high = highmark;
if (highmark) {//高水位
/* There is now a new high-water mark for read.
enable the callback if needed, and see if we should
suspend/bufferevent_wm_unsuspend. */
//还没设置高水位的回调函数
if (bufev_private->read_watermarks_cb == NULL) {
bufev_private->read_watermarks_cb =
evbuffer_add_cb(bufev->input,
bufferevent_inbuf_wm_cb,
bufev);//添加回调函数
}
evbuffer_cb_set_flags(bufev->input,
bufev_private->read_watermarks_cb,
EVBUFFER_CB_ENABLED|EVBUFFER_CB_NODEFER);
//设置(修改)高水位时，evbuffer的数据量已经超过了水位值
//可能是把之前的高水位调高或者调低
//挂起操作和取消挂起操作都是幂等的(即多次挂起的作用等同于挂起一次)
if (evbuffer_get_length(bufev->input) > highmark)
bufferevent_wm_suspend_read(bufev);
else if (evbuffer_get_length(bufev->input) < highmark)//调低了
bufferevent_wm_unsuspend_read(bufev);
} else {
//高水位值等于0，那么就要取消挂起 读事件
//取消挂起操作是幂等的
/* There is now no high-water mark for read. */
if (bufev_private->read_watermarks_cb)
evbuffer_cb_clear_flags(bufev->input,
bufev_private->read_watermarks_cb,
EVBUFFER_CB_ENABLED);
bufferevent_wm_unsuspend_read(bufev);
}
}
BEV_UNLOCK(bufev);
}
这个函数，不仅仅为高水位设置回调函数，还会检查当前evbuffer的数据量是否超过了高水位。因为这个设置水位函数可能是在bufferevent工作一段时间后才添加的，所以evbuffer是有可能已经有数据的了，因此需要检查。如果超过了水位值，那么就需要挂起读。当然也存在另外一种可能：用户之前设置过了一个比较大的高水位，挂起了读。现在发现错了，就把高水位调低一点，此时就需要恢复读。
现在假设用户移除了一些evbuffer的数据，进而触发了evbuffer的回调函数，当然也就调用了函数bufferevent_inbuf_wm_cb。下面看一下这个函数是怎么恢复读的。
//bufferevent.c文件
static void
bufferevent_inbuf_wm_cb(struct evbuffer *buf,
const struct evbuffer_cb_info *cbinfo,
void *arg)
{
struct bufferevent *bufev = arg;
size_t size;
size = evbuffer_get_length(buf);
if (size >= bufev->wm_read.high)
bufferevent_wm_suspend_read(bufev);
else
bufferevent_wm_unsuspend_read(bufev);
}
//bufferevent-internal.h文件
#define bufferevent_wm_unsuspend_read(b) \
bufferevent_unsuspend_read((b), BEV_SUSPEND_WM)
//bufferevent.c文件
void
bufferevent_unsuspend_read(struct bufferevent *bufev, bufferevent_suspend_flags what)
{
struct bufferevent_private *bufev_private =
EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
BEV_LOCK(bufev);
bufev_private->read_suspended &= ~what;
if (!bufev_private->read_suspended && (bufev->enabled & EV_READ))
bufev->be_ops->enable(bufev, EV_READ);//重新把event插入到event_base中
BEV_UNLOCK(bufev);
}
因为用户可以手动为这个evbuffer添加数据，此时也会调用bufferevent_inbuf_wm_cb函数。此时就要检查evbuffer的数据量是否已经超过高水位了，而不能仅仅检查是否低于高水位。
高水位导致读的挂起和之后读的恢复，一切工作都是由Libevent内部完成的，用户不用做任何工作。
从socket中读取数据：
从前面的一系列博文可以知道，如果一个socket可读了，那么监听可读事件的event的回调函数就会被调用。这个回调函数是在bufferevent_socket_new函数中被Libevent内部设置的，设置为bufferevent_readcb函数，用户并不知情。
当socket有数据可读时，Libevent就会监听到，然后调用bufferevent_readcb函数处理。该函数会调用evbuffer_read函数，把数据从socket fd中读取到evbuffer中。然后再调用用户在bufferevent_setcb函数中设置的读事件回调函数。所以，当用户的读事件回调函数被调用时，数据已经在evbuffer中了，用户拿来就用，无需调用read这类会阻塞的函数。
下面看一下bufferevent_readcb函数的具体实现。static void
bufferevent_readcb(evutil_socket_t fd, short event, void *arg)
{
struct bufferevent *bufev = arg;
struct bufferevent_private *bufev_p =
EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
struct evbuffer *input;
int res = 0;
short what = BEV_EVENT_READING;
ev_ssize_t howmuch = -1, readmax=-1;
_bufferevent_incref_and_lock(bufev);
if (event == EV_TIMEOUT) {
/* Note that we only check for event==EV_TIMEOUT. If
* event==EV_TIMEOUT|EV_READ, we can safely ignore the
* timeout, since a read has occurred */
what |= BEV_EVENT_TIMEOUT;
goto error;
}
input = bufev->input;
//用户设置了高水位
if (bufev->wm_read.high != 0) {
howmuch = bufev->wm_read.high - evbuffer_get_length(input);
/* we somehow lowered the watermark, stop reading */
if (howmuch <= 0) {
bufferevent_wm_suspend_read(bufev);
goto done;
}
}
//因为用户可以限速，所以这么要检测最大的可读大小。
//如果没有限速的话，那么将返回16384字节，即16K
//默认情况下是没有限速的。
readmax = _bufferevent_get_read_max(bufev_p);
if (howmuch < 0 || howmuch > readmax) /* The use of -1 for "unlimited"
* uglifies this code. XXXX */
howmuch = readmax;
//一些原因导致读 被挂起，比如加锁了。
if (bufev_p->read_suspended)
goto done;
//解冻，使得可以在input的后面追加数据
evbuffer_unfreeze(input, 0);
res = evbuffer_read(input, fd, (int)howmuch); //从socket fd中读取数据
evbuffer_freeze(input, 0);//冻结
if (res == -1) {
int err = evutil_socket_geterror(fd);
if (EVUTIL_ERR_RW_RETRIABLE(err))//EINTER or EAGAIN
goto reschedule;
//不是 EINTER or EAGAIN 这两个可以重试的错误，那么就应该是其他致命的错误
//此时，应该报告给用户
what |= BEV_EVENT_ERROR;/**< unrecoverable error encountered */
} else if (res == 0) {//断开了连接
what |= BEV_EVENT_EOF;
}
if (res <= 0)
goto error;
//速率相关的操作
_bufferevent_decrement_read_buckets(bufev_p, res);
//evbuffer的数据量大于低水位值。
if (evbuffer_get_length(input) >= bufev->wm_read.low)
_bufferevent_run_readcb(bufev);//调用用户设置的回调函数
goto done;
reschedule:
goto done;
error:
//把监听可读事件的event从event_base的事件队列中删除掉.event_del
bufferevent_disable(bufev, EV_READ);//会调用be_socket_disable函数
_bufferevent_run_eventcb(bufev, what);//会调用用户设置的错误处理函数
done:
_bufferevent_decref_and_unlock(bufev);
}
细心的读者可能会发现：对用户的读事件回调函数的触发是边缘触发的。这也就要求，在回调函数中，用户应该尽可能地把evbuffer的所有数据都读出来。如果想等到下一次回调时再读，那么需要等到下一次socketfd接收到数据才会触发用户的回调函数。如果之后socket fd一直收不到任何数据，那么即使evbuffer还有数据，用户的回调函数也不会被调用了。
处理写事件：
对一个可读事件进行监听是比较容易的，但对于一个可写事件进行监听则比较困难。为什么呢？因为可读监听是监听fd的读缓冲区是否有数据了，如果没有数据那么就一直等待。对于可写，首先要明白“什么是可写”，可写就是fd的写缓冲区(这个缓冲区在内核)还没满，可以往里面放数据。这就有一个问题，如果写缓冲区没有满，那么就一直是可写状态。如果一个event监听了可写事件，那么这个event就会一直被触发，因为一般情况下，如果不是发大量的数据这个写缓冲区是不会满的。
也就是说，不能监听可写事件。但我们确实要往fd中写数据，那怎么办？Libevent的做法是：当我们确实要写入数据时，才监听可写事件。也就是说我们调用bufferevent_write写入数据时，Libevent才会把监听可写事件的那个event注册到event_base中。当Libevent把数据都写入到fd的缓冲区后，Libevent又会把这个event从event_base中删除。比较烦琐。
bufferevent_writecb函数不仅仅要处理上面说到的那个问题，还要处理另外一个坑爹的问题。那就是：判断socket fd是不是已经连接上服务器了。这是因为这个socket fd是非阻塞的，所以它调用connect时，可能还没连接上就返回了。对于非阻塞socket fd，一般是通过判断这个socket是否可写，从而得知这个socket是否已经连接上服务器。如果可写，那么它就已经成功连接上服务器了。这个问题，这里先提一下，后面会详细讲。
同前面的监听可读一样，Libevent是在bufferevent_socket_new函数设置可写的回调函数，为bufferevent_writecb。
//bufferevent_sock.c文件
static void
bufferevent_writecb(evutil_socket_t fd, short event, void *arg)
{
struct bufferevent *bufev = arg;
struct bufferevent_private *bufev_p =
EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
int res = 0;
short what = BEV_EVENT_WRITING;
int connected = 0;
ev_ssize_t atmost = -1;
_bufferevent_incref_and_lock(bufev);
if (event == EV_TIMEOUT) {
/* Note that we only check for event==EV_TIMEOUT. If
* event==EV_TIMEOUT|EV_WRITE, we can safely ignore the
* timeout, since a read has occurred */
what |= BEV_EVENT_TIMEOUT;
goto error;
}
...//判断这个socket是否已经连接上服务器了
//用户可能设置了限速，如果没有限速，那么atmost将返回16384(16K)
atmost = _bufferevent_get_write_max(bufev_p);
//一些原因导致写被挂起来了
if (bufev_p->write_suspended)
goto done;
//如果evbuffer有数据可以写到sockfd中
if (evbuffer_get_length(bufev->output)) {
//解冻链表头
evbuffer_unfreeze(bufev->output, 1);
//将output这个evbuffer的数据写到socket fd 的缓冲区中
//会把已经写到socket fd缓冲区的数据，从evbuffer中删除
res = evbuffer_write_atmost(bufev->output, fd, atmost);
evbuffer_freeze(bufev->output, 1);
if (res == -1) {
int err = evutil_socket_geterror(fd);
if (EVUTIL_ERR_RW_RETRIABLE(err))//可以恢复的错误。一般是EINTR或者EAGAIN
goto reschedule;
what |= BEV_EVENT_ERROR;
} else if (res == 0) {//该socket已经断开连接了
what |= BEV_EVENT_EOF;
}
if (res <= 0)
goto error;
}
//如果把写缓冲区的数据都写完成了。为了防止event_base不断地触发可写
//事件，此时要把这个监听可写的event删除。
//前面的atmost限制了一次最大的可写数据。如果还没写所有的数据
//那么就不能delete这个event，而是要继续监听可写事情，知道把所有的
//数据都写到socket fd中。
if (evbuffer_get_length(bufev->output) == 0) {
event_del(&bufev->ev_write);
}
//如果evbuffer里面的数据量已经写得七七八八了，小于设置的低水位值，那么
//就会调用用户设置的写事件回调函数
if ((res || !connected) &&
evbuffer_get_length(bufev->output) <= bufev->wm_write.low) {
_bufferevent_run_writecb(bufev);
}
goto done;
reschedule:
if (evbuffer_get_length(bufev->output) == 0) {
event_del(&bufev->ev_write);
}
goto done;
error:
bufferevent_disable(bufev, EV_WRITE);//有错误。把这个写event删除
_bufferevent_run_eventcb(bufev, what);
done:
_bufferevent_decref_and_unlock(bufev);
}
上面代码的逻辑比较清晰，调用evbuffer_write_atmost函数把数据从evbuffer中写到evbuffer缓冲区中，此时要注意函数的返回值，因为可能写的时候发生错误。如果发生了错误，就要调用用户设置的event回调函数(网上也有人称其为错误处理函数)。
之后，还要判断evbuffer的数据是否已经全部写到socket 的缓冲区了。如果已经全部写了，那么就要把监听写事件的event从event_base的插入队列中删除。如果还没写完，那么就不能删除，因为还要继续监听可写事件，下次接着写。
现在来看一下，把监听写事件的event从event_base的插入队列中删除后，如果下次用户有数据要写的时候，怎么把这个event添加到event_base的插入队列。
用户一般是通过bufferevent_write函数把数据写入到evbuffer(写入evbuffer后，接着就会被写入socket，所以调用bufferevent_write就相当于把数据写入到socket。)。而这个bufferevent_write函数是直接调用evbuffer_add函数的。函数evbuffer_add没有调用什么可疑的函数，能够把监听可写的event添加到event_base中。唯一的可能就是那个回调函数。对就是evbuffer的回调函数。关于evbuffer的回调函数，可以参考这里。
//bufferevent.c文件
int
bufferevent_write(struct bufferevent *bufev, const void *data, size_t size)
{
if (evbuffer_add(bufev->output, data, size) == -1)
return (-1);
return 0;
}
//buffer.c文件
int
evbuffer_add(struct evbuffer *buf, const void *data_in, size_t datlen)
{
...
out:
evbuffer_invoke_callbacks(buf);//调用回调函数
result = 0;
done:
return result;
}
还记得本文前面的bufferevent_socket_new函数吗？该函数里面会有
evbuffer_add_cb(bufev->output,bufferevent_socket_outbuf_cb, bufev);
当bufferevent的写缓冲区output的数据发生变化时，函数bufferevent_socket_outbuf_cb就会被调用。现在马上飞到这个函数。
//bufferevent_sock.c文件
static void
bufferevent_socket_outbuf_cb(struct evbuffer *buf,
const struct evbuffer_cb_info *cbinfo,
void *arg)
{
struct bufferevent *bufev = arg;
struct bufferevent_private *bufev_p =
EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
if (cbinfo->n_added && //evbuffer添加了数据
(bufev->enabled & EV_WRITE) && //默认情况下是enable EV_WRITE的
!event_pending(&bufev->ev_write, EV_WRITE, NULL) &&//这个event已经被踢出event_base了
!bufev_p->write_suspended) {//这个bufferevent的写并没有被挂起
//把这个event添加到event_base中
if (be_socket_add(&bufev->ev_write, &bufev->timeout_write) == -1) {
/* Should we log this? */
}
}
}
这个函数首先进行一些判断，满足条件后就会把这个监听写事件的event添加到event_base中。其中event_pending函数就是判断这个bufev->ev_write是否已经被event_base删除了。关于event_pending，可以参考这里。
对于bufferevent_write，初次使用该函数的读者可能会有疑问：调用该函数后，参数data指向的内存空间能不能马上释放，还是要等到Libevent把data指向的数据都写到socket 缓存区才能删除？其实，从前一篇博文可以看到，evbuffer_add是直接复制一份用户要发送的数据到evbuffer缓存区的。所以，调用完bufferevent_write，就可以马上释放参数data指向的内存空间。
网上的关于Libevent的一些使用例子，包括我写的《 Libevent使用例子，从简单到复杂》，都是在主线程中调用bufferevent_write函数写入数据的。从上面的分析可以得知，是可以马上把监听可写事件的event添加到event_base中。如果是在次线程调用该函数写入数据呢？此时，主线程可能还睡眠在poll、epoll这类的多路IO复用函数上。这种情况下能不能及时唤醒主线程呢？其实是可以的，只要你的Libevent在一开始使用了线程功能。具体的分析过程可以参考《evthread_notify_base通知主线程》。上面代码中的be_socket_add会调用event_add，而在次线程调用event_add就会调用evthread_notify_base通知主线程。
bufferevent_socket_connect：
用户可以在调用bufferevent_socket_new函数时，传一个-1作为socket的文件描述符，然后调用bufferevent_socket_connect函数连接服务器，无需自己写代码调用connect函数连接服务器。
bufferevent_socket_connect函数会调用socket函数申请一个套接字fd，然后把这个fd设置成非阻塞的(这就导致了一些坑爹的事情)。接着就connect服务器，因为该socket fd是非阻塞的，所以不会等待，而是马上返回，连接这工作交给内核来完成。所以，返回后这个socket还没有真正连接上服务器。那么什么时候连接上呢？内核又是怎么通知通知用户呢？
一般来说，当可以往socket fd写东西了，那就说明已经连接上了。也就是说这个socket fd变成可写状态，就连接上了。
所以，对于“非阻塞connect”比较流行的做法是：用select或者poll这类多路IO复用函数监听该socket的可写事件。当这个socket触发了可写事件，然后再对这个socket调用getsockopt函数，做进一步的判断。
Libevent也是这样实现的，下面来看一下bufferevent_socket_connect函数。//bufferevent_sock.c文件
int
bufferevent_socket_connect(struct bufferevent *bev,
struct sockaddr *sa, int socklen)
{
struct bufferevent_private *bufev_p =
EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
evutil_socket_t fd;
int r = 0;
int result=-1;
int ownfd = 0;
_bufferevent_incref_and_lock(bev);
if (!bufev_p)
goto done;
fd = bufferevent_getfd(bev);
if (fd < 0) {//该bufferevent还没有设置fd
if (!sa)
goto done;
fd = socket(sa->sa_family, SOCK_STREAM, 0);
if (fd < 0)
goto done;
if (evutil_make_socket_nonblocking(fd)<0)//设置为非阻塞
goto done;
ownfd = 1;
}
if (sa) {
r = evutil_socket_connect(&fd, sa, socklen);//非阻塞connect
if (r < 0)
goto freesock;
}
...
//为bufferevent里面的两个event设置监听的fd
//后面会调用bufferevent_enable
bufferevent_setfd(bev, fd);
if (r == 0) {//暂时还没连接上，因为fd是非阻塞的
//此时需要监听可写事件，当可写了，并且没有错误的话，就成功连接上了
if (! be_socket_enable(bev, EV_WRITE)) {
bufev_p->connecting = 1;//标志这个sockfd正在连接
result = 0;
goto done;
}
} else if (r == 1) {//已经连接上了
/* The connect succeeded already. How very BSD of it. */
result = 0;
bufev_p->connecting = 1;
event_active(&bev->ev_write, EV_WRITE, 1);//手动激活这个event
} else {// connection refused
/* The connect failed already. How very BSD of it. */
bufev_p->connection_refused = 1;
bufev_p->connecting = 1;
result = 0;
event_active(&bev->ev_write, EV_WRITE, 1);//手动激活这个event
}
goto done;
freesock:
_bufferevent_run_eventcb(bev, BEV_EVENT_ERROR);//出现错误
if (ownfd)
evutil_closesocket(fd);
done:
_bufferevent_decref_and_unlock(bev);
return result;
}
这个函数比较多错误处理的代码，大致看一下就行了。有几个地方要注意，即使connect的时候被拒绝，或者已经连接上了，都会手动激活这个event。一个event即使没有加入event_base，也是可以手动激活的。具体原理参考这里。
无论是手动激活event，或者监听到这个event可写了，都是会调用bufferevent_writecb函数。现在再次看一下该函数，只看connect部分。
//bufferevent_sock.c文件
static void
bufferevent_writecb(evutil_socket_t fd, short event, void *arg)
{
struct bufferevent_private *bufev_p =
EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
int connected = 0;
_bufferevent_incref_and_lock(bufev);
...
//正在连接。因为这个sockfd可能是非阻塞的，所以可能之前的connect还没
//连接上。而判断该sockfd是否成功连接上了的一个方法是判断这个sockfd是否可写
if (bufev_p->connecting) {
//c等于1，说明已经连接成功
//c等于0，说明还没连接上
//c等于-1，说明发生错误
int c = evutil_socket_finished_connecting(fd);
if (bufev_p->connection_refused) {//在bufferevent_socket_connect中被设置
bufev_p->connection_refused = 0;
c = -1;
}
if (c == 0)//还没连接上，继续监听可写吧
goto done;
//错误，或者已经连接上了
bufev_p->connecting = 0;//修改标志值
if (c < 0) {//错误
event_del(&bufev->ev_write);
event_del(&bufev->ev_read);
_bufferevent_run_eventcb(bufev, BEV_EVENT_ERROR);
goto done;
} else {//连接上了。
connected = 1;
...//win32
//居然会调用用户设置的错误处理函数。太神奇了
_bufferevent_run_eventcb(bufev,
BEV_EVENT_CONNECTED);
if (!(bufev->enabled & EV_WRITE) || //默认都是enable EV_WRITE的
bufev_p->write_suspended) {
event_del(&bufev->ev_write);//不再需要监听可写。因为已经连接上了
goto done;
}
}
}
...
done:
_bufferevent_decref_and_unlock(bufev);
}
可以看到无论是connect被拒绝、发生错误或者连接上了，都在这里做统一的处理。
如果已经连接上了，那么会调用用户设置event回调函数(网上也称之为错误处理函数)，通知用户已经连接上了。并且，还会把监听可写事件的event从event_base中删除，其理由在前面已经说过了。
函数evutil_socket_finished_connecting会检查这个socket，从而得知这个socket是处于什么状态。在bufferevent_socket_connect函数中，出现的一些错误，比如被拒绝，也是能通过这个函数检查出来的。所以可以在这里做统一的处理。该函数的内部是使用。贴一下这个函数的代码吧。
//evutil.c文件
//Return 1 for connected, 0 for not yet, -1 for error.
int
evutil_socket_finished_connecting(evutil_socket_t fd)
{
int e;
ev_socklen_t elen = sizeof(e);
//用来检测这个fd是否已经连接上了，这个fd是非阻塞的
//如果e的值被设为0，那么就说明连接上了。
//否则e被设置为对应的错误值。
if (getsockopt(fd, SOL_SOCKET, SO_ERROR, (void*)&e, &elen) < 0)
return -1;
if (e) {
if (EVUTIL_ERR_CONNECT_RETRIABLE(e))//还没连接上
return 0;
EVUTIL_SET_SOCKET_ERROR(e);
return -1;
}
return 1;
}
好长啊！终于写完了。