/usr/src/lib/libevent/event.c

Bug Summary

File:	src/lib/libevent/event.c
Warning:	line 283, column 25 Array access (via field 'activequeues') results in a null pointer dereference

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name event.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/lib/libevent/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/lib/libevent -D NDEBUG -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/lib/libevent/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/lib/libevent/event.c

1/*	$OpenBSD: event.c,v 1.41 2019/05/01 19:14:25 jca Exp $	*/

3/*
* Copyright (c) 2000-2004 Niels Provos <provos@citi.umich.edu>
* All rights reserved.
*
* 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.
*/

30#include <sys/types.h>
31#include <sys/socket.h>
32#include <sys/time.h>
33#include <sys/queue.h>

35#include <stdio.h>
36#include <stdlib.h>
37#include <unistd.h>
38#include <errno(*__errno()).h>
39#include <signal.h>
40#include <string.h>
41#include <assert.h>
42#include <time.h>
43#include <netdb.h>
44#include <asr.h>

46#include "event.h"
47#include "event-internal.h"
48#include "log.h"

50extern const struct eventop selectops;
51extern const struct eventop pollops;
52extern const struct eventop kqops;

54/* In order of preference */
55static const struct eventop *eventops[] = {
&kqops,
&pollops,
&selectops,
NULL((void *)0)
60};

62/* Global state */
63struct event_base *current_base = NULL((void *)0);
64extern struct event_base *evsignal_base;

66/* Handle signals - This is a deprecated interface */
67int (*event_sigcb)(void);		/* Signal callback when gotsig is set */
68volatile sig_atomic_t event_gotsig;	/* Set in signal handler */

70/* Prototypes */
71static void	event_queue_insert(struct event_base *, struct event *, int);
72static void	event_queue_remove(struct event_base *, struct event *, int);
73static int	event_haveevents(struct event_base *);

75static void	event_process_active(struct event_base *);

77static int	timeout_next(struct event_base *, struct timeval **);
78static void	timeout_process(struct event_base *);

80static void
81gettime(struct event_base *base, struct timeval *tp)
82{
struct timespec	ts;

if (base->tv_cache.tv_sec) {
*tp = base->tv_cache;
return;
}

if (clock_gettime(CLOCK_MONOTONIC3, &ts) == -1)
event_err(1, "%s: clock_gettime", __func__);

TIMESPEC_TO_TIMEVAL(tp, &ts)do { (tp)->tv_sec = (&ts)->tv_sec; (tp)->tv_usec
 = (&ts)->tv_nsec / 1000; } while (0);
94}

96struct event_base *
97event_init(void)
98{
struct event_base *base = event_base_new();

if (base != NULL((void *)0))
current_base = base;

return (base);
105}

107struct event_base *
108event_base_new(void)
109{
int i;
struct event_base *base;

if ((base = calloc(1, sizeof(struct event_base))) == NULL((void *)0))
event_err(1, "%s: calloc", __func__);

event_sigcb = NULL((void *)0);
event_gotsig = 0;

gettime(base, &base->event_tv);

min_heap_ctor(&base->timeheap);
TAILQ_INIT(&base->eventqueue)do { (&base->eventqueue)->tqh_first = ((void *)0); (
&base->eventqueue)->tqh_last = &(&base->
eventqueue)->tqh_first; } while (0);
base->sig.ev_signal_pair[0] = -1;
base->sig.ev_signal_pair[1] = -1;

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

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

if (base->evbase == NULL((void *)0))
event_errx(1, "%s: no event mechanism available", __func__);

if (!issetugid() && getenv("EVENT_SHOW_METHOD"))
event_msgx("libevent using: %s", base->evsel->name);

/* allocate a single active event queue */
event_base_priority_init(base, 1);

return (base);
143}

