short bufferevent_get_enabled(struct bufferevent *bufev) { short r; BEV_LOCK(bufev); r = bufev->enabled; BEV_UNLOCK(bufev); return r; }
void bufferevent_incref(struct bufferevent *bufev) { struct bufferevent_private *bufev_private = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); BEV_LOCK(bufev); ++bufev_private->refcnt; BEV_UNLOCK(bufev); }
static void _bufferevent_cancel_all(struct bufferevent *bev) { union bufferevent_ctrl_data d; memset(&d, 0, sizeof(d)); BEV_LOCK(bev); if (bev->be_ops->ctrl) bev->be_ops->ctrl(bev, BEV_CTRL_CANCEL_ALL, &d); BEV_UNLOCK(bev); }
void bufferevent_suspend_read(struct bufferevent *bufev, short 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); bufev_private->read_suspended |= what; BEV_UNLOCK(bufev); }
void bufferevent_suspend_write(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->write_suspended) bufev->be_ops->disable(bufev, EV_WRITE); bufev_private->write_suspended |= what; BEV_UNLOCK(bufev); }
void bufferevent_unsuspend_write(struct bufferevent *bufev, short what) { struct bufferevent_private *bufev_private = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); BEV_LOCK(bufev); bufev_private->write_suspended &= ~what; if (!bufev_private->write_suspended) bufev->be_ops->enable(bufev, EV_WRITE); BEV_UNLOCK(bufev); }
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); BEV_UNLOCK(bufev); }
int bufferevent_decref_and_unlock_(struct bufferevent *bufev) { struct bufferevent_private *bufev_private = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); int n_cbs = 0; #define MAX_CBS 16 struct event_callback *cbs[MAX_CBS]; EVUTIL_ASSERT(bufev_private->refcnt > 0); if (--bufev_private->refcnt) { BEV_UNLOCK(bufev); return 0; } if (bufev->be_ops->unlink) bufev->be_ops->unlink(bufev); /* Okay, we're out of references. Let's finalize this once all the * callbacks are done running. */ cbs[0] = &bufev->ev_read.ev_evcallback; cbs[1] = &bufev->ev_write.ev_evcallback; cbs[2] = &bufev_private->deferred; n_cbs = 3; if (bufev_private->rate_limiting) { struct event *e = &bufev_private->rate_limiting->refill_bucket_event; if (event_initialized(e)) cbs[n_cbs++] = &e->ev_evcallback; } n_cbs += evbuffer_get_callbacks_(bufev->input, cbs+n_cbs, MAX_CBS-n_cbs); n_cbs += evbuffer_get_callbacks_(bufev->output, cbs+n_cbs, MAX_CBS-n_cbs); event_callback_finalize_many_(bufev->ev_base, n_cbs, cbs, bufferevent_finalize_cb_); #undef MAX_CBS BEV_UNLOCK(bufev); return 1; }
int bufferevent_flush(struct bufferevent *bufev, short iotype, enum bufferevent_flush_mode mode) { int r = -1; BEV_LOCK(bufev); if (bufev->be_ops->flush) r = bufev->be_ops->flush(bufev, iotype, mode); BEV_UNLOCK(bufev); return r; }
int bufferevent_setfd(struct bufferevent *bev, evutil_socket_t fd) { union bufferevent_ctrl_data d; int res = -1; d.fd = fd; BEV_LOCK(bev); if (bev->be_ops->ctrl) res = bev->be_ops->ctrl(bev, BEV_CTRL_SET_FD, &d); BEV_UNLOCK(bev); return res; }
evutil_socket_t bufferevent_getfd(struct bufferevent *bev) { union bufferevent_ctrl_data d; int res = -1; d.fd = -1; BEV_LOCK(bev); if (bev->be_ops->ctrl) res = bev->be_ops->ctrl(bev, BEV_CTRL_GET_FD, &d); BEV_UNLOCK(bev); return (res<0) ? -1 : d.fd; }
struct bufferevent * bufferevent_get_underlying(struct bufferevent *bev) { union bufferevent_ctrl_data d; int res = -1; d.ptr = NULL; BEV_LOCK(bev); if (bev->be_ops->ctrl) res = bev->be_ops->ctrl(bev, BEV_CTRL_GET_UNDERLYING, &d); BEV_UNLOCK(bev); return (res<0) ? NULL : d.ptr; }
enum bufferevent_options bufferevent_get_options_(struct bufferevent *bev) { struct bufferevent_private *bev_p = EVUTIL_UPCAST(bev, struct bufferevent_private, bev); enum bufferevent_options options; BEV_LOCK(bev); options = bev_p->options; BEV_UNLOCK(bev); return options; }
static void bufferevent_finalize_cb_(struct event_callback *evcb, void *arg_) { struct bufferevent *bufev = arg_; struct bufferevent *underlying; struct bufferevent_private *bufev_private = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); BEV_LOCK(bufev); underlying = bufferevent_get_underlying(bufev); /* Clean up the shared info */ if (bufev->be_ops->destruct) bufev->be_ops->destruct(bufev); /* XXX what happens if refcnt for these buffers is > 1? * The buffers can share a lock with this bufferevent object, * but the lock might be destroyed below. */ /* evbuffer will free the callbacks */ evbuffer_free(bufev->input); evbuffer_free(bufev->output); if (bufev_private->rate_limiting) { if (bufev_private->rate_limiting->group) bufferevent_remove_from_rate_limit_group_internal_(bufev,0); mm_free(bufev_private->rate_limiting); bufev_private->rate_limiting = NULL; } BEV_UNLOCK(bufev); if (bufev_private->own_lock) EVTHREAD_FREE_LOCK(bufev_private->lock, EVTHREAD_LOCKTYPE_RECURSIVE); /* Free the actual allocated memory. */ mm_free(((char*)bufev) - bufev->be_ops->mem_offset); /* Release the reference to underlying now that we no longer need the * reference to it. We wait this long mainly in case our lock is * shared with underlying. * * The 'destruct' function will also drop a reference to underlying * if BEV_OPT_CLOSE_ON_FREE is set. * * XXX Should we/can we just refcount evbuffer/bufferevent locks? * It would probably save us some headaches. */ if (underlying) bufferevent_decref_(underlying); }
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; }
void bufferevent_incref(struct bufferevent *bufev) { struct bufferevent_private *bufev_private = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); /* XXX: now that this function is public, we might want to * - return the count from this function * - create a new function to atomically grab the current refcount */ BEV_LOCK(bufev); ++bufev_private->refcnt; BEV_UNLOCK(bufev); }
void bufferevent_setcb(struct bufferevent *bufev, bufferevent_data_cb readcb, bufferevent_data_cb writecb, bufferevent_event_cb eventcb, void *cbarg) { BEV_LOCK(bufev); bufev->readcb = readcb; bufev->writecb = writecb; bufev->errorcb = eventcb; bufev->cbarg = cbarg; BEV_UNLOCK(bufev); }
int bufferevent_disable(struct bufferevent *bufev, short event) { int r = 0; BEV_LOCK(bufev); bufev->enabled &= ~event; if (bufev->be_ops->disable(bufev, event) < 0) r = -1; BEV_UNLOCK(bufev); return r; }
void bufferevent_wm_unsuspend_read(struct bufferevent *bufev) { struct bufferevent_private *bufev_private = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); BEV_LOCK(bufev); if (bufev_private->read_suspended) { bufev_private->read_suspended = 0; if (bufev->enabled & EV_READ) bufev->be_ops->enable(bufev, EV_READ); } BEV_UNLOCK(bufev); }
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_WRITE) { bufev->wm_write.low = lowmark; bufev->wm_write.high = highmark; } 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); 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 { /* 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); }
int bufferevent_disable_hard(struct bufferevent *bufev, short event) { int r = 0; struct bufferevent_private *bufev_private = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); BEV_LOCK(bufev); bufev->enabled &= ~event; bufev_private->connecting = 0; if (bufev->be_ops->disable(bufev, event) < 0) r = -1; BEV_UNLOCK(bufev); return r; }
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); }
void bufferevent_getcb(struct bufferevent *bufev, bufferevent_data_cb *readcb_ptr, bufferevent_data_cb *writecb_ptr, bufferevent_event_cb *eventcb_ptr, void **cbarg_ptr) { BEV_LOCK(bufev); if (readcb_ptr) *readcb_ptr = bufev->readcb; if (writecb_ptr) *writecb_ptr = bufev->writecb; if (eventcb_ptr) *eventcb_ptr = bufev->errorcb; if (cbarg_ptr) *cbarg_ptr = bufev->cbarg; 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; }
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); bufferevent_decref_(bev); return -1; } }
void bufferevent_getwatermark(struct bufferevent *bufev, short events, size_t *lowmark, size_t *highmark) { BEV_LOCK(bufev); if (events == EV_WRITE) { if (lowmark) *lowmark = bufev->wm_write.low; if (highmark) *highmark = bufev->wm_write.high; } if (events == EV_READ) { if (lowmark) *lowmark = bufev->wm_read.low; if (highmark) *highmark = bufev->wm_read.high; } BEV_UNLOCK(bufev); }
/* 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; }
void bufferevent_set_timeouts(struct bufferevent *bufev, const struct timeval *tv_read, const struct timeval *tv_write) { 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) bufev->be_ops->adj_timeouts(bufev); BEV_UNLOCK(bufev); }
/* XXXX Should non-socket bufferevents support this? */ int bufferevent_priority_set(struct bufferevent *bufev, int priority) { int r = -1; struct bufferevent_private *bufev_p = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); 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; event_deferred_cb_set_priority_(&bufev_p->deferred, priority); r = 0; done: BEV_UNLOCK(bufev); return r; }
int _bufferevent_decref_and_unlock(struct bufferevent *bufev) { struct bufferevent_private *bufev_private = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); struct bufferevent *underlying; EVUTIL_ASSERT(bufev_private->refcnt > 0); if (--bufev_private->refcnt) { BEV_UNLOCK(bufev); return 0; } underlying = bufferevent_get_underlying(bufev); /* Clean up the shared info */ if (bufev->be_ops->destruct) bufev->be_ops->destruct(bufev); /* XXX what happens if refcnt for these buffers is > 1? * The buffers can share a lock with this bufferevent object, * but the lock might be destroyed below. */ /* evbuffer will free the callbacks */ evbuffer_free(bufev->input); evbuffer_free(bufev->output); if (bufev_private->rate_limiting) { if (bufev_private->rate_limiting->group) bufferevent_remove_from_rate_limit_group(bufev); if (event_initialized(&bufev_private->rate_limiting->refill_bucket_event)) event_del(&bufev_private->rate_limiting->refill_bucket_event); event_debug_unassign(&bufev_private->rate_limiting->refill_bucket_event); mm_free(bufev_private->rate_limiting); bufev_private->rate_limiting = NULL; } event_debug_unassign(&bufev->ev_read); event_debug_unassign(&bufev->ev_write); BEV_UNLOCK(bufev); if (bufev_private->own_lock) EVTHREAD_FREE_LOCK(bufev_private->lock, EVTHREAD_LOCKTYPE_RECURSIVE); /* Free the actual allocated memory. */ mm_free(((char*)bufev) - bufev->be_ops->mem_offset); /* Release the reference to underlying now that we no longer need the * reference to it. We wait this long mainly in case our lock is * shared with underlying. * * The 'destruct' function will also drop a reference to underlying * if BEV_OPT_CLOSE_ON_FREE is set. * * XXX Should we/can we just refcount evbuffer/bufferevent locks? * It would probably save us some headaches. */ if (underlying) bufferevent_decref(underlying); return 1; }