1 files changed, 203 insertions, 154 deletions

diff --git a/event.c b/event.c
index 503003e2..3816650e 100644
--- a/event.c
+++ b/event.c
@@ -52,6 +52,9 @@
 #include <string.h>
 #include <time.h>
 #include <limits.h>
+#ifdef EVENT__HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
 
 #include "event2/event.h"
 #include "event2/event_struct.h"
@@ -123,6 +126,7 @@ static const struct eventop *eventops[] = {
 };
 
 /* Global state; deprecated */
+EVENT2_EXPORT_SYMBOL
 struct event_base *event_global_current_base_ = NULL;
 #define current_base event_global_current_base_
 
@@ -228,133 +232,169 @@ HT_PROTOTYPE(event_debug_map, event_debug_entry, node, hash_debug_entry,
 HT_GENERATE(event_debug_map, event_debug_entry, node, hash_debug_entry,
     eq_debug_entry, 0.5, mm_malloc, mm_realloc, mm_free)
 
-/* Macro: record that ev is now setup (that is, ready for an add) */
-#define event_debug_note_setup_(ev) do {				\
-	if (event_debug_mode_on_) {					\
-		struct event_debug_entry *dent,find;			\
-		find.ptr = (ev);					\
-		EVLOCK_LOCK(event_debug_map_lock_, 0);			\
-		dent = HT_FIND(event_debug_map, &global_debug_map, &find); \
-		if (dent) {						\
-			dent->added = 0;				\
-		} else {						\
-			dent = mm_malloc(sizeof(*dent));		\
-			if (!dent)					\
-				event_err(1,				\
-				    "Out of memory in debugging code");	\
-			dent->ptr = (ev);				\
-			dent->added = 0;				\
-			HT_INSERT(event_debug_map, &global_debug_map, dent); \
-		}							\
-		EVLOCK_UNLOCK(event_debug_map_lock_, 0);		\
-	}								\
-	event_debug_mode_too_late = 1;					\
-	} while (0)
-/* Macro: record that ev is no longer setup */
-#define event_debug_note_teardown_(ev) do {				\
-	if (event_debug_mode_on_) {					\
-		struct event_debug_entry *dent,find;			\
-		find.ptr = (ev);					\
-		EVLOCK_LOCK(event_debug_map_lock_, 0);			\
-		dent = HT_REMOVE(event_debug_map, &global_debug_map, &find); \
-		if (dent)						\
-			mm_free(dent);					\
-		EVLOCK_UNLOCK(event_debug_map_lock_, 0);		\
-	}								\
-	event_debug_mode_too_late = 1;					\
-	} while (0)
+/* record that ev is now setup (that is, ready for an add) */
+static void event_debug_note_setup_(const struct event *ev)
+{
+	struct event_debug_entry *dent, find;
+
+	if (!event_debug_mode_on_)
+		goto out;
+
+	find.ptr = ev;
+	EVLOCK_LOCK(event_debug_map_lock_, 0);
+	dent = HT_FIND(event_debug_map, &global_debug_map, &find);
+	if (dent) {
+		dent->added = 0;
+	} else {
+		dent = mm_malloc(sizeof(*dent));
+		if (!dent)
+			event_err(1,
+			    "Out of memory in debugging code");
+		dent->ptr = ev;
+		dent->added = 0;
+		HT_INSERT(event_debug_map, &global_debug_map, dent);
+	}
+	EVLOCK_UNLOCK(event_debug_map_lock_, 0);
+
+out:
+	event_debug_mode_too_late = 1;
+}
+/* record that ev is no longer setup */
+static void event_debug_note_teardown_(const struct event *ev)
+{
+	struct event_debug_entry *dent, find;
+
+	if (!event_debug_mode_on_)
+		goto out;
+
+	find.ptr = ev;
+	EVLOCK_LOCK(event_debug_map_lock_, 0);
+	dent = HT_REMOVE(event_debug_map, &global_debug_map, &find);
+	if (dent)
+		mm_free(dent);
+	EVLOCK_UNLOCK(event_debug_map_lock_, 0);
+
+out:
+	event_debug_mode_too_late = 1;
+}
 /* Macro: record that ev is now added */
