/*

* 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"

#include "evconfig-private.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

#include <ctype.h>

#include <errno.h>

#include <signal.h>

#include <string.h>

#include <time.h>

#include <limits.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"

#define HT_NO_CACHE_HASH_VALUES

#include "ht-internal.h"

#include "util-internal.h"

#ifdef EVENT__HAVE_WORKING_KQUEUE

#include "kqueue-internal.h"

#endif

#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 void *event_self_cbarg_ptr_ = NULL;

/* Prototypes */

static void event_queue_insert_active(struct event_base *, struct event_callback *);

static void event_queue_insert_active_later(struct event_base *, struct event_callback *);

static void event_queue_insert_timeout(struct event_base *, struct event *);

static void event_queue_insert_inserted(struct event_base *, struct event *);

static void event_queue_remove_active(struct event_base *, struct event_callback *);

static void event_queue_remove_active_later(struct event_base *, struct event_callback *);

static void event_queue_remove_timeout(struct event_base *, struct event *);

static void event_queue_remove_inserted(struct event_base *, struct event *);

static void event_queue_make_later_events_active(struct event_base *base);

static int evthread_make_base_notifiable_nolock_(struct event_base *base);

static int event_del_(struct event *ev, int blocking);

#ifdef USE_REINSERT_TIMEOUT

/* This code seems buggy; only turn it on if we find out what the trouble is. */

static void event_queue_reinsert_timeout(struct event_base *,struct event *, int was_common, int is_common, int old_timeout_idx);

#endif

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

static void insert_common_timeout_inorder(struct common_timeout_list *ctl,

struct event *ev);

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

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

/** 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 (evutil_gettime_monotonic_(&base->monotonic_timer, tp) == -1) {

return -1;

}

if (base->last_updated_clock_diff + CLOCK_SYNC_INTERVAL

< tp->tv_sec) {

struct timeval tv;

evutil_gettimeofday(&tv,NULL);

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

base->last_updated_clock_diff = tp->tv_sec;

}

return 0;

}

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 {

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

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

}

int

event_base_update_cache_time(struct event_base *base)

{

if (!base) {

base = current_base;

if (!current_base)

return -1;

}

EVBASE_ACQUIRE_LOCK(base, th_base_lock);

if (base->running_loop)

update_time_cache(base);

EVBASE_RELEASE_LOCK(base, th_base_lock);

return 0;

}

static inline struct event *

event_callback_to_event(struct event_callback *evcb)

{

EVUTIL_ASSERT((evcb->evcb_flags & EVLIST_INIT));

return EVUTIL_UPCAST(evcb, struct event, ev_evcallback);

}

static inline struct event_callback *

event_to_event_callback(struct event *ev)

{

return &ev->ev_evcallback;

}

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_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;

}

if (cfg)

base->flags = cfg->flags;

should_check_environment =

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

{

struct timeval tmp;

int precise_time =

cfg && (cfg->flags & EVENT_BASE_FLAG_PRECISE_TIMER);

int flags;

if (should_check_environment && !precise_time) {

precise_time = evutil_getenv_("EVENT_PRECISE_TIMER") != NULL;

base->flags |= EVENT_BASE_FLAG_PRECISE_TIMER;

}

flags = precise_time ? EV_MONOT_PRECISE : 0;

evutil_configure_monotonic_time_(&base->monotonic_timer, flags);

gettime(base, &tmp);

}

min_heap_ctor_(&base->timeheap);

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;

TAILQ_INIT(&base->active_later_queue);

evmap_io_initmap_(&base->io);

evmap_signal_initmap_(&base->sigmap);

event_changelist_init_(&base->changelist);

base->evbase = NULL;

if (cfg) {

memcpy(&base->max_dispatch_time,

&cfg->max_dispatch_interval, sizeof(struct timeval));

base->limit_callbacks_after_prio =

cfg->limit_callbacks_after_prio;

} else {

base->max_dispatch_time.tv_sec = -1;

base->limit_callbacks_after_prio = 1;

}

if (cfg && cfg->max_dispatch_callbacks >= 0) {

base->max_dispatch_callbacks = cfg->max_dispatch_callbacks;

} else {

base->max_dispatch_callbacks = INT_MAX;

}

if (base->max_dispatch_callbacks == INT_MAX &&

base->max_dispatch_time.tv_sec == -1)

base->limit_callbacks_after_prio = INT_MAX;

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, 0);

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

}

static int

event_base_cancel_single_callback_(struct event_base *base,

struct event_callback *evcb,

int run_finalizers)

{

int result = 0;

if (evcb->evcb_flags & EVLIST_INIT) {

struct event *ev = event_callback_to_event(evcb);

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

event_del_(ev, EVENT_DEL_EVEN_IF_FINALIZING);

result = 1;

}

} else {

EVBASE_ACQUIRE_LOCK(base, th_base_lock);

event_callback_cancel_nolock_(base, evcb, 1);

EVBASE_RELEASE_LOCK(base, th_base_lock);

result = 1;

}

if (run_finalizers && (evcb->evcb_flags & EVLIST_FINALIZING)) {

switch (evcb->evcb_closure) {

case EV_CLOSURE_EVENT_FINALIZE:

case EV_CLOSURE_EVENT_FINALIZE_FREE: {

struct event *ev = event_callback_to_event(evcb);

ev->ev_evcallback.evcb_cb_union.evcb_evfinalize(ev, ev->ev_arg);

if (evcb->evcb_closure == EV_CLOSURE_EVENT_FINALIZE_FREE)

mm_free(ev);

break;

}

case EV_CLOSURE_CB_FINALIZE:

evcb->evcb_cb_union.evcb_cbfinalize(evcb, evcb->evcb_arg);

break;

default:

break;

}

}

return result;

}

static void

event_base_free_(struct event_base *base, int run_finalizers)

{

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;

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

evmap_delete_all_(base);

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

struct event_callback *evcb, *next;

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

next = TAILQ_NEXT(evcb, evcb_active_next);

n_deleted += event_base_cancel_single_callback_(base, evcb, run_finalizers);

evcb = next;

}

}

{

struct event_callback *evcb;

while ((evcb = TAILQ_FIRST(&base->active_later_queue))) {

n_deleted += event_base_cancel_single_callback_(base, evcb, run_finalizers);

}

}

if (n_deleted)

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

__func__, n_deleted));

while (LIST_FIRST(&base->once_events)) {

struct event_once *eonce = LIST_FIRST(&base->once_events);

LIST_REMOVE(eonce, next_once);

mm_free(eonce);

}

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

evmap_io_clear_(&base->io);

evmap_signal_clear_(&base->sigmap);

event_changelist_freemem_(&base->changelist);

EVTHREAD_FREE_LOCK(base->th_base_lock, 0);

EVTHREAD_FREE_COND(base->current_event_cond);

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

if (base == current_base)

current_base = NULL;

mm_free(base);

}

void

event_base_free_nofinalize(struct event_base *base)

{

event_base_free_(base, 0);

}

void

event_base_free(struct event_base *base)

{

event_base_free_(base, 1);

}

/* Fake eventop; used to disable the backend temporarily inside event_reinit

* so that we can call event_del() on an event without telling the backend.

*/

