/*

* Copyright (c) 2007-2012 Niels Provos and Nick Mathewson

* Copyright (c) 2002-2006 Niels Provos <provos@citi.umich.edu>

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

* 3. The name of the author may not be used to endorse or promote products

* derived from this software without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#include <sys/types.h>

#include "event2/event-config.h"

#ifdef _EVENT_HAVE_SYS_TIME_H

#include <sys/time.h>

#endif

#include <errno.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifdef _EVENT_HAVE_STDARG_H

#include <stdarg.h>

#endif

#ifdef _EVENT_HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef WIN32

#include <winsock2.h>

#include <ws2tcpip.h>

#endif

#ifdef _EVENT_HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#endif

#ifdef _EVENT_HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

#ifdef _EVENT_HAVE_NETINET_IN6_H

#include <netinet/in6.h>

#endif

#include "event2/util.h"

#include "event2/bufferevent.h"

#include "event2/buffer.h"

#include "event2/bufferevent_struct.h"

#include "event2/bufferevent_compat.h"

#include "event2/event.h"

#include "log-internal.h"

#include "mm-internal.h"

#include "bufferevent-internal.h"

#include "util-internal.h"

#ifdef WIN32

#include "iocp-internal.h"

#endif

/* prototypes */

static int be_socket_enable(struct bufferevent *, short);

static int be_socket_disable(struct bufferevent *, short);

static void be_socket_destruct(struct bufferevent *);

static int be_socket_adj_timeouts(struct bufferevent *);

static int be_socket_flush(struct bufferevent *, short, enum bufferevent_flush_mode);

static int be_socket_ctrl(struct bufferevent *, enum bufferevent_ctrl_op, union bufferevent_ctrl_data *);

static void be_socket_setfd(struct bufferevent *, evutil_socket_t);

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,

};

#define be_socket_add(ev, t) \

_bufferevent_add_event((ev), (t))

//用户添加数据，打开写事件。

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

(bufev->enabled & EV_WRITE) &&

!event_pending(&bufev->ev_write, EV_WRITE, NULL) &&

!bufev_p->write_suspended) {

/* Somebody added data to the buffer, and we would like to

* write, and we were not writing. So, start writing. */

if (be_socket_add(&bufev->ev_write, &bufev->timeout_write) == -1) {

/* Should we log this? */

}

}

}

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 we have a high watermark configured then we don't want to

* read more data than would make us reach the watermark.

*/

if (bufev->wm_read.high != 0) {

howmuch = bufev->wm_read.high - evbuffer_get_length(input);

/* 缓冲区超过高水位，挂起读。 */

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;

evbuffer_unfreeze(input, 0);

res = evbuffer_read(input, fd, (int)howmuch); /* XXXX evbuffer_read would do better to take and return ev_ssize_t */

evbuffer_freeze(input, 0);

if (res == -1) {

int err = evutil_socket_geterror(fd);

if (EVUTIL_ERR_RW_RETRIABLE(err)) //EINTER or EAGAIN

goto reschedule;

/* error case */

what |= BEV_EVENT_ERROR;

} else if (res == 0) {

/* eof case */

what |= BEV_EVENT_EOF;

}

if (res <= 0)

goto error;

_bufferevent_decrement_read_buckets(bufev_p, res);

/* 数据大于低水平，调用用户设置的回调。 */

if (evbuffer_get_length(input) >= bufev->wm_read.low)

_bufferevent_run_readcb(bufev);

goto done;

reschedule:

goto done;

error:

bufferevent_disable(bufev, EV_READ);

_bufferevent_run_eventcb(bufev, what);

done:

_bufferevent_decref_and_unlock(bufev);

}

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;

}

//正在连接服务器...

if (bufev_p->connecting) {

int c = evutil_socket_finished_connecting(fd);

/* we need to fake the error if the connection was refused

* immediately - usually connection to localhost on BSD */

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;

#ifdef WIN32

if (BEV_IS_ASYNC(bufev)) {

event_del(&bufev->ev_write);

bufferevent_async_set_connected(bufev);

_bufferevent_run_eventcb(bufev,

BEV_EVENT_CONNECTED);

goto done;

}

#endif

//连接成功，调用用户错误处理函数。比较奇怪。

_bufferevent_run_eventcb(bufev,

BEV_EVENT_CONNECTED);

if (!(bufev->enabled & EV_WRITE) ||

bufev_p->write_suspended) {

event_del(&bufev->ev_write);

goto done;

}

}

}

atmost = _bufferevent_get_write_max(bufev_p);

//写被挂起

if (bufev_p->write_suspended)

goto done;

//存在可写数据

if (evbuffer_get_length(bufev->output)) {

evbuffer_unfreeze(bufev->output, 1);

//将缓冲区数据写入socket。

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)) //socket缓冲区满，一次未写完，继续监听可写事件，等待下次写入。

goto reschedule;

