posix: upgrade libevent from 1.4.7 to 1.4.13

third_party/libevent/event.c

 /*
  * 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
@@ skipping 19 matching lines @@
 
 #ifdef WIN32
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #undef WIN32_LEAN_AND_MEAN
 #endif
 #include <sys/types.h>
 #ifdef HAVE_SYS_TIME_H
 #include <sys/time.h>
 #else 
-#include <sys/_time.h>
+#include <sys/_libevent_time.h>
 #endif
 #include <sys/queue.h>
 #include <stdio.h>
 #include <stdlib.h>
 #ifndef WIN32
 #include <unistd.h>
 #endif
 #include <errno.h>
 #include <signal.h>
 #include <string.h>
@@ skipping 21 matching lines @@
 extern const struct eventop kqops;
 #endif
 #ifdef HAVE_DEVPOLL
 extern const struct eventop devpollops;
 #endif
 #ifdef WIN32
 extern const struct eventop win32ops;
 #endif
 
 /* In order of preference */
-const struct eventop *eventops[] = {
+static const struct eventop *eventops[] = {
 #ifdef HAVE_EVENT_PORTS
         &evportops,
 #endif
 #ifdef HAVE_WORKING_KQUEUE
         &kqops,
 #endif
 #ifdef HAVE_EPOLL
         &epollops,
 #endif
 #ifdef HAVE_DEVPOLL
         &devpollops,
 #endif
 #ifdef HAVE_POLL
         &pollops,
 #endif
 #ifdef HAVE_SELECT
         &selectops,
 #endif
 #ifdef WIN32
         &win32ops,
 #endif
         NULL
 };
 
 /* Global state */
 struct event_base *current_base = NULL;
 extern struct event_base *evsignal_base;
 static int use_monotonic;
-static int use_monotonic_initialized;
 
 /* Prototypes */
 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 void     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 void
 detect_monotonic(void)
 {
 #if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
-        if (use_monotonic_initialized)
-                return;
-
         struct timespec ts;
 
         if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
                 use_monotonic = 1;
-        use_monotonic_initialized = 1;
 #endif
 }
 
 static int
 gettime(struct event_base *base, struct timeval *tp)
 {
         if (base->tv_cache.tv_sec) {
                 *tp = base->tv_cache;
                 return (0);
         }
@@ skipping 45 matching lines @@
         base->evbase = NULL;
         for (i = 0; eventops[i] && !base->evbase; i++) {
                 base->evsel = eventops[i];
 
                 base->evbase = base->evsel->init(base);
         }
 
         if (base->evbase == NULL)
                 event_errx(1, "%s: no event mechanism available", __func__);
 
-        if (getenv("EVENT_SHOW_METHOD")) 
+        if (evutil_getenv("EVENT_SHOW_METHOD")) 
                 event_msgx("libevent using: %s\n",
                            base->evsel->name);
 
         /* allocate a single active event queue */
         event_base_priority_init(base, 1);
 
         return (base);
 }
 
 void
@@ skipping 64 matching lines @@
         void *evbase = base->evbase;
         int res = 0;
         struct event *ev;
 
         /* check if this event mechanism requires reinit */
         if (!evsel->need_reinit)
                 return (0);
 
         /* 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);
                 base->sig.ev_signal_added = 0;
         }
         
         if (base->evsel->dealloc != NULL)
                 base->evsel->dealloc(base, base->evbase);
         evbase = base->evbase = evsel->init(base);
         if (base->evbase == NULL)
                 event_errx(1, "%s: could not reinitialize event mechanism",
                     __func__);
 
@@ skipping 21 matching lines @@
 
         if (base->nactivequeues && npriorities != base->nactivequeues) {
                 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 **)calloc(base->nactivequeues,
-            npriorities * sizeof(struct event_list *));
+        base->activequeues = (struct event_list **)
+            calloc(base->nactivequeues, sizeof(struct event_list *));
         if (base->activequeues == NULL)
                 event_err(1, "%s: calloc", __func__);
 
         for (i = 0; i < base->nactivequeues; ++i) {
                 base->activequeues[i] = malloc(sizeof(struct event_list));
                 if (base->activequeues[i] == NULL)
                         event_err(1, "%s: malloc", __func__);
                 TAILQ_INIT(base->activequeues[i]);
         }
 
@@ skipping 122 matching lines @@
 
 int
 event_base_loop(struct event_base *base, int flags)
 {
         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;
                 }
 
@@ skipping 36 matching lines @@
                 timeout_process(base);
 
                 if (base->event_count_active) {
                         event_process_active(base);
                         if (!base->event_count_active && (flags & EVLOOP_ONCE))
                                 done = 1;
                 } else if (flags & EVLOOP_NONBLOCK)
                         done = 1;
         }
 
+        /* clear time cache */
+        base->tv_cache.tv_sec = 0;
+
         event_debug(("%s: asked to terminate loop.", __func__));
         return (0);
 }
 
 /* Sets up an event for processing once */
 
 struct event_once {
         struct event ev;
 
         void (*cb)(int, short, void *);
@@ skipping 219 matching lines @@
                 gettime(base, &now);
                 evutil_timeradd(&now, tv, &ev->ev_timeout);
 
                 event_debug((
                          "event_add: timeout in %ld seconds, call %p",
                          tv->tv_sec, ev->ev_callback));
 
                 event_queue_insert(base, ev, EVLIST_TIMEOUT);
         }
 
-        return (0);
+        return (res);
 }
 
 int
 event_del(struct event *ev)
 {
         struct event_base *base;
         const struct eventop *evsel;
         void *evbase;
 
         event_debug(("event_del: %p, callback %p",
@@ skipping 104 matching lines @@
         /*
          * We can modify the key element of the node without destroying
          * the key, beause we apply it to all in the right order.
          */
         pev = base->timeheap.p;
         size = base->timeheap.n;
         for (; size-- > 0; ++pev) {
                 struct timeval *ev_tv = &(**pev).ev_timeout;
                 evutil_timersub(ev_tv, &off, ev_tv);
         }
+        /* Now remember what the new time turned out to be. */
+        base->event_tv = *tv;
 }
 
 void
 timeout_process(struct event_base *base)
 {
         struct timeval now;
         struct event *ev;
 
         if (min_heap_empty(&base->timeheap))
                 return;
@@ skipping 86 matching lines @@
 /* 
  * No thread-safe interface needed - the information should be the same
  * for all threads.
  */
 
 const char *
 event_get_method(void)
 {
         return (current_base->evsel->name);
 }