-#define event_debug_note_add_(ev)	do {				\
-	if (event_debug_mode_on_) {					\
-		struct event_debug_entry *dent,find;			\
-		find.ptr = (ev);					\
-		EVLOCK_LOCK(event_debug_map_lock_, 0);			\
-		dent = HT_FIND(event_debug_map, &global_debug_map, &find); \
-		if (dent) {						\
-			dent->added = 1;				\
-		} else {						\
-			event_errx(EVENT_ERR_ABORT_,			\
-			    "%s: noting an add on a non-setup event %p" \
-			    " (events: 0x%x, fd: "EV_SOCK_FMT		\
-			    ", flags: 0x%x)",				\
-			    __func__, (ev), (ev)->ev_events,		\
-			    EV_SOCK_ARG((ev)->ev_fd), (ev)->ev_flags);	\
-		}							\
-		EVLOCK_UNLOCK(event_debug_map_lock_, 0);		\
-	}								\
-	event_debug_mode_too_late = 1;					\
-	} while (0)
-/* Macro: record that ev is no longer added */
-#define event_debug_note_del_(ev) do {					\
-	if (event_debug_mode_on_) {					\
-		struct event_debug_entry *dent,find;			\
-		find.ptr = (ev);					\
-		EVLOCK_LOCK(event_debug_map_lock_, 0);			\
-		dent = HT_FIND(event_debug_map, &global_debug_map, &find); \
-		if (dent) {						\
-			dent->added = 0;				\
-		} else {						\
-			event_errx(EVENT_ERR_ABORT_,			\
-			    "%s: noting a del on a non-setup event %p"	\
-			    " (events: 0x%x, fd: "EV_SOCK_FMT		\
-			    ", flags: 0x%x)",				\
-			    __func__, (ev), (ev)->ev_events,		\
-			    EV_SOCK_ARG((ev)->ev_fd), (ev)->ev_flags);	\
-		}							\
-		EVLOCK_UNLOCK(event_debug_map_lock_, 0);		\
-	}								\
-	event_debug_mode_too_late = 1;					\
-	} while (0)
-/* Macro: assert that ev is setup (i.e., okay to add or inspect) */
-#define event_debug_assert_is_setup_(ev) do {				\
-	if (event_debug_mode_on_) {					\
-		struct event_debug_entry *dent,find;			\
-		find.ptr = (ev);					\
-		EVLOCK_LOCK(event_debug_map_lock_, 0);			\
-		dent = HT_FIND(event_debug_map, &global_debug_map, &find); \
-		if (!dent) {						\
-			event_errx(EVENT_ERR_ABORT_,			\
-			    "%s called on a non-initialized event %p"	\
-			    " (events: 0x%x, fd: "EV_SOCK_FMT\
-			    ", flags: 0x%x)",				\
-			    __func__, (ev), (ev)->ev_events,		\
-			    EV_SOCK_ARG((ev)->ev_fd), (ev)->ev_flags);	\
-		}							\
-		EVLOCK_UNLOCK(event_debug_map_lock_, 0);		\
-	}								\
-	} while (0)
-/* Macro: assert that ev is not added (i.e., okay to tear down or set
- * up again) */
-#define event_debug_assert_not_added_(ev) do {				\
-	if (event_debug_mode_on_) {					\
-		struct event_debug_entry *dent,find;			\
-		find.ptr = (ev);					\
-		EVLOCK_LOCK(event_debug_map_lock_, 0);			\
-		dent = HT_FIND(event_debug_map, &global_debug_map, &find); \
-		if (dent && dent->added) {				\
-			event_errx(EVENT_ERR_ABORT_,			\
-			    "%s called on an already added event %p"	\
-			    " (events: 0x%x, fd: "EV_SOCK_FMT", "	\
-			    "flags: 0x%x)",				\
-			    __func__, (ev), (ev)->ev_events,		\
-			    EV_SOCK_ARG((ev)->ev_fd), (ev)->ev_flags);	\
-		}							\
-		EVLOCK_UNLOCK(event_debug_map_lock_, 0);		\
-	}								\
-	} while (0)
+static void event_debug_note_add_(const struct event *ev)
+{
+	struct event_debug_entry *dent,find;
+
+	if (!event_debug_mode_on_)
+		goto out;
+
+	find.ptr = ev;
+	EVLOCK_LOCK(event_debug_map_lock_, 0);
+	dent = HT_FIND(event_debug_map, &global_debug_map, &find);
+	if (dent) {
+		dent->added = 1;
+	} else {
+		event_errx(EVENT_ERR_ABORT_,
+		    "%s: noting an add on a non-setup event %p"
+		    " (events: 0x%x, fd: "EV_SOCK_FMT
+		    ", flags: 0x%x)",
+		    __func__, ev, ev->ev_events,
+		    EV_SOCK_ARG(ev->ev_fd), ev->ev_flags);
+	}
+	EVLOCK_UNLOCK(event_debug_map_lock_, 0);
+
+out:
+	event_debug_mode_too_late = 1;
+}
+/* record that ev is no longer added */
+static void event_debug_note_del_(const struct event *ev)
+{
+	struct event_debug_entry *dent, find;
+
+	if (!event_debug_mode_on_)
+		goto out;
+
+	find.ptr = ev;
+	EVLOCK_LOCK(event_debug_map_lock_, 0);
+	dent = HT_FIND(event_debug_map, &global_debug_map, &find);
+	if (dent) {
+		dent->added = 0;
+	} else {
+		event_errx(EVENT_ERR_ABORT_,
+		    "%s: noting a del on a non-setup event %p"
+		    " (events: 0x%x, fd: "EV_SOCK_FMT
+		    ", flags: 0x%x)",
+		    __func__, ev, ev->ev_events,
+		    EV_SOCK_ARG(ev->ev_fd), ev->ev_flags);
+	}
+	EVLOCK_UNLOCK(event_debug_map_lock_, 0);
+
+out:
+	event_debug_mode_too_late = 1;
+}
+/* assert that ev is setup (i.e., okay to add or inspect) */
+static void event_debug_assert_is_setup_(const struct event *ev)
+{
+	struct event_debug_entry *dent, find;
+
+	if (!event_debug_mode_on_)
+		return;
+
+	find.ptr = ev;
+	EVLOCK_LOCK(event_debug_map_lock_, 0);
+	dent = HT_FIND(event_debug_map, &global_debug_map, &find);
+	if (!dent) {
+		event_errx(EVENT_ERR_ABORT_,
+		    "%s called on a non-initialized event %p"
+		    " (events: 0x%x, fd: "EV_SOCK_FMT
+		    ", flags: 0x%x)",
+		    __func__, ev, ev->ev_events,
+		    EV_SOCK_ARG(ev->ev_fd), ev->ev_flags);
+	}
+	EVLOCK_UNLOCK(event_debug_map_lock_, 0);
+}
+/* assert that ev is not added (i.e., okay to tear down or set up again) */
+static void event_debug_assert_not_added_(const struct event *ev)
+{
+	struct event_debug_entry *dent, find;
+
+	if (!event_debug_mode_on_)
+		return;
+
+	find.ptr = ev;
+	EVLOCK_LOCK(event_debug_map_lock_, 0);
+	dent = HT_FIND(event_debug_map, &global_debug_map, &find);
+	if (dent && dent->added) {
+		event_errx(EVENT_ERR_ABORT_,
+		    "%s called on an already added event %p"
+		    " (events: 0x%x, fd: "EV_SOCK_FMT", "
+		    "flags: 0x%x)",
+		    __func__, ev, ev->ev_events,
+		    EV_SOCK_ARG(ev->ev_fd), ev->ev_flags);
+	}
+	EVLOCK_UNLOCK(event_debug_map_lock_, 0);
+}
+static void event_debug_assert_socket_nonblocking_(evutil_socket_t fd)
+{
+	if (!event_debug_mode_on_)
+		return;
+	if (fd < 0)
+		return;
+
+#ifndef _WIN32
+	{
+		int flags;
+		if ((flags = fcntl(fd, F_GETFL, NULL)) >= 0) {
+			EVUTIL_ASSERT(flags & O_NONBLOCK);
+		}
+	}
+#endif
+}
 #else
