2 * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
3 * Copyright (c) 2002-2006 Niels Provos <provos@citi.umich.edu>
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 #include <sys/types.h>
31 #include "event2/event-config.h"
33 #ifdef _EVENT_HAVE_SYS_TIME_H
41 #ifdef _EVENT_HAVE_STDARG_H
44 #ifdef _EVENT_HAVE_UNISTD_H
53 #ifdef _EVENT_HAVE_SYS_SOCKET_H
54 #include <sys/socket.h>
56 #ifdef _EVENT_HAVE_NETINET_IN_H
57 #include <netinet/in.h>
59 #ifdef _EVENT_HAVE_NETINET_IN6_H
60 #include <netinet/in6.h>
63 #include "event2/util.h"
64 #include "event2/bufferevent.h"
65 #include "event2/buffer.h"
66 #include "event2/bufferevent_struct.h"
67 #include "event2/bufferevent_compat.h"
68 #include "event2/event.h"
69 #include "log-internal.h"
70 #include "mm-internal.h"
71 #include "bufferevent-internal.h"
72 #include "util-internal.h"
74 #include "iocp-internal.h"
78 static int be_socket_enable(struct bufferevent *, short);
79 static int be_socket_disable(struct bufferevent *, short);
80 static void be_socket_destruct(struct bufferevent *);
81 static int be_socket_adj_timeouts(struct bufferevent *);
82 static int be_socket_flush(struct bufferevent *, short, enum bufferevent_flush_mode);
83 static int be_socket_ctrl(struct bufferevent *, enum bufferevent_ctrl_op, union bufferevent_ctrl_data *);
85 static void be_socket_setfd(struct bufferevent *, evutil_socket_t);
87 const struct bufferevent_ops bufferevent_ops_socket = {
89 evutil_offsetof(struct bufferevent_private, bev),
93 be_socket_adj_timeouts,
98 #define be_socket_add(ev, t) \
99 _bufferevent_add_event((ev), (t))
102 bufferevent_socket_outbuf_cb(struct evbuffer *buf,
103 const struct evbuffer_cb_info *cbinfo,
106 struct bufferevent *bufev = arg;
107 struct bufferevent_private *bufev_p =
108 EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
110 if (cbinfo->n_added &&
111 (bufev->enabled & EV_WRITE) &&
112 !event_pending(&bufev->ev_write, EV_WRITE, NULL) &&
113 !bufev_p->write_suspended) {
114 /* Somebody added data to the buffer, and we would like to
115 * write, and we were not writing. So, start writing. */
116 if (be_socket_add(&bufev->ev_write, &bufev->timeout_write) == -1) {
117 /* Should we log this? */
123 bufferevent_readcb(evutil_socket_t fd, short event, void *arg)
125 struct bufferevent *bufev = arg;
126 struct bufferevent_private *bufev_p =
127 EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
128 struct evbuffer *input;
130 short what = BEV_EVENT_READING;
131 ev_ssize_t howmuch = -1, readmax=-1;
133 _bufferevent_incref_and_lock(bufev);
135 if (event == EV_TIMEOUT) {
136 what |= BEV_EVENT_TIMEOUT;
140 input = bufev->input;
143 * If we have a high watermark configured then we don't want to
144 * read more data than would make us reach the watermark.
146 if (bufev->wm_read.high != 0) {
147 howmuch = bufev->wm_read.high - evbuffer_get_length(input);
148 /* we somehow lowered the watermark, stop reading */
150 bufferevent_wm_suspend_read(bufev);
154 readmax = _bufferevent_get_read_max(bufev_p);
155 if (howmuch < 0 || howmuch > readmax) /* The use of -1 for "unlimited"
156 * uglifies this code. XXXX */
158 if (bufev_p->read_suspended)
161 evbuffer_unfreeze(input, 0);
162 res = evbuffer_read(input, fd, (int)howmuch); /* XXXX evbuffer_read would do better to take and return ev_ssize_t */
163 evbuffer_freeze(input, 0);
166 int err = evutil_socket_geterror(fd);
167 if (EVUTIL_ERR_RW_RETRIABLE(err))
170 what |= BEV_EVENT_ERROR;
171 } else if (res == 0) {
173 what |= BEV_EVENT_EOF;
179 _bufferevent_decrement_read_buckets(bufev_p, res);
181 /* Invoke the user callback - must always be called last */
182 if (evbuffer_get_length(input) >= bufev->wm_read.low)
183 _bufferevent_run_readcb(bufev);
191 bufferevent_disable(bufev, EV_READ);
192 _bufferevent_run_eventcb(bufev, what);
195 _bufferevent_decref_and_unlock(bufev);
199 bufferevent_writecb(evutil_socket_t fd, short event, void *arg)
201 struct bufferevent *bufev = arg;
202 struct bufferevent_private *bufev_p =
203 EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
205 short what = BEV_EVENT_WRITING;
207 ev_ssize_t atmost = -1;
209 _bufferevent_incref_and_lock(bufev);
211 if (event == EV_TIMEOUT) {
212 what |= BEV_EVENT_TIMEOUT;
215 if (bufev_p->connecting) {
216 int c = evutil_socket_finished_connecting(fd);
217 /* we need to fake the error if the connection was refused
218 * immediately - usually connection to localhost on BSD */
219 if (bufev_p->connection_refused) {
220 bufev_p->connection_refused = 0;
227 bufev_p->connecting = 0;
229 event_del(&bufev->ev_write);
230 event_del(&bufev->ev_read);
231 _bufferevent_run_eventcb(bufev, BEV_EVENT_ERROR);
236 if (BEV_IS_ASYNC(bufev)) {
237 event_del(&bufev->ev_write);
238 bufferevent_async_set_connected(bufev);
239 _bufferevent_run_eventcb(bufev,
240 BEV_EVENT_CONNECTED);
244 _bufferevent_run_eventcb(bufev,
245 BEV_EVENT_CONNECTED);
246 if (!(bufev->enabled & EV_WRITE) ||
247 bufev_p->write_suspended) {
248 event_del(&bufev->ev_write);
254 atmost = _bufferevent_get_write_max(bufev_p);
256 if (bufev_p->write_suspended)
259 if (evbuffer_get_length(bufev->output)) {
260 evbuffer_unfreeze(bufev->output, 1);
261 res = evbuffer_write_atmost(bufev->output, fd, atmost);
262 evbuffer_freeze(bufev->output, 1);
264 int err = evutil_socket_geterror(fd);
265 if (EVUTIL_ERR_RW_RETRIABLE(err))
267 what |= BEV_EVENT_ERROR;
268 } else if (res == 0) {
270 XXXX Actually, a 0 on write doesn't indicate
271 an EOF. An ECONNRESET might be more typical.
273 what |= BEV_EVENT_EOF;
278 _bufferevent_decrement_write_buckets(bufev_p, res);
281 if (evbuffer_get_length(bufev->output) == 0) {
282 event_del(&bufev->ev_write);
286 * Invoke the user callback if our buffer is drained or below the
289 if ((res || !connected) &&
290 evbuffer_get_length(bufev->output) <= bufev->wm_write.low) {
291 _bufferevent_run_writecb(bufev);
297 if (evbuffer_get_length(bufev->output) == 0) {
298 event_del(&bufev->ev_write);
303 bufferevent_disable(bufev, EV_WRITE);
304 _bufferevent_run_eventcb(bufev, what);
307 _bufferevent_decref_and_unlock(bufev);
311 bufferevent_socket_new(struct event_base *base, evutil_socket_t fd,
314 struct bufferevent_private *bufev_p;
315 struct bufferevent *bufev;
318 if (base && event_base_get_iocp(base))
319 return bufferevent_async_new(base, fd, options);
322 if ((bufev_p = mm_calloc(1, sizeof(struct bufferevent_private)))== NULL)
325 if (bufferevent_init_common(bufev_p, base, &bufferevent_ops_socket,
330 bufev = &bufev_p->bev;
331 evbuffer_set_flags(bufev->output, EVBUFFER_FLAG_DRAINS_TO_FD);
333 event_assign(&bufev->ev_read, bufev->ev_base, fd,
334 EV_READ|EV_PERSIST, bufferevent_readcb, bufev);
335 event_assign(&bufev->ev_write, bufev->ev_base, fd,
336 EV_WRITE|EV_PERSIST, bufferevent_writecb, bufev);
338 evbuffer_add_cb(bufev->output, bufferevent_socket_outbuf_cb, bufev);
340 evbuffer_freeze(bufev->input, 0);
341 evbuffer_freeze(bufev->output, 1);
347 bufferevent_socket_connect(struct bufferevent *bev,
348 struct sockaddr *sa, int socklen)
350 struct bufferevent_private *bufev_p =
351 EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
358 _bufferevent_incref_and_lock(bev);
363 fd = bufferevent_getfd(bev);
367 fd = socket(sa->sa_family, SOCK_STREAM, 0);
370 if (evutil_make_socket_nonblocking(fd)<0)
376 if (bufferevent_async_can_connect(bev)) {
377 bufferevent_setfd(bev, fd);
378 r = bufferevent_async_connect(bev, fd, sa, socklen);
381 bufev_p->connecting = 1;
386 r = evutil_socket_connect(&fd, sa, socklen);
391 /* ConnectEx() isn't always around, even when IOCP is enabled.
392 * Here, we borrow the socket object's write handler to fall back
393 * on a non-blocking connect() when ConnectEx() is unavailable. */
394 if (BEV_IS_ASYNC(bev)) {
395 event_assign(&bev->ev_write, bev->ev_base, fd,
396 EV_WRITE|EV_PERSIST, bufferevent_writecb, bev);
399 bufferevent_setfd(bev, fd);
401 if (! be_socket_enable(bev, EV_WRITE)) {
402 bufev_p->connecting = 1;
407 /* The connect succeeded already. How very BSD of it. */
409 bufev_p->connecting = 1;
410 event_active(&bev->ev_write, EV_WRITE, 1);
412 /* The connect failed already. How very BSD of it. */
413 bufev_p->connection_refused = 1;
414 bufev_p->connecting = 1;
416 event_active(&bev->ev_write, EV_WRITE, 1);
422 _bufferevent_run_eventcb(bev, BEV_EVENT_ERROR);
424 evutil_closesocket(fd);
425 /* do something about the error? */
427 _bufferevent_decref_and_unlock(bev);
432 bufferevent_connect_getaddrinfo_cb(int result, struct evutil_addrinfo *ai,
435 struct bufferevent *bev = arg;
436 struct bufferevent_private *bev_p =
437 EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
441 bufferevent_unsuspend_write(bev, BEV_SUSPEND_LOOKUP);
442 bufferevent_unsuspend_read(bev, BEV_SUSPEND_LOOKUP);
445 bev_p->dns_error = result;
446 _bufferevent_run_eventcb(bev, BEV_EVENT_ERROR);
447 _bufferevent_decref_and_unlock(bev);
449 evutil_freeaddrinfo(ai);
453 /* XXX use the other addrinfos? */
454 /* XXX use this return value */
455 r = bufferevent_socket_connect(bev, ai->ai_addr, (int)ai->ai_addrlen);
457 _bufferevent_decref_and_unlock(bev);
458 evutil_freeaddrinfo(ai);
462 bufferevent_socket_connect_hostname(struct bufferevent *bev,
463 struct evdns_base *evdns_base, int family, const char *hostname, int port)
466 struct evutil_addrinfo hint;
468 struct bufferevent_private *bev_p =
469 EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
471 if (family != AF_INET && family != AF_INET6 && family != AF_UNSPEC)
473 if (port < 1 || port > 65535)
477 bev_p->dns_error = 0;
480 evutil_snprintf(portbuf, sizeof(portbuf), "%d", port);
482 memset(&hint, 0, sizeof(hint));
483 hint.ai_family = family;
484 hint.ai_protocol = IPPROTO_TCP;
485 hint.ai_socktype = SOCK_STREAM;
487 bufferevent_suspend_write(bev, BEV_SUSPEND_LOOKUP);
488 bufferevent_suspend_read(bev, BEV_SUSPEND_LOOKUP);
490 bufferevent_incref(bev);
491 err = evutil_getaddrinfo_async(evdns_base, hostname, portbuf,
492 &hint, bufferevent_connect_getaddrinfo_cb, bev);
497 bufferevent_unsuspend_write(bev, BEV_SUSPEND_LOOKUP);
498 bufferevent_unsuspend_read(bev, BEV_SUSPEND_LOOKUP);
504 bufferevent_socket_get_dns_error(struct bufferevent *bev)
507 struct bufferevent_private *bev_p =
508 EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
511 rv = bev_p->dns_error;
518 * Create a new buffered event object.
520 * The read callback is invoked whenever we read new data.
521 * The write callback is invoked whenever the output buffer is drained.
522 * The error callback is invoked on a write/read error or on EOF.
524 * Both read and write callbacks maybe NULL. The error callback is not
525 * allowed to be NULL and have to be provided always.
529 bufferevent_new(evutil_socket_t fd,
530 bufferevent_data_cb readcb, bufferevent_data_cb writecb,
531 bufferevent_event_cb eventcb, void *cbarg)
533 struct bufferevent *bufev;
535 if (!(bufev = bufferevent_socket_new(NULL, fd, 0)))
538 bufferevent_setcb(bufev, readcb, writecb, eventcb, cbarg);
545 be_socket_enable(struct bufferevent *bufev, short event)
547 if (event & EV_READ) {
548 if (be_socket_add(&bufev->ev_read,&bufev->timeout_read) == -1)
551 if (event & EV_WRITE) {
552 if (be_socket_add(&bufev->ev_write,&bufev->timeout_write) == -1)
559 be_socket_disable(struct bufferevent *bufev, short event)
561 struct bufferevent_private *bufev_p =
562 EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
563 if (event & EV_READ) {
564 if (event_del(&bufev->ev_read) == -1)
567 /* Don't actually disable the write if we are trying to connect. */
568 if ((event & EV_WRITE) && ! bufev_p->connecting) {
569 if (event_del(&bufev->ev_write) == -1)
576 be_socket_destruct(struct bufferevent *bufev)
578 struct bufferevent_private *bufev_p =
579 EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
581 EVUTIL_ASSERT(bufev->be_ops == &bufferevent_ops_socket);
583 fd = event_get_fd(&bufev->ev_read);
585 event_del(&bufev->ev_read);
586 event_del(&bufev->ev_write);
588 if ((bufev_p->options & BEV_OPT_CLOSE_ON_FREE) && fd >= 0)
589 EVUTIL_CLOSESOCKET(fd);
593 be_socket_adj_timeouts(struct bufferevent *bufev)
596 if (event_pending(&bufev->ev_read, EV_READ, NULL))
597 if (be_socket_add(&bufev->ev_read, &bufev->timeout_read) < 0)
599 if (event_pending(&bufev->ev_write, EV_WRITE, NULL)) {
600 if (be_socket_add(&bufev->ev_write, &bufev->timeout_write) < 0)
607 be_socket_flush(struct bufferevent *bev, short iotype,
608 enum bufferevent_flush_mode mode)
615 be_socket_setfd(struct bufferevent *bufev, evutil_socket_t fd)
618 EVUTIL_ASSERT(bufev->be_ops == &bufferevent_ops_socket);
620 event_del(&bufev->ev_read);
621 event_del(&bufev->ev_write);
623 event_assign(&bufev->ev_read, bufev->ev_base, fd,
624 EV_READ|EV_PERSIST, bufferevent_readcb, bufev);
625 event_assign(&bufev->ev_write, bufev->ev_base, fd,
626 EV_WRITE|EV_PERSIST, bufferevent_writecb, bufev);
629 bufferevent_enable(bufev, bufev->enabled);
634 /* XXXX Should non-socket bufferevents support this? */
636 bufferevent_priority_set(struct bufferevent *bufev, int priority)
641 if (bufev->be_ops != &bufferevent_ops_socket)
644 if (event_priority_set(&bufev->ev_read, priority) == -1)
646 if (event_priority_set(&bufev->ev_write, priority) == -1)
655 /* XXXX Should non-socket bufferevents support this? */
657 bufferevent_base_set(struct event_base *base, struct bufferevent *bufev)
662 if (bufev->be_ops != &bufferevent_ops_socket)
665 bufev->ev_base = base;
667 res = event_base_set(base, &bufev->ev_read);
671 res = event_base_set(base, &bufev->ev_write);
678 be_socket_ctrl(struct bufferevent *bev, enum bufferevent_ctrl_op op,
679 union bufferevent_ctrl_data *data)
682 case BEV_CTRL_SET_FD:
683 be_socket_setfd(bev, data->fd);
685 case BEV_CTRL_GET_FD:
686 data->fd = event_get_fd(&bev->ev_read);
688 case BEV_CTRL_GET_UNDERLYING:
689 case BEV_CTRL_CANCEL_ALL: