/*

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

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

 *

 * 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 "event2/event-config.h"

#ifdef WIN32

#include <winsock2.h>

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

#undef WIN32_LEAN_AND_MEAN

#endif

#include <sys/types.h>

#if !defined(WIN32) && defined(_EVENT_HAVE_SYS_TIME_H)

#include <sys/time.h>

#endif

#include <sys/queue.h>

#ifdef _EVENT_HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#ifdef _EVENT_HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef _EVENT_HAVE_SYS_EVENTFD_H

#include <sys/eventfd.h>

#endif

#include <ctype.h>

#include <errno.h>

#include <signal.h>

#include <string.h>

#include <time.h>

#include "event2/event.h"

#include "event2/event_struct.h"

#include "event2/event_compat.h"

#include "event-internal.h"

#include "defer-internal.h"

#include "evthread-internal.h"

#include "event2/thread.h"

#include "event2/util.h"

#include "log-internal.h"

#include "evmap-internal.h"

#include "iocp-internal.h"

#include "changelist-internal.h"

#include "ht-internal.h"

#include "util-internal.h"

#ifdef _EVENT_HAVE_EVENT_PORTS

extern const struct eventop evportops;

#endif

#ifdef _EVENT_HAVE_SELECT

extern const struct eventop selectops;

#endif

#ifdef _EVENT_HAVE_POLL

extern const struct eventop pollops;

#endif

#ifdef _EVENT_HAVE_EPOLL

extern const struct eventop epollops;

#endif

#ifdef _EVENT_HAVE_WORKING_KQUEUE

extern const struct eventop kqops;

#endif

#ifdef _EVENT_HAVE_DEVPOLL

extern const struct eventop devpollops;

#endif

#ifdef WIN32

extern const struct eventop win32ops;

#endif

/* Array of backends in order of preference. */

static const struct eventop *eventops[] = {

#ifdef _EVENT_HAVE_EVENT_PORTS

	&evportops,

#endif

#ifdef _EVENT_HAVE_WORKING_KQUEUE

	&kqops,

#endif

#ifdef _EVENT_HAVE_EPOLL

	&epollops,

#endif

#ifdef _EVENT_HAVE_DEVPOLL

	&devpollops,

#endif

#ifdef _EVENT_HAVE_POLL

	&pollops,

#endif

#ifdef _EVENT_HAVE_SELECT

	&selectops,

#endif

#ifdef WIN32

	&win32ops,

#endif

	NULL

};

/* Global state; deprecated */

struct event_base *event_global_current_base_ = NULL;

#define current_base event_global_current_base_

/* Global state */

static int use_monotonic;

/* Prototypes */

static inline int event_add_internal(struct event *ev,

    const struct timeval *tv, int tv_is_absolute);

static inline int event_del_internal(struct event *ev);

static void	event_queue_insert(struct event_base *, struct event *, int);

static void	event_queue_remove(struct event_base *, struct event *, int);

static int	event_haveevents(struct event_base *);

static int	event_process_active(struct event_base *);

static int	timeout_next(struct event_base *, struct timeval **);

static void	timeout_process(struct event_base *);

static void	timeout_correct(struct event_base *, struct timeval *);

static inline void	event_signal_closure(struct event_base *, struct event *ev);

static inline void	event_persist_closure(struct event_base *, struct event *ev);

static int	evthread_notify_base(struct event_base *base);

#ifndef _EVENT_DISABLE_DEBUG_MODE

/* These functions implement a hashtable of which 'struct event *' structures

 * have been setup or added.  We don't want to trust the content of the struct

 * event itself, since we're trying to work through cases where an event gets

 * clobbered or freed.  Instead, we keep a hashtable indexed by the pointer.

 */

struct event_debug_entry {

	HT_ENTRY(event_debug_entry) node;

	const struct event *ptr;

	unsigned added : 1;

};

static inline unsigned

hash_debug_entry(const struct event_debug_entry *e)

{

	/* We need to do this silliness to convince compilers that we

	 * honestly mean to cast e->ptr to an integer, and discard any

	 * part of it that doesn't fit in an unsigned.

	 */

	unsigned u = (unsigned) ((ev_uintptr_t) e->ptr);

	/* Our hashtable implementation is pretty sensitive to low bits,

	 * and every struct event is over 64 bytes in size, so we can

	 * just say >>6. */

	return (u >> 6);

}

static inline int

eq_debug_entry(const struct event_debug_entry *a,

    const struct event_debug_entry *b)

{

	return a->ptr == b->ptr;

}

int _event_debug_mode_on = 0;

/* Set if it's too late to enable event_debug_mode. */

static int event_debug_mode_too_late = 0;

#ifndef _EVENT_DISABLE_THREAD_SUPPORT

static void *_event_debug_map_lock = NULL;

#endif

static HT_HEAD(event_debug_map, event_debug_entry) global_debug_map =

	HT_INITIALIZER();

HT_PROTOTYPE(event_debug_map, event_debug_entry, node, hash_debug_entry,

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

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

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

#endif

#define EVENT_BASE_ASSERT_LOCKED(base)		\

	EVLOCK_ASSERT_LOCKED((base)->th_base_lock)

/* The first time this function is called, it sets use_monotonic to 1

 * if we have a clock function that supports monotonic time */

static void

detect_monotonic(void)

{

#if defined(_EVENT_HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)

	struct timespec	ts;

	static int use_monotonic_initialized = 0;

	if (use_monotonic_initialized)

		return;

	if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)

		use_monotonic = 1;

	use_monotonic_initialized = 1;

#endif

}

/* How often (in seconds) do we check for changes in wall clock time relative

 * to monotonic time?  Set this to -1 for 'never.' */

#define CLOCK_SYNC_INTERVAL -1

/** Set 'tp' to the current time according to 'base'.  We must hold the lock

 * on 'base'.  If there is a cached time, return it.  Otherwise, use

 * clock_gettime or gettimeofday as appropriate to find out the right time.

 * Return 0 on success, -1 on failure.

 */

static int

gettime(struct event_base *base, struct timeval *tp)

{

	EVENT_BASE_ASSERT_LOCKED(base);

	if (base->tv_cache.tv_sec) {

		*tp = base->tv_cache;

		return (0);

	}

#if defined(_EVENT_HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)

	if (use_monotonic) {

		struct timespec	ts;

		if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1)

			return (-1);

		tp->tv_sec = ts.tv_sec;

		tp->tv_usec = ts.tv_nsec / 1000;

		if (base->last_updated_clock_diff + CLOCK_SYNC_INTERVAL

		    < ts.tv_sec) {

			struct timeval tv;

			evutil_gettimeofday(&tv,NULL);

			evutil_timersub(&tv, tp, &base->tv_clock_diff);

			base->last_updated_clock_diff = ts.tv_sec;

		}

		return (0);

	}

#endif

	return (evutil_gettimeofday(tp, NULL));

}

int

event_base_gettimeofday_cached(struct event_base *base, struct timeval *tv)

{

	int r;

	if (!base) {

		base = current_base;

		if (!current_base)

			return evutil_gettimeofday(tv, NULL);

	}

	EVBASE_ACQUIRE_LOCK(base, th_base_lock);

	if (base->tv_cache.tv_sec == 0) {

		r = evutil_gettimeofday(tv, NULL);

	} else {

#if defined(_EVENT_HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)

		evutil_timeradd(&base->tv_cache, &base->tv_clock_diff, tv);

#else

		*tv = base->tv_cache;

#endif

		r = 0;

	}

	EVBASE_RELEASE_LOCK(base, th_base_lock);

	return r;

}

/** Make 'base' have no current cached time. */

static inline void

clear_time_cache(struct event_base *base)

{

	base->tv_cache.tv_sec = 0;

}

/** Replace the cached time in 'base' with the current time. */

static inline void

update_time_cache(struct event_base *base)

{

	base->tv_cache.tv_sec = 0;

	if (!(base->flags & EVENT_BASE_FLAG_NO_CACHE_TIME))

	    gettime(base, &base->tv_cache);

}

struct event_base *

event_init(void)

{

	struct event_base *base = event_base_new_with_config(NULL);

	if (base == NULL) {

		event_errx(1, "%s: Unable to construct event_base", __func__);

		return NULL;

	}

	current_base = base;

	return (base);

}

struct event_base *

event_base_new(void)

{

	struct event_base *base = NULL;

	struct event_config *cfg = event_config_new();

	if (cfg) {

		base = event_base_new_with_config(cfg);

		event_config_free(cfg);

	}

	return base;

}

/** Return true iff 'method' is the name of a method that 'cfg' tells us to

 * avoid. */

static int

event_config_is_avoided_method(const struct event_config *cfg,

    const char *method)

{

	struct event_config_entry *entry;

	TAILQ_FOREACH(entry, &cfg->entries, next) {

		if (entry->avoid_method != NULL &&

		    strcmp(entry->avoid_method, method) == 0)

			return (1);

	}

	return (0);

}