what |= BEV_EVENT_ERROR; //写发生异常错误

} else if (res == 0) {

/* eof case

XXXX Actually, a 0 on write doesn't indicate

an EOF. An ECONNRESET might be more typical.

*/

what |= BEV_EVENT_EOF;

}

if (res <= 0)

goto error;

_bufferevent_decrement_write_buckets(bufev_p, res);

}

//缓冲区数据已写完，删除写事件。

if (evbuffer_get_length(bufev->output) == 0) {

event_del(&bufev->ev_write);

}

/* 低于写低水位，调用用户回调。

*/

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

_bufferevent_run_eventcb(bufev, what);

done:

_bufferevent_decref_and_unlock(bufev);

}

struct bufferevent *

bufferevent_socket_new(struct event_base *base, evutil_socket_t fd,

int options)

{

struct bufferevent_private *bufev_p;

struct bufferevent *bufev;

#ifdef WIN32

if (base && event_base_get_iocp(base))

return bufferevent_async_new(base, fd, options);

#endif

if ((bufev_p = mm_calloc(1, sizeof(struct bufferevent_private)))== NULL)

return NULL;

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

//设置读写回调

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

/* 虽然这里冻结了，但实际上Libevent在读数据或者写数据之前会解冻的读完或者写完数据后，又会马上冻结。

* 这主要防止数据被意外修改。用户一般不会直接调用evbuffer_freeze或者evbuffer_unfreeze函数。

* 一切的冻结和解冻操作都由Libevent内部完成。还有一点要注意，因为这里只是把写缓冲区的头部冻结了。

* 所以还是可以往写缓冲区的尾部追加数据。同样，此时也是可以从读缓冲区读取数据。这个是必须的。

* 因为在Libevent内部不解冻的时候，用户需要从读缓冲区中获取数据(这相当于从socket fd中读取数据)，

* 用户也需要把数据写到写缓冲区中(这相当于把数据写入到socket fd中)。*/

//冻结读缓冲区的尾部，未解冻之前不能往读缓冲区追加数据

//也就是说不能从socket fd中读取数据

evbuffer_freeze(bufev->input, 0);

//冻结写缓冲区的头部，未解冻之前不能把写缓冲区的头部数据删除

//也就是说不能把数据写到socket fd

evbuffer_freeze(bufev->output, 1);

return bufev;

}

/* bufferevent 非阻塞连接 */

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

//还没设置fd，设置fd。

if (fd < 0) {

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) {

#ifdef WIN32

if (bufferevent_async_can_connect(bev)) {

bufferevent_setfd(bev, fd);

r = bufferevent_async_connect(bev, fd, sa, socklen);

if (r < 0)

goto freesock;

bufev_p->connecting = 1;

result = 0;

goto done;

} else

#endif

//非阻塞连接

r = evutil_socket_connect(&fd, sa, socklen);

if (r < 0)

goto freesock;

}

#ifdef WIN32

/* ConnectEx() isn't always around, even when IOCP is enabled.

* Here, we borrow the socket object's write handler to fall back

* on a non-blocking connect() when ConnectEx() is unavailable. */

if (BEV_IS_ASYNC(bev)) {

event_assign(&bev->ev_write, bev->ev_base, fd,

EV_WRITE|EV_PERSIST, bufferevent_writecb, bev);

}

#endif

bufferevent_setfd(bev, fd);