145void
146event_base_free(struct event_base *base)
147{
int i;
size_t n_deleted=0;
struct event *ev;

if (base == NULL((void *)0) && current_base)
base = current_base;
if (base == current_base)
current_base = NULL((void *)0);

/* XXX(niels) - check for internal events first */
assert(base)((void)0);
/* Delete all non-internal events. */
for (ev = TAILQ_FIRST(&base->eventqueue)((&base->eventqueue)->tqh_first); ev; ) {
struct event *next = TAILQ_NEXT(ev, ev_next)((ev)->ev_next.tqe_next);
if (!(ev->ev_flags & EVLIST_INTERNAL0x10)) {
	event_del(ev);
	++n_deleted;
}
ev = next;
}
while ((ev = min_heap_top(&base->timeheap)) != NULL((void *)0)) {
event_del(ev);
++n_deleted;
}

for (i = 0; i < base->nactivequeues; ++i) {
for (ev = TAILQ_FIRST(base->activequeues[i])((base->activequeues[i])->tqh_first); ev; ) {
	struct event *next = TAILQ_NEXT(ev, ev_active_next)((ev)->ev_active_next.tqe_next);
	if (!(ev->ev_flags & EVLIST_INTERNAL0x10)) {
		event_del(ev);
		++n_deleted;
	}
	ev = next;
}
}

if (n_deleted)
event_debug(("%s: %zu events were still set in base",do {;} while (0)
	__func__, n_deleted))do {;} while (0);

if (base->evsel->dealloc != NULL((void *)0))
base->evsel->dealloc(base, base->evbase);

for (i = 0; i < base->nactivequeues; ++i)
assert(TAILQ_EMPTY(base->activequeues[i]))((void)0);

assert(min_heap_empty(&base->timeheap))((void)0);
min_heap_dtor(&base->timeheap);

for (i = 0; i < base->nactivequeues; ++i)
free(base->activequeues[i]);
free(base->activequeues);

assert(TAILQ_EMPTY(&base->eventqueue))((void)0);

free(base);
204}

206/* reinitialized the event base after a fork */
207int
208event_reinit(struct event_base *base)
209{
const struct eventop *evsel = base->evsel;
void *evbase = base->evbase;
int res = 0;
struct event *ev;

215#if 0
/* Right now, reinit always takes effect, since even if the
  backend doesn't require it, the signal socketpair code does.
*/
/* check if this event mechanism requires reinit */
if (!evsel->need_reinit)
return (0);
222#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_INSERTED0x02);
if (base->sig.ev_signal.ev_flags & EVLIST_ACTIVE0x08)
	event_queue_remove(base, &base->sig.ev_signal,
	    EVLIST_ACTIVE0x08);
base->sig.ev_signal_added = 0;
}

if (base->evsel->dealloc != NULL((void *)0))
base->evsel->dealloc(base, base->evbase);
evbase = base->evbase = evsel->init(base);
if (base->evbase == NULL((void *)0))
event_errx(1, "%s: could not reinitialize event mechanism",
    __func__);

TAILQ_FOREACH(ev, &base->eventqueue, ev_next)for((ev) = ((&base->eventqueue)->tqh_first); (ev) !=
 ((void *)0); (ev) = ((ev)->ev_next.tqe_next)) {
if (evsel->add(evbase, ev) == -1)
	res = -1;
}

return (res);
249}

251int
252event_priority_init(int npriorities)
253{
return event_base_priority_init(current_base, npriorities);
1
Calling 'event_base_priority_init'→
255}

257int
258event_base_priority_init(struct event_base *base, int npriorities)
259{
int i;

if (base->event_count_active)
2
←
Assuming field 'event_count_active' is 0→
3
←
Taking false branch→
return (-1);

if (npriorities == base->nactivequeues)
4
←
Assuming 'npriorities' is not equal to field 'nactivequeues'→
5
←
Taking false branch→
return (0);

if (base->nactivequeues) {
6
←
Assuming field 'nactivequeues' is 0→
7
←
Taking false branch→
for (i = 0; i < base->nactivequeues; ++i) {
	free(base->activequeues[i]);
}
free(base->activequeues);
}

/* Allocate our priority queues */
base->nactivequeues = npriorities;
base->activequeues = (struct event_list **)
8
←
Value assigned to field 'activequeues'→
   calloc(base->nactivequeues, sizeof(struct event_list *));
if (base->activequeues == NULL((void *)0))
9
←
Assuming field 'activequeues' is equal to NULL→
10
←
Assuming pointer value is null→
11
←
Taking true branch→
event_err(1, "%s: calloc", __func__);

for (i = 0; i < base->nactivequeues; ++i) {
12
←
Assuming 'i' is < field 'nactivequeues'→
13
←
Loop condition is true.  Entering loop body→
base->activequeues[i] = malloc(sizeof(struct event_list));
14
←
Array access (via field 'activequeues') results in a null pointer dereference
if (base->activequeues[i] == NULL((void *)0))
	event_err(1, "%s: malloc", __func__);
TAILQ_INIT(base->activequeues[i])do { (base->activequeues[i])->tqh_first = ((void *)0); (
base->activequeues[i])->tqh_last = &(base->activequeues
[i])->tqh_first; } while (0);
}

return (0);
290}