/** Return true iff 'method' is disabled according to the environment. */

static int

event_is_method_disabled(const char *name)

{

	char environment[64];

	int i;

	evutil_snprintf(environment, sizeof(environment), "EVENT_NO%s", name);

	for (i = 8; environment[i] != '\0'; ++i)

		environment[i] = EVUTIL_TOUPPER(environment[i]);

	/* Note that evutil_getenv() ignores the environment entirely if

	 * we're setuid */

	return (evutil_getenv(environment) != NULL);

}

int

event_base_get_features(const struct event_base *base)

{

	return base->evsel->features;

}

void

event_deferred_cb_queue_init(struct deferred_cb_queue *cb)

{

	memset(cb, 0, sizeof(struct deferred_cb_queue));

	TAILQ_INIT(&cb->deferred_cb_list);

}

/** Helper for the deferred_cb queue: wake up the event base. */

static void

notify_base_cbq_callback(struct deferred_cb_queue *cb, void *baseptr)

{

	struct event_base *base = baseptr;

	if (EVBASE_NEED_NOTIFY(base))

		evthread_notify_base(base);

}

struct deferred_cb_queue *

event_base_get_deferred_cb_queue(struct event_base *base)

{

	return base ? &base->defer_queue : NULL;

}

void

event_enable_debug_mode(void)

{

#ifndef _EVENT_DISABLE_DEBUG_MODE

	if (_event_debug_mode_on)

		event_errx(1, "%s was called twice!", __func__);

	if (event_debug_mode_too_late)

		event_errx(1, "%s must be called *before* creating any events "

		    "or event_bases",__func__);

	_event_debug_mode_on = 1;

	HT_INIT(event_debug_map, &global_debug_map);

#endif

}

#if 0

void

event_disable_debug_mode(void)

{

	struct event_debug_entry **ent, *victim;

	EVLOCK_LOCK(_event_debug_map_lock, 0);

	for (ent = HT_START(event_debug_map, &global_debug_map); ent; ) {

		victim = *ent;

		ent = HT_NEXT_RMV(event_debug_map,&global_debug_map, ent);

		mm_free(victim);

	}

	HT_CLEAR(event_debug_map, &global_debug_map);

	EVLOCK_UNLOCK(_event_debug_map_lock , 0);

}

#endif

struct event_base *

event_base_new_with_config(const struct event_config *cfg)

{

	int i;

	struct event_base *base;

	int should_check_environment;

#ifndef _EVENT_DISABLE_DEBUG_MODE

	event_debug_mode_too_late = 1;

#endif

	if ((base = mm_calloc(1, sizeof(struct event_base))) == NULL) {

		event_warn("%s: calloc", __func__);

		return NULL;

	}

	detect_monotonic();

	gettime(base, &base->event_tv);

	min_heap_ctor(&base->timeheap);

	TAILQ_INIT(&base->eventqueue);

	base->sig.ev_signal_pair[0] = -1;

	base->sig.ev_signal_pair[1] = -1;

	base->th_notify_fd[0] = -1;

	base->th_notify_fd[1] = -1;

	event_deferred_cb_queue_init(&base->defer_queue);

	base->defer_queue.notify_fn = notify_base_cbq_callback;

	base->defer_queue.notify_arg = base;

	if (cfg)

		base->flags = cfg->flags;

	evmap_io_initmap(&base->io);

	evmap_signal_initmap(&base->sigmap);

	event_changelist_init(&base->changelist);

	base->evbase = NULL;

	should_check_environment =

	    !(cfg && (cfg->flags & EVENT_BASE_FLAG_IGNORE_ENV));

	for (i = 0; eventops[i] && !base->evbase; i++) {

		if (cfg != NULL) {

			/* determine if this backend should be avoided */

			if (event_config_is_avoided_method(cfg,

				eventops[i]->name))

				continue;

			if ((eventops[i]->features & cfg->require_features)

			    != cfg->require_features)

				continue;

		}

		/* also obey the environment variables */

		if (should_check_environment &&

		    event_is_method_disabled(eventops[i]->name))

			continue;

		base->evsel = eventops[i];

		base->evbase = base->evsel->init(base);

	}

	if (base->evbase == NULL) {

		event_warnx("%s: no event mechanism available",

		    __func__);

		base->evsel = NULL;

		event_base_free(base);

		return NULL;

	}

	if (evutil_getenv("EVENT_SHOW_METHOD"))

		event_msgx("libevent using: %s", base->evsel->name);

	/* allocate a single active event queue */

	if (event_base_priority_init(base, 1) < 0) {

		event_base_free(base);

		return NULL;

	}

	/* prepare for threading */

#ifndef _EVENT_DISABLE_THREAD_SUPPORT

	if (EVTHREAD_LOCKING_ENABLED() &&

	    (!cfg || !(cfg->flags & EVENT_BASE_FLAG_NOLOCK))) {

		int r;

		EVTHREAD_ALLOC_LOCK(base->th_base_lock,

		    EVTHREAD_LOCKTYPE_RECURSIVE);

		base->defer_queue.lock = base->th_base_lock;

		EVTHREAD_ALLOC_COND(base->current_event_cond);

		r = evthread_make_base_notifiable(base);

		if (r<0) {

			event_warnx("%s: Unable to make base notifiable.", __func__);

			event_base_free(base);

			return NULL;

		}

	}

#endif

#ifdef WIN32

	if (cfg && (cfg->flags & EVENT_BASE_FLAG_STARTUP_IOCP))

		event_base_start_iocp(base, cfg->n_cpus_hint);

#endif

	return (base);

}