if (r == 0) { /* 正在连接，监听读事件。*/

if (! be_socket_enable(bev, EV_WRITE)) {

bufev_p->connecting = 1;

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

} else {

/* 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);

}

goto done;

freesock:

_bufferevent_run_eventcb(bev, BEV_EVENT_ERROR);

if (ownfd)

evutil_closesocket(fd);

/* do something about the error? */

done:

_bufferevent_decref_and_unlock(bev);

return result;

}

static void

bufferevent_connect_getaddrinfo_cb(int result, struct evutil_addrinfo *ai,

void *arg)

{

struct bufferevent *bev = arg;

struct bufferevent_private *bev_p =

EVUTIL_UPCAST(bev, struct bufferevent_private, bev);

int r;

BEV_LOCK(bev);

bufferevent_unsuspend_write(bev, BEV_SUSPEND_LOOKUP);

bufferevent_unsuspend_read(bev, BEV_SUSPEND_LOOKUP);

if (result != 0) {

bev_p->dns_error = result;

_bufferevent_run_eventcb(bev, BEV_EVENT_ERROR);

_bufferevent_decref_and_unlock(bev);

if (ai)

evutil_freeaddrinfo(ai);

return;

}

/* XXX use the other addrinfos? */

/* XXX use this return value */

r = bufferevent_socket_connect(bev, ai->ai_addr, (int)ai->ai_addrlen);

(void)r;

_bufferevent_decref_and_unlock(bev);

evutil_freeaddrinfo(ai);

}

int

bufferevent_socket_connect_hostname(struct bufferevent *bev,

struct evdns_base *evdns_base, int family, const char *hostname, int port)

{

char portbuf[10];

struct evutil_addrinfo hint;

int err;

struct bufferevent_private *bev_p =

EVUTIL_UPCAST(bev, struct bufferevent_private, bev);

if (family != AF_INET && family != AF_INET6 && family != AF_UNSPEC)

return -1;

if (port < 1 || port > 65535)

return -1;

BEV_LOCK(bev);

bev_p->dns_error = 0;

BEV_UNLOCK(bev);

evutil_snprintf(portbuf, sizeof(portbuf), "%d", port);

memset(&hint, 0, sizeof(hint));

hint.ai_family = family;

hint.ai_protocol = IPPROTO_TCP;

hint.ai_socktype = SOCK_STREAM;

bufferevent_suspend_write(bev, BEV_SUSPEND_LOOKUP);

bufferevent_suspend_read(bev, BEV_SUSPEND_LOOKUP);

bufferevent_incref(bev);

err = evutil_getaddrinfo_async(evdns_base, hostname, portbuf,

&hint, bufferevent_connect_getaddrinfo_cb, bev);

if (err == 0) {

return 0;

} else {

bufferevent_unsuspend_write(bev, BEV_SUSPEND_LOOKUP);

bufferevent_unsuspend_read(bev, BEV_SUSPEND_LOOKUP);

return -1;

}

}

int

bufferevent_socket_get_dns_error(struct bufferevent *bev)

{

int rv;

struct bufferevent_private *bev_p =

EVUTIL_UPCAST(bev, struct bufferevent_private, bev);

BEV_LOCK(bev);

rv = bev_p->dns_error;

BEV_UNLOCK(bev);

return rv;

}

/*

* Create a new buffered event object.

*

* The read callback is invoked whenever we read new data.

* The write callback is invoked whenever the output buffer is drained.

* The error callback is invoked on a write/read error or on EOF.

*

* Both read and write callbacks maybe NULL. The error callback is not

* allowed to be NULL and have to be provided always.

*/

struct bufferevent *

bufferevent_new(evutil_socket_t fd,

bufferevent_data_cb readcb, bufferevent_data_cb writecb,

bufferevent_event_cb eventcb, void *cbarg)

{

struct bufferevent *bufev;

if (!(bufev = bufferevent_socket_new(NULL, fd, 0)))

return NULL;

bufferevent_setcb(bufev, readcb, writecb, eventcb, cbarg);

return bufev;

}

/* 将读写事件添加到event_base */

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;

}

//挂起某个事件(直接删除)。

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)

return -1;

}

return 0;

}

static void

be_socket_destruct(struct bufferevent *bufev)

{

struct bufferevent_private *bufev_p =

EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);

evutil_socket_t fd;

EVUTIL_ASSERT(bufev->be_ops == &bufferevent_ops_socket);

fd = event_get_fd(&bufev->ev_read);

event_del(&bufev->ev_read);

event_del(&bufev->ev_write);

if ((bufev_p->options & BEV_OPT_CLOSE_ON_FREE) && fd >= 0)

EVUTIL_CLOSESOCKET(fd);

}

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;

}

static int

be_socket_flush(struct bufferevent *bev, short iotype,

enum bufferevent_flush_mode mode)

{

return 0;

}

static void

be_socket_setfd(struct bufferevent *bufev, evutil_socket_t fd)

{

BEV_LOCK(bufev);

EVUTIL_ASSERT(bufev->be_ops == &bufferevent_ops_socket);

event_del(&bufev->ev_read);

event_del(&bufev->ev_write);

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

if (fd >= 0)

bufferevent_enable(bufev, bufev->enabled);

BEV_UNLOCK(bufev);

}

/* XXXX Should non-socket bufferevents support this? */

int

bufferevent_priority_set(struct bufferevent *bufev, int priority)

{

int r = -1;

BEV_LOCK(bufev);

if (bufev->be_ops != &bufferevent_ops_socket)

goto done;

if (event_priority_set(&bufev->ev_read, priority) == -1)

goto done;

if (event_priority_set(&bufev->ev_write, priority) == -1)

goto done;

r = 0;

done:

BEV_UNLOCK(bufev);

return r;

}

/* XXXX Should non-socket bufferevents support this? */

int

bufferevent_base_set(struct event_base *base, struct bufferevent *bufev)

{

int res = -1;

BEV_LOCK(bufev);

if (bufev->be_ops != &bufferevent_ops_socket)

goto done;

bufev->ev_base = base;

res = event_base_set(base, &bufev->ev_read);

if (res == -1)

goto done;

res = event_base_set(base, &bufev->ev_write);

done:

BEV_UNLOCK(bufev);

return res;

}

static int

be_socket_ctrl(struct bufferevent *bev, enum bufferevent_ctrl_op op,

union bufferevent_ctrl_data *data)

{

switch (op) {

case BEV_CTRL_SET_FD:

be_socket_setfd(bev, data->fd);

return 0;

case BEV_CTRL_GET_FD:

data->fd = event_get_fd(&bev->ev_read);

return 0;

case BEV_CTRL_GET_UNDERLYING:

case BEV_CTRL_CANCEL_ALL:

default:

return -1;

}

}