292int
293event_haveevents(struct event_base *base)
294{
return (base->event_count > 0);
296}

298/*
* Active events are stored in priority queues.  Lower priorities are always
* process before higher priorities.  Low priority events can starve high
* priority ones.
*/

304static void
305event_process_active(struct event_base *base)
306{
struct event *ev;
struct event_list *activeq = NULL((void *)0);
int i;
short ncalls;

for (i = 0; i < base->nactivequeues; ++i) {
if (TAILQ_FIRST(base->activequeues[i])((base->activequeues[i])->tqh_first) != NULL((void *)0)) {
	activeq = base->activequeues[i];
	break;
}
}

assert(activeq != NULL)((void)0);

for (ev = TAILQ_FIRST(activeq)((activeq)->tqh_first); ev; ev = TAILQ_FIRST(activeq)((activeq)->tqh_first)) {
if (ev->ev_events & EV_PERSIST0x10)
	event_queue_remove(base, ev, EVLIST_ACTIVE0x08);
else
	event_del(ev);

/* Allows deletes to work */
ncalls = ev->ev_ncalls;
ev->ev_pncalls = &ncalls;
while (ncalls) {
	ncalls--;
	ev->ev_ncalls = ncalls;
	(*ev->ev_callback)((int)ev->ev_fd, ev->ev_res, ev->ev_arg);
	if (event_gotsig || base->event_break)
		return;
}
}
338}

340/*
* Wait continously for events.  We exit only if no events are left.
*/

344int
345event_dispatch(void)
346{
return (event_loop(0));
348}

350int
351event_base_dispatch(struct event_base *event_base)
352{
return (event_base_loop(event_base, 0));
354}

356const char *
357event_base_get_method(struct event_base *base)
358{
assert(base)((void)0);
return (base->evsel->name);
361}

363static void
364event_loopexit_cb(int fd, short what, void *arg)
365{
struct event_base *base = arg;
base->event_gotterm = 1;
368}

370/* not thread safe */
371int
372event_loopexit(const struct timeval *tv)
373{
return (event_once(-1, EV_TIMEOUT0x01, event_loopexit_cb,
    current_base, tv));
376}

378int
379event_base_loopexit(struct event_base *event_base, const struct timeval *tv)
380{
return (event_base_once(event_base, -1, EV_TIMEOUT0x01, event_loopexit_cb,
    event_base, tv));
383}

385/* not thread safe */
386int
387event_loopbreak(void)
388{
return (event_base_loopbreak(current_base));
390}

392int
393event_base_loopbreak(struct event_base *event_base)
394{
if (event_base == NULL((void *)0))
return (-1);

event_base->event_break = 1;
return (0);
400}



404/* not thread safe */

406int
407event_loop(int flags)
408{
return event_base_loop(current_base, flags);
410}