int

event_base_start_iocp(struct event_base *base, int n_cpus)

{

#ifdef WIN32

	if (base->iocp)

		return 0;

	base->iocp = event_iocp_port_launch(n_cpus);

	if (!base->iocp) {

		event_warnx("%s: Couldn't launch IOCP", __func__);

		return -1;

	}

	return 0;

#else

	return -1;

#endif

}

void

event_base_stop_iocp(struct event_base *base)

{

#ifdef WIN32

	int rv;

	if (!base->iocp)

		return;

	rv = event_iocp_shutdown(base->iocp, -1);

	EVUTIL_ASSERT(rv >= 0);

	base->iocp = NULL;

#endif

}

void

event_base_free(struct event_base *base)

{

	int i, n_deleted=0;

	struct event *ev;

	/* XXXX grab the lock? If there is contention when one thread frees

	 * the base, then the contending thread will be very sad soon. */

	/* event_base_free(NULL) is how to free the current_base if we

	 * made it with event_init and forgot to hold a reference to it. */

	if (base == NULL && current_base)

		base = current_base;

	/* If we're freeing current_base, there won't be a current_base. */

	if (base == current_base)

		current_base = NULL;

	/* Don't actually free NULL. */

	if (base == NULL) {

		event_warnx("%s: no base to free", __func__);

		return;

	}

	/* XXX(niels) - check for internal events first */

#ifdef WIN32

	event_base_stop_iocp(base);

#endif

	/* threading fds if we have them */

	if (base->th_notify_fd[0] != -1) {

		event_del(&base->th_notify);

		EVUTIL_CLOSESOCKET(base->th_notify_fd[0]);

		if (base->th_notify_fd[1] != -1)

			EVUTIL_CLOSESOCKET(base->th_notify_fd[1]);

		base->th_notify_fd[0] = -1;

		base->th_notify_fd[1] = -1;

		event_debug_unassign(&base->th_notify);

	}

	/* Delete all non-internal events. */

	for (ev = TAILQ_FIRST(&base->eventqueue); ev; ) {

		struct event *next = TAILQ_NEXT(ev, ev_next);

		if (!(ev->ev_flags & EVLIST_INTERNAL)) {

			event_del(ev);

			++n_deleted;

		}

		ev = next;

	}

	while ((ev = min_heap_top(&base->timeheap)) != NULL) {

		event_del(ev);

		++n_deleted;

	}

	for (i = 0; i < base->n_common_timeouts; ++i) {

		struct common_timeout_list *ctl =

		    base->common_timeout_queues[i];

		event_del(&ctl->timeout_event); /* Internal; doesn't count */

		event_debug_unassign(&ctl->timeout_event);

		for (ev = TAILQ_FIRST(&ctl->events); ev; ) {

			struct event *next = TAILQ_NEXT(ev,

			    ev_timeout_pos.ev_next_with_common_timeout);

			if (!(ev->ev_flags & EVLIST_INTERNAL)) {

				event_del(ev);

				++n_deleted;

			}

			ev = next;

		}

		mm_free(ctl);

	}

	if (base->common_timeout_queues)

		mm_free(base->common_timeout_queues);

	for (i = 0; i < base->nactivequeues; ++i) {

		for (ev = TAILQ_FIRST(&base->activequeues[i]); ev; ) {

			struct event *next = TAILQ_NEXT(ev, ev_active_next);

			if (!(ev->ev_flags & EVLIST_INTERNAL)) {

				event_del(ev);

				++n_deleted;

			}

			ev = next;

		}

	}

	if (n_deleted)

		event_debug(("%s: %d events were still set in base",

			__func__, n_deleted));

	if (base->evsel != NULL && base->evsel->dealloc != NULL)

		base->evsel->dealloc(base);

	for (i = 0; i < base->nactivequeues; ++i)

		EVUTIL_ASSERT(TAILQ_EMPTY(&base->activequeues[i]));

	EVUTIL_ASSERT(min_heap_empty(&base->timeheap));

	min_heap_dtor(&base->timeheap);

	mm_free(base->activequeues);

	EVUTIL_ASSERT(TAILQ_EMPTY(&base->eventqueue));

	evmap_io_clear(&base->io);

	evmap_signal_clear(&base->sigmap);

	event_changelist_freemem(&base->changelist);

	EVTHREAD_FREE_LOCK(base->th_base_lock, EVTHREAD_LOCKTYPE_RECURSIVE);

	EVTHREAD_FREE_COND(base->current_event_cond);

	mm_free(base);

}