static int

nil_backend_del(struct event_base *b, evutil_socket_t fd, short old,

short events, void *fdinfo)

{

return 0;

}

const struct eventop nil_eventop = {

"nil",

NULL, /* init: unused. */

NULL, /* add: unused. */

nil_backend_del, /* del: used, so needs to be killed. */

NULL, /* dispatch: unused. */

NULL, /* dealloc: unused. */

0, 0, 0

};

/* reinitialize the event base after a fork */

int

event_reinit(struct event_base *base)

{

const struct eventop *evsel;

int res = 0;

int was_notifiable = 0;

int had_signal_added = 0;

EVBASE_ACQUIRE_LOCK(base, th_base_lock);

evsel = base->evsel;

/* check if this event mechanism requires reinit on the backend */

if (evsel->need_reinit) {

/* We're going to call event_del() on our notify events (the

* ones that tell about signals and wakeup events). But we

* don't actually want to tell the backend to change its

* state, since it might still share some resource (a kqueue,

* an epoll fd) with the parent process, and we don't want to

* delete the fds from _that_ backend, we temporarily stub out

* the evsel with a replacement.

*/

base->evsel = &nil_eventop;

}

/* We need to re-create a new signal-notification fd and a new

* thread-notification fd. Otherwise, we'll still share those with

* the parent process, which would make any notification sent to them

* get received by one or both of the event loops, more or less at

* random.

*/

if (base->sig.ev_signal_added) {

event_del_nolock_(&base->sig.ev_signal, EVENT_DEL_AUTOBLOCK);

event_debug_unassign(&base->sig.ev_signal);

memset(&base->sig.ev_signal, 0, sizeof(base->sig.ev_signal));

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]);

had_signal_added = 1;

base->sig.ev_signal_added = 0;

}

if (base->th_notify_fn != NULL) {

was_notifiable = 1;

base->th_notify_fn = NULL;

}

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

event_del_nolock_(&base->th_notify, EVENT_DEL_AUTOBLOCK);

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

}

/* Replace the original evsel. */

base->evsel = evsel;

if (evsel->need_reinit) {

/* Reconstruct the backend through brute-force, so that we do

* not share any structures with the parent process. For some

* backends, this is necessary: epoll and kqueue, for

* instance, have events associated with a kernel

* structure. If didn't reinitialize, we'd share that

* structure with the parent process, and any changes made by

* the parent would affect our backend's behavior (and vice

* versa).

*/

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;

}

/* Empty out the changelist (if any): we are starting from a

* blank slate. */

event_changelist_freemem_(&base->changelist);

/* Tell the event maps to re-inform the backend about all

* pending events. This will make the signal notification

* event get re-created if necessary. */

if (evmap_reinit_(base) < 0)

res = -1;

} else {

if (had_signal_added)

res = evsig_init_(base);

}

/* If we were notifiable before, and nothing just exploded, become

* notifiable again. */

if (was_notifiable && res == 0)

res = evthread_make_base_notifiable_nolock_(base);

done:

EVBASE_RELEASE_LOCK(base, th_base_lock);

return (res);

}

const char **

event_get_supported_methods(void)

{

static const char **methods = NULL;

const struct eventop **method;