-#define event_debug_note_setup_(ev) \
-	((void)0)
-#define event_debug_note_teardown_(ev) \
-	((void)0)
-#define event_debug_note_add_(ev) \
-	((void)0)
-#define event_debug_note_del_(ev) \
-	((void)0)
-#define event_debug_assert_is_setup_(ev) \
-	((void)0)
-#define event_debug_assert_not_added_(ev) \
-	((void)0)
+static void event_debug_note_setup_(const struct event *ev) { (void)ev; }
+static void event_debug_note_teardown_(const struct event *ev) { (void)ev; }
+static void event_debug_note_add_(const struct event *ev) { (void)ev; }
+static void event_debug_note_del_(const struct event *ev) { (void)ev; }
+static void event_debug_assert_is_setup_(const struct event *ev) { (void)ev; }
+static void event_debug_assert_not_added_(const struct event *ev) { (void)ev; }
+static void event_debug_assert_socket_nonblocking_(evutil_socket_t fd) { (void)fd; }
 #endif
 
 #define EVENT_BASE_ASSERT_LOCKED(base)		\
@@ -590,7 +630,9 @@ event_base_new_with_config(const struct event_config *cfg)
 		int flags;
 		if (should_check_environment && !precise_time) {
 			precise_time = evutil_getenv_("EVENT_PRECISE_TIMER") != NULL;
-			base->flags |= EVENT_BASE_FLAG_PRECISE_TIMER;
+			if (precise_time) {
+				base->flags |= EVENT_BASE_FLAG_PRECISE_TIMER;
+			}
 		}
 		flags = precise_time ? EV_MONOT_PRECISE : 0;
 		evutil_configure_monotonic_time_(&base->monotonic_timer, flags);