412int
413event_base_loop(struct event_base *base, int flags)
414{
const struct eventop *evsel = base->evsel;
void *evbase = base->evbase;
struct timeval tv;
struct timeval *tv_p;
int res, done;

/* clear time cache */
base->tv_cache.tv_sec = 0;

if (base->sig.ev_signal_added)
evsignal_base = base;
done = 0;
while (!done) {
/* Terminate the loop if we have been asked to */
if (base->event_gotterm) {
	base->event_gotterm = 0;
	break;
}

if (base->event_break) {
	base->event_break = 0;
	break;
}

/* You cannot use this interface for multi-threaded apps */
while (event_gotsig) {
	event_gotsig = 0;
	if (event_sigcb) {
		res = (*event_sigcb)();
		if (res == -1) {
			errno(*__errno()) = EINTR4;
			return (-1);
		}
	}
}

tv_p = &tv;
if (!base->event_count_active && !(flags & EVLOOP_NONBLOCK0x02)) {
	timeout_next(base, &tv_p);
} else {
	/*
	 * if we have active events, we just poll new events
	 * without waiting.
	 */
	timerclear(&tv)(&tv)->tv_sec = (&tv)->tv_usec = 0;
}

/* If we have no events, we just exit */
if (!event_haveevents(base)) {
	event_debug(("%s: no events registered.", __func__))do {;} while (0);
	return (1);
}

/* update last old time */
gettime(base, &base->event_tv);

/* clear time cache */
base->tv_cache.tv_sec = 0;

res = evsel->dispatch(base, evbase, tv_p);

if (res == -1)
	return (-1);
gettime(base, &base->tv_cache);

timeout_process(base);

if (base->event_count_active) {
	event_process_active(base);
	if (!base->event_count_active && (flags & EVLOOP_ONCE0x01))
		done = 1;
} else if (flags & EVLOOP_NONBLOCK0x02)
	done = 1;
}

/* clear time cache */
base->tv_cache.tv_sec = 0;

event_debug(("%s: asked to terminate loop.", __func__))do {;} while (0);
return (0);
495}

497/* Sets up an event for processing once */

499struct event_once {
struct event ev;

void (*cb)(int, short, void *);
void *arg;
504};

506/* One-time callback, it deletes itself */

508static void
509event_once_cb(int fd, short events, void *arg)
510{
struct event_once *eonce = arg;

(*eonce->cb)(fd, events, eonce->arg);
free(eonce);
515}

517/* not threadsafe, event scheduled once. */
518int
519event_once(int fd, short events,
  void (*callback)(int, short, void *), void *arg, const struct timeval *tv)
521{
return event_base_once(current_base, fd, events, callback, arg, tv);
523}

525/* Schedules an event once */
526int
527event_base_once(struct event_base *base, int fd, short events,
  void (*callback)(int, short, void *), void *arg, const struct timeval *tv)
529{
struct event_once *eonce;
struct timeval etv;
int res;

/* We cannot support signals that just fire once */
if (events & EV_SIGNAL0x08)
return (-1);

if ((eonce = calloc(1, sizeof(struct event_once))) == NULL((void *)0))
return (-1);

eonce->cb = callback;
eonce->arg = arg;

if (events == EV_TIMEOUT0x01) {
if (tv == NULL((void *)0)) {
	timerclear(&etv)(&etv)->tv_sec = (&etv)->tv_usec = 0;
	tv = &etv;
}

evtimer_set(&eonce->ev, event_once_cb, eonce)event_set(&eonce->ev, -1, 0, event_once_cb, eonce);
} else if (events & (EV_READ0x02|EV_WRITE0x04)) {
events &= EV_READ0x02|EV_WRITE0x04;

event_set(&eonce->ev, fd, events, event_once_cb, eonce);
} else {
/* Bad event combination */
free(eonce);
return (-1);
}

res = event_base_set(base, &eonce->ev);
if (res == 0)
res = event_add(&eonce->ev, tv);
if (res != 0) {
free(eonce);
return (res);
}

return (0);
570}

572void
573event_set(struct event *ev, int fd, short events,
 void (*callback)(int, short, void *), void *arg)
575{
/* Take the current base - caller needs to set the real base later */
ev->ev_base = current_base;

ev->ev_callback = callback;
ev->ev_arg = arg;
ev->ev_fd = fd;
ev->ev_events = events;
ev->ev_res = 0;
ev->ev_flags = EVLIST_INIT0x80;
ev->ev_ncalls = 0;
ev->ev_pncalls = NULL((void *)0);

min_heap_elem_init(ev);

/* by default, we put new events into the middle priority */
if(current_base)
ev->ev_pri = current_base->nactivequeues/2;
593}

