自学教程：C++ BEV_UNLOCK函数代码示例

shortbufferevent_get_enabled(struct bufferevent *bufev){	short r;	BEV_LOCK(bufev);	r = bufev->enabled;	BEV_UNLOCK(bufev);	return r;}

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

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

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

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

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

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

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

intbufferevent_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_tbufferevent_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_optionsbufferevent_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 voidbufferevent_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);}

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

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

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

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

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

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

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

voidbufferevent_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? */intbufferevent_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;}

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

voidbufferevent_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? */intbufferevent_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;}

voidbufferevent_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? */intbufferevent_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;}