@@ -862,6 +904,7 @@ event_base_free_(struct event_base *base, int run_finalizers)
 		 * A simple case is bufferevent with underlying (i.e. filters).
 		 */
 		int i = event_base_free_queues_(base, run_finalizers);
+		event_debug(("%s: %d events freed", __func__, i));
 		if (!i) {
 			break;
 		}
@@ -1640,10 +1683,12 @@ event_process_active_single_queue(struct event_base *base,
 			break;
 		case EV_CLOSURE_EVENT: {
 			void (*evcb_callback)(evutil_socket_t, short, void *);
+			short res;
 			EVUTIL_ASSERT(ev != NULL);
 			evcb_callback = *ev->ev_callback;
+			res = ev->ev_res;
 			EVBASE_RELEASE_LOCK(base, th_base_lock);
-			evcb_callback(ev->ev_fd, ev->ev_res, ev->ev_arg);
+			evcb_callback(ev->ev_fd, res, ev->ev_arg);
 		}
 		break;
 		case EV_CLOSURE_CB_SELF: {
@@ -2069,6 +2114,8 @@ event_assign(struct event *ev, struct event_base *base, evutil_socket_t fd, shor
 	if (arg == &event_self_cbarg_ptr_)
 		arg = ev;
 
+	if (!(events & EV_SIGNAL))
+		event_debug_assert_socket_nonblocking_(fd);
 	event_debug_assert_not_added_(ev);
 
 	ev->ev_base = base;
@@ -2719,17 +2766,16 @@ static int
 event_del_(struct event *ev, int blocking)
 {
 	int res;
+	struct event_base *base = ev->ev_base;
 
-	if (EVUTIL_FAILURE_CHECK(!ev->ev_base)) {
+	if (EVUTIL_FAILURE_CHECK(!base)) {
 		event_warnx("%s: event has no event_base set.", __func__);
 		return -1;
 	}
 
-	EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
-
+	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
 	res = event_del_nolock_(ev, blocking);
-
-	EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
+	EVBASE_RELEASE_LOCK(base, th_base_lock);
 
 	return (res);
 }
@@ -2779,21 +2825,7 @@ event_del_nolock_(struct event *ev, int blocking)
 		}
 	}
 
-	/* If the main thread is currently executing this event's callback,
-	 * and we are not the main thread, then we want to wait until the
-	 * callback is done before we start removing the event.  That way,
-	 * when this function returns, it will be safe to free the
-	 * user-supplied argument. */
 	base = ev->ev_base;
-#ifndef EVENT__DISABLE_THREAD_SUPPORT
-	if (blocking != EVENT_DEL_NOBLOCK &&
-	    base->current_event == event_to_event_callback(ev) &&
-	    !EVBASE_IN_THREAD(base) &&
-	    (blocking == EVENT_DEL_BLOCK || !(ev->ev_events & EV_FINALIZE))) {
-		++base->current_event_waiters;
-		EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);
-	}
-#endif
 
 	EVUTIL_ASSERT(!(ev->ev_flags & ~EVLIST_ALL));
 
@@ -2832,6 +2864,10 @@ event_del_nolock_(struct event *ev, int blocking)
 			notify = 1;
 			res = 0;
 		}