595int
596event_base_set(struct event_base *base, struct event *ev)
597{
/* Only innocent events may be assigned to a different base */
if (ev->ev_flags != EVLIST_INIT0x80)
return (-1);

ev->ev_base = base;
ev->ev_pri = base->nactivequeues/2;

return (0);
606}

608/*
* Set's the priority of an event - if an event is already scheduled
* changing the priority is going to fail.
*/

613int
614event_priority_set(struct event *ev, int pri)
615{
if (ev->ev_flags & EVLIST_ACTIVE0x08)
return (-1);
if (pri < 0 || pri >= ev->ev_base->nactivequeues)
return (-1);

ev->ev_pri = pri;

return (0);
624}

626/*
* Checks if a specific event is pending or scheduled.
*/

630int
631event_pending(struct event *ev, short event, struct timeval *tv)
632{
struct timeval	now, res;
int flags = 0;

if (ev->ev_flags & EVLIST_INSERTED0x02)
flags |= (ev->ev_events & (EV_READ0x02|EV_WRITE0x04|EV_SIGNAL0x08));
if (ev->ev_flags & EVLIST_ACTIVE0x08)
flags |= ev->ev_res;
if (ev->ev_flags & EVLIST_TIMEOUT0x01)
flags |= EV_TIMEOUT0x01;

event &= (EV_TIMEOUT0x01|EV_READ0x02|EV_WRITE0x04|EV_SIGNAL0x08);

/* See if there is a timeout that we should report */
if (tv != NULL((void *)0) && (flags & event & EV_TIMEOUT0x01)) {
gettime(ev->ev_base, &now);
timersub(&ev->ev_timeout, &now, &res)do { (&res)->tv_sec = (&ev->ev_timeout)->tv_sec
 - (&now)->tv_sec; (&res)->tv_usec = (&ev->
ev_timeout)->tv_usec - (&now)->tv_usec; if ((&res
)->tv_usec < 0) { (&res)->tv_sec--; (&res)->
tv_usec += 1000000; } } while (0);
/* correctly remap to real time */
gettimeofday(&now, NULL((void *)0));
timeradd(&now, &res, tv)do { (tv)->tv_sec = (&now)->tv_sec + (&res)->
tv_sec; (tv)->tv_usec = (&now)->tv_usec + (&res
)->tv_usec; if ((tv)->tv_usec >= 1000000) { (tv)->
tv_sec++; (tv)->tv_usec -= 1000000; } } while (0);
}

return (flags & event);
655}