/* reinitialize the event base after a fork */

int

event_reinit(struct event_base *base)

{

	const struct eventop *evsel;

	int res = 0;

	struct event *ev;

	int was_notifiable = 0;

	EVBASE_ACQUIRE_LOCK(base, th_base_lock);

	evsel = base->evsel;

#if 0

	/* Right now, reinit always takes effect, since even if the

	   backend doesn't require it, the signal socketpair code does.

	   XXX

	 */

	/* check if this event mechanism requires reinit */

	if (!evsel->need_reinit)

		goto done;

#endif

	/* prevent internal delete */

	if (base->sig.ev_signal_added) {

		/* we cannot call event_del here because the base has

		 * not been reinitialized yet. */

		event_queue_remove(base, &base->sig.ev_signal,

		    EVLIST_INSERTED);

		if (base->sig.ev_signal.ev_flags & EVLIST_ACTIVE)

			event_queue_remove(base, &base->sig.ev_signal,

			    EVLIST_ACTIVE);

		if (base->sig.ev_signal_pair[0] != -1)

			EVUTIL_CLOSESOCKET(base->sig.ev_signal_pair[0]);

		if (base->sig.ev_signal_pair[1] != -1)

			EVUTIL_CLOSESOCKET(base->sig.ev_signal_pair[1]);

		base->sig.ev_signal_added = 0;

	}

	if (base->th_notify_fd[0] != -1) {

		/* we cannot call event_del here because the base has

		 * not been reinitialized yet. */

		was_notifiable = 1;

		event_queue_remove(base, &base->th_notify,

		    EVLIST_INSERTED);

		if (base->th_notify.ev_flags & EVLIST_ACTIVE)

			event_queue_remove(base, &base->th_notify,

			    EVLIST_ACTIVE);

		base->sig.ev_signal_added = 0;

		EVUTIL_CLOSESOCKET(base->th_notify_fd[0]);

		if (base->th_notify_fd[1] != -1)

			EVUTIL_CLOSESOCKET(base->th_notify_fd[1]);

		base->th_notify_fd[0] = -1;

		base->th_notify_fd[1] = -1;

		event_debug_unassign(&base->th_notify);

	}

	if (base->evsel->dealloc != NULL)

		base->evsel->dealloc(base);

	base->evbase = evsel->init(base);

	if (base->evbase == NULL) {

		event_errx(1, "%s: could not reinitialize event mechanism",

		    __func__);

		res = -1;

		goto done;

	}

	event_changelist_freemem(&base->changelist); /* XXX */

	evmap_io_clear(&base->io);

	evmap_signal_clear(&base->sigmap);

	TAILQ_FOREACH(ev, &base->eventqueue, ev_next) {

		if (ev->ev_events & (EV_READ|EV_WRITE)) {

			if (ev == &base->sig.ev_signal) {

				/* If we run into the ev_signal event, it's only

				 * in eventqueue because some signal event was

				 * added, which made evsig_add re-add ev_signal.

				 * So don't double-add it. */

				continue;

			}

			if (evmap_io_add(base, ev->ev_fd, ev) == -1)

				res = -1;

		} else if (ev->ev_events & EV_SIGNAL) {

			if (evmap_signal_add(base, (int)ev->ev_fd, ev) == -1)

				res = -1;

		}

	}