+		/* If we do not have events, let's notify event base so it can
+		 * exit without waiting */
+		if (!event_haveevents(base) && !N_ACTIVE_CALLBACKS(base))
+			notify = 1;
 	}
 
 	/* if we are not in the right thread, we need to wake up the loop */
@@ -2840,6 +2876,21 @@ event_del_nolock_(struct event *ev, int blocking)
 
 	event_debug_note_del_(ev);
 
+	/* If the main thread is currently executing this event's callback,
+	 * and we are not the main thread, then we want to wait until the
+	 * callback is done before returning. That way, when this function
+	 * returns, it will be safe to free the user-supplied argument.
+	 */
+#ifndef EVENT__DISABLE_THREAD_SUPPORT
+	if (blocking != EVENT_DEL_NOBLOCK &&
+	    base->current_event == event_to_event_callback(ev) &&
+	    !EVBASE_IN_THREAD(base) &&
+	    (blocking == EVENT_DEL_BLOCK || !(ev->ev_events & EV_FINALIZE))) {
+		++base->current_event_waiters;
+		EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);
+	}
+#endif
+
 	return (res);
 }
 
@@ -2960,6 +3011,7 @@ event_callback_activate_nolock_(struct event_base *base,
 	switch (evcb->evcb_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER)) {
 	default:
 		EVUTIL_ASSERT(0);
+		EVUTIL_FALLTHROUGH;
 	case EVLIST_ACTIVE_LATER:
 		event_queue_remove_active_later(base, evcb);
 		r = 0;
@@ -3148,10 +3200,6 @@ timeout_process(struct event_base *base)
 	}
 }
 
-#if (EVLIST_INTERNAL >> 4) != 1
-#error "Mismatch for value of EVLIST_INTERNAL"
-#endif
-
 #ifndef MAX
 #define MAX(a,b) (((a)>(b))?(a):(b))
 #endif
@@ -3159,13 +3207,13 @@ timeout_process(struct event_base *base)
 #define MAX_EVENT_COUNT(var, v) var = MAX(var, v)
 
 /* These are a fancy way to spell
-     if (flags & EVLIST_INTERNAL)
+     if (~flags & EVLIST_INTERNAL)
          base->event_count--/++;
 */
 #define DECR_EVENT_COUNT(base,flags) \
-	((base)->event_count -= (~((flags) >> 4) & 1))
+	((base)->event_count -= !((flags) & EVLIST_INTERNAL))
 #define INCR_EVENT_COUNT(base,flags) do {					\
-	((base)->event_count += (~((flags) >> 4) & 1));				\
+	((base)->event_count += !((flags) & EVLIST_INTERNAL));			\
 	MAX_EVENT_COUNT((base)->event_count_max, (base)->event_count);		\
 } while (0)
 
@@ -3697,13 +3745,14 @@ dump_inserted_event_fn(const struct event_base *base, const struct event *e, voi
 	if (! (e->ev_flags & (EVLIST_INSERTED|EVLIST_TIMEOUT)))
 		return 0;
 
-	fprintf(output, "  %p [%s "EV_SOCK_FMT"]%s%s%s%s%s%s",
+	fprintf(output, "  %p [%s "EV_SOCK_FMT"]%s%s%s%s%s%s%s",
 	    (void*)e, gloss, EV_SOCK_ARG(e->ev_fd),
 	    (e->ev_events&EV_READ)?" Read":"",
 	    (e->ev_events&EV_WRITE)?" Write":"",
 	    (e->ev_events&EV_CLOSED)?" EOF":"",
 	    (e->ev_events&EV_SIGNAL)?" Signal":"",
 	    (e->ev_events&EV_PERSIST)?" Persist":"",
+	    (e->ev_events&EV_ET)?" ET":"",
 	    (e->ev_flags&EVLIST_INTERNAL)?" Internal":"");
 	if (e->ev_flags & EVLIST_TIMEOUT) {
 		struct timeval tv;