657int
658event_add(struct event *ev, const struct timeval *tv)
659{
struct event_base *base = ev->ev_base;
const struct eventop *evsel = base->evsel;
void *evbase = base->evbase;
int res = 0;

event_debug((do {;} while (0)
 "event_add: event: %p, %s%s%scall %p",do {;} while (0)
 ev,do {;} while (0)
 ev->ev_events & EV_READ ? "EV_READ " : " ",do {;} while (0)
 ev->ev_events & EV_WRITE ? "EV_WRITE " : " ",do {;} while (0)
 tv ? "EV_TIMEOUT " : " ",do {;} while (0)
 ev->ev_callback))do {;} while (0);

assert(!(ev->ev_flags & ~EVLIST_ALL))((void)0);

/*
* prepare for timeout insertion further below, if we get a
* failure on any step, we should not change any state.
*/
if (tv != NULL((void *)0) && !(ev->ev_flags & EVLIST_TIMEOUT0x01)) {
if (min_heap_reserve(&base->timeheap,
	1 + min_heap_size(&base->timeheap)) == -1)
	return (-1);  /* ENOMEM == errno */
}

if ((ev->ev_events & (EV_READ0x02|EV_WRITE0x04|EV_SIGNAL0x08)) &&
   !(ev->ev_flags & (EVLIST_INSERTED0x02|EVLIST_ACTIVE0x08))) {
res = evsel->add(evbase, ev);
if (res != -1)
	event_queue_insert(base, ev, EVLIST_INSERTED0x02);
}

/*
* we should change the timout state only if the previous event
* addition succeeded.
*/
if (res != -1 && tv != NULL((void *)0)) {
struct timeval now;

/*
 * we already reserved memory above for the case where we
 * are not replacing an exisiting timeout.
 */
if (ev->ev_flags & EVLIST_TIMEOUT0x01)
	event_queue_remove(base, ev, EVLIST_TIMEOUT0x01);

/* Check if it is active due to a timeout.  Rescheduling
 * this timeout before the callback can be executed
 * removes it from the active list. */
if ((ev->ev_flags & EVLIST_ACTIVE0x08) &&
    (ev->ev_res & EV_TIMEOUT0x01)) {
	/* See if we are just active executing this
	 * event in a loop
	 */
	if (ev->ev_ncalls && ev->ev_pncalls) {
		/* Abort loop */
		*ev->ev_pncalls = 0;
	}

	event_queue_remove(base, ev, EVLIST_ACTIVE0x08);
}

gettime(base, &now);
timeradd(&now, tv, &ev->ev_timeout)do { (&ev->ev_timeout)->tv_sec = (&now)->tv_sec
 + (tv)->tv_sec; (&ev->ev_timeout)->tv_usec = (&
now)->tv_usec + (tv)->tv_usec; if ((&ev->ev_timeout
)->tv_usec >= 1000000) { (&ev->ev_timeout)->tv_sec
++; (&ev->ev_timeout)->tv_usec -= 1000000; } } while
 (0);

event_debug((do {;} while (0)
	 "event_add: timeout in %lld seconds, call %p",do {;} while (0)
	 (long long)tv->tv_sec, ev->ev_callback))do {;} while (0);

event_queue_insert(base, ev, EVLIST_TIMEOUT0x01);
}

return (res);
733}

735int
736event_del(struct event *ev)
737{
struct event_base *base;
const struct eventop *evsel;
void *evbase;

event_debug(("event_del: %p, callback %p",do {;} while (0)
 ev, ev->ev_callback))do {;} while (0);

/* An event without a base has not been added */
if (ev->ev_base == NULL((void *)0))
return (-1);

base = ev->ev_base;
evsel = base->evsel;
evbase = base->evbase;

assert(!(ev->ev_flags & ~EVLIST_ALL))((void)0);

/* See if we are just active executing this event in a loop */
if (ev->ev_ncalls && ev->ev_pncalls) {
/* Abort loop */
*ev->ev_pncalls = 0;
}

if (ev->ev_flags & EVLIST_TIMEOUT0x01)
event_queue_remove(base, ev, EVLIST_TIMEOUT0x01);

if (ev->ev_flags & EVLIST_ACTIVE0x08)
event_queue_remove(base, ev, EVLIST_ACTIVE0x08);

if (ev->ev_flags & EVLIST_INSERTED0x02) {
event_queue_remove(base, ev, EVLIST_INSERTED0x02);
return (evsel->del(evbase, ev));
}

return (0);
773}

775void
776event_active(struct event *ev, int res, short ncalls)
777{
/* We get different kinds of events, add them together */
if (ev->ev_flags & EVLIST_ACTIVE0x08) {
ev->ev_res |= res;
return;
}

ev->ev_res = res;
ev->ev_ncalls = ncalls;
ev->ev_pncalls = NULL((void *)0);
event_queue_insert(ev->ev_base, ev, EVLIST_ACTIVE0x08);
788}

790static int
791timeout_next(struct event_base *base, struct timeval **tv_p)
792{
struct timeval now;
struct event *ev;
struct timeval *tv = *tv_p;

if ((ev = min_heap_top(&base->timeheap)) == NULL((void *)0)) {
/* if no time-based events are active wait for I/O */
*tv_p = NULL((void *)0);
return (0);
}

gettime(base, &now);

if (timercmp(&ev->ev_timeout, &now, <=)(((&ev->ev_timeout)->tv_sec == (&now)->tv_sec
) ? ((&ev->ev_timeout)->tv_usec <= (&now)->
tv_usec) : ((&ev->ev_timeout)->tv_sec <= (&now
)->tv_sec))) {
timerclear(tv)(tv)->tv_sec = (tv)->tv_usec = 0;
return (0);
}

timersub(&ev->ev_timeout, &now, tv)do { (tv)->tv_sec = (&ev->ev_timeout)->tv_sec - (
&now)->tv_sec; (tv)->tv_usec = (&ev->ev_timeout
)->tv_usec - (&now)->tv_usec; if ((tv)->tv_usec <
 0) { (tv)->tv_sec--; (tv)->tv_usec += 1000000; } } while
 (0);

assert(tv->tv_sec >= 0)((void)0);
assert(tv->tv_usec >= 0)((void)0);

event_debug(("timeout_next: in %lld seconds", (long long)tv->tv_sec))do {;} while (0);
return (0);
817}

819void
820timeout_process(struct event_base *base)
821{
struct timeval now;
struct event *ev;

if (min_heap_empty(&base->timeheap))
return;

gettime(base, &now);

while ((ev = min_heap_top(&base->timeheap))) {
if (timercmp(&ev->ev_timeout, &now, >)(((&ev->ev_timeout)->tv_sec == (&now)->tv_sec
) ? ((&ev->ev_timeout)->tv_usec > (&now)->
tv_usec) : ((&ev->ev_timeout)->tv_sec > (&now
)->tv_sec)))
	break;

/* delete this event from the I/O queues */
event_del(ev);

event_debug(("timeout_process: call %p",do {;} while (0)
	 ev->ev_callback))do {;} while (0);
event_active(ev, EV_TIMEOUT0x01, 1);
}
841}

843void
844event_queue_remove(struct event_base *base, struct event *ev, int queue)
845{
if (!(ev->ev_flags & queue))
event_errx(1, "%s: %p(fd %d) not on queue %x", __func__,
	   ev, ev->ev_fd, queue);

if (~ev->ev_flags & EVLIST_INTERNAL0x10)
base->event_count--;

ev->ev_flags &= ~queue;
switch (queue) {
case EVLIST_INSERTED0x02:
TAILQ_REMOVE(&base->eventqueue, ev, ev_next)do { if (((ev)->ev_next.tqe_next) != ((void *)0)) (ev)->
ev_next.tqe_next->ev_next.tqe_prev = (ev)->ev_next.tqe_prev
; else (&base->eventqueue)->tqh_last = (ev)->ev_next
.tqe_prev; *(ev)->ev_next.tqe_prev = (ev)->ev_next.tqe_next
; ; ; } while (0);
break;
case EVLIST_ACTIVE0x08:
base->event_count_active--;
TAILQ_REMOVE(base->activequeues[ev->ev_pri],do { if (((ev)->ev_active_next.tqe_next) != ((void *)0)) (
ev)->ev_active_next.tqe_next->ev_active_next.tqe_prev =
 (ev)->ev_active_next.tqe_prev; else (base->activequeues
[ev->ev_pri])->tqh_last = (ev)->ev_active_next.tqe_prev
; *(ev)->ev_active_next.tqe_prev = (ev)->ev_active_next
.tqe_next; ; ; } while (0)
    ev, ev_active_next)do { if (((ev)->ev_active_next.tqe_next) != ((void *)0)) (
ev)->ev_active_next.tqe_next->ev_active_next.tqe_prev =
 (ev)->ev_active_next.tqe_prev; else (base->activequeues
[ev->ev_pri])->tqh_last = (ev)->ev_active_next.tqe_prev
; *(ev)->ev_active_next.tqe_prev = (ev)->ev_active_next
.tqe_next; ; ; } while (0);
break;
case EVLIST_TIMEOUT0x01:
min_heap_erase(&base->timeheap, ev);
break;
default:
event_errx(1, "%s: unknown queue %x", __func__, queue);
}
869}

871void
872event_queue_insert(struct event_base *base, struct event *ev, int queue)
873{
if (ev->ev_flags & queue) {
/* Double insertion is possible for active events */
if (queue & EVLIST_ACTIVE0x08)
	return;

event_errx(1, "%s: %p(fd %d) already on queue %x", __func__,
	   ev, ev->ev_fd, queue);
}

if (~ev->ev_flags & EVLIST_INTERNAL0x10)
base->event_count++;

ev->ev_flags |= queue;
switch (queue) {
case EVLIST_INSERTED0x02:
TAILQ_INSERT_TAIL(&base->eventqueue, ev, ev_next)do { (ev)->ev_next.tqe_next = ((void *)0); (ev)->ev_next
.tqe_prev = (&base->eventqueue)->tqh_last; *(&base
->eventqueue)->tqh_last = (ev); (&base->eventqueue
)->tqh_last = &(ev)->ev_next.tqe_next; } while (0);
break;
case EVLIST_ACTIVE0x08:
base->event_count_active++;
TAILQ_INSERT_TAIL(base->activequeues[ev->ev_pri],do { (ev)->ev_active_next.tqe_next = ((void *)0); (ev)->
ev_active_next.tqe_prev = (base->activequeues[ev->ev_pri
])->tqh_last; *(base->activequeues[ev->ev_pri])->
tqh_last = (ev); (base->activequeues[ev->ev_pri])->tqh_last
 = &(ev)->ev_active_next.tqe_next; } while (0)
    ev,ev_active_next)do { (ev)->ev_active_next.tqe_next = ((void *)0); (ev)->
ev_active_next.tqe_prev = (base->activequeues[ev->ev_pri
])->tqh_last; *(base->activequeues[ev->ev_pri])->
tqh_last = (ev); (base->activequeues[ev->ev_pri])->tqh_last
 = &(ev)->ev_active_next.tqe_next; } while (0);
break;
case EVLIST_TIMEOUT0x01: {
min_heap_push(&base->timeheap, ev);
break;
}
default:
event_errx(1, "%s: unknown queue %x", __func__, queue);
}
903}

905/* Functions for debugging */

907const char *
908event_get_version(void)
909{
return (_EVENT_VERSION"1.4.15-stable");
911}

913/*
* No thread-safe interface needed - the information should be the same
* for all threads.
*/

918const char *
919event_get_method(void)
920{
return (current_base->evsel->name);
922}


925/*
* Libevent glue for ASR.
*/
928struct event_asr {
struct event	 ev;
struct asr_query *async;
void		(*cb)(struct asr_result *, void *);
void		*arg;
933};

935static void
936event_asr_dispatch(int fd __attribute__((__unused__)),
  short ev __attribute__((__unused__)), void *arg)
938{
struct event_asr	*eva = arg;
struct asr_result	 ar;
struct timeval		 tv;

event_del(&eva->ev);

if (asr_run(eva->async, &ar)) {
eva->cb(&ar, eva->arg);
free(eva);
} else {
event_set(&eva->ev, ar.ar_fd,
    ar.ar_cond == ASR_WANT_READ1 ? EV_READ0x02 : EV_WRITE0x04,
    event_asr_dispatch, eva);
tv.tv_sec = ar.ar_timeout / 1000;
tv.tv_usec = (ar.ar_timeout % 1000) * 1000;
event_add(&eva->ev, &tv);
}
956}

958struct event_asr *
959event_asr_run(struct asr_query *async, void (*cb)(struct asr_result *, void *),
  void *arg)
961{
struct event_asr *eva;
struct timeval tv;

eva = calloc(1, sizeof *eva);
if (eva == NULL((void *)0))
return (NULL((void *)0));
eva->async = async;
eva->cb = cb;
eva->arg = arg;
tv.tv_sec = 0;
tv.tv_usec = 0;
evtimer_set(&eva->ev, event_asr_dispatch, eva)event_set(&eva->ev, -1, 0, event_asr_dispatch, eva);
evtimer_add(&eva->ev, &tv)event_add(&eva->ev, &tv);
return (eva);
976}

978void
979event_asr_abort(struct event_asr *eva)
980{
asr_abort(eva->async);
event_del(&eva->ev);
free(eva);
984}