]> granicus.if.org Git - libevent/commitdiff
Merge remote-tracking branch 'github/20_win64_compilation' into 21_win64_compilation
authorNick Mathewson <nickm@torproject.org>
Thu, 1 Nov 2012 22:12:07 +0000 (18:12 -0400)
committerNick Mathewson <nickm@torproject.org>
Thu, 1 Nov 2012 22:12:07 +0000 (18:12 -0400)
Conflicts:
event.c
http.c
sample/event-read-fifo.c
test/regress_bufferevent.c

20 files changed:
1  2 
event.c
http.c
sample/event-read-fifo.c
sample/signal-test.c
sample/time-test.c
test/bench.c
test/bench_cascade.c
test/regress_bufferevent.c
test/regress_dns.c
test/regress_main.c
test/regress_ssl.c
test/regress_util.c
test/regress_zlib.c
test/test-changelist.c
test/test-eof.c
test/test-init.c
test/test-ratelim.c
test/test-time.c
test/test-weof.c
util-internal.h

diff --cc event.c
index c209213a117e2c710faac78620b31fa0fc0ef356,91cb0cce37ba2ff276169306a59405fc8fc23c73..62744f80a178721d70847990867684e4fe91e82f
+++ b/event.c
@@@ -257,13 -238,14 +257,14 @@@ HT_GENERATE(event_debug_map, event_debu
                if (dent) {                                             \
                        dent->added = 1;                                \
                } else {                                                \
 -                      event_errx(_EVENT_ERR_ABORT,                    \
 +                      event_errx(EVENT_ERR_ABORT_,                    \
                            "%s: noting an add on a non-setup event %p" \
-                           " (events: 0x%x, fd: %d, flags: 0x%x)",     \
+                           " (events: 0x%x, fd: "EV_SOCK_FMT           \
+                           ", flags: 0x%x)",                           \
                            __func__, (ev), (ev)->ev_events,            \
-                           (ev)->ev_fd, (ev)->ev_flags);               \
+                           EV_SOCK_ARG((ev)->ev_fd), (ev)->ev_flags);  \
                }                                                       \
 -              EVLOCK_UNLOCK(_event_debug_map_lock, 0);                \
 +              EVLOCK_UNLOCK(event_debug_map_lock_, 0);                \
        }                                                               \
        event_debug_mode_too_late = 1;                                  \
        } while (0)
                if (dent) {                                             \
                        dent->added = 0;                                \
                } else {                                                \
 -                      event_errx(_EVENT_ERR_ABORT,                    \
 +                      event_errx(EVENT_ERR_ABORT_,                    \
                            "%s: noting a del on a non-setup event %p"  \
-                           " (events: 0x%x, fd: %d, flags: 0x%x)",     \
+                           " (events: 0x%x, fd: "EV_SOCK_FMT           \
+                           ", flags: 0x%x)",                           \
                            __func__, (ev), (ev)->ev_events,            \
-                           (ev)->ev_fd, (ev)->ev_flags);               \
+                           EV_SOCK_ARG((ev)->ev_fd), (ev)->ev_flags);  \
                }                                                       \
 -              EVLOCK_UNLOCK(_event_debug_map_lock, 0);                \
 +              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) {                                     \
 +#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);                  \
 +              EVLOCK_LOCK(event_debug_map_lock_, 0);                  \
                dent = HT_FIND(event_debug_map, &global_debug_map, &find); \
                if (!dent) {                                            \
 -                      event_errx(_EVENT_ERR_ABORT,                    \
 +                      event_errx(EVENT_ERR_ABORT_,                    \
                            "%s called on a non-initialized event %p"   \
-                           " (events: 0x%x, fd: %d, flags: 0x%x)",     \
+                           " (events: 0x%x, fd: "EV_SOCK_FMT\
+                           ", flags: 0x%x)",                           \
                            __func__, (ev), (ev)->ev_events,            \
-                           (ev)->ev_fd, (ev)->ev_flags);               \
+                           EV_SOCK_ARG((ev)->ev_fd), (ev)->ev_flags);  \
                }                                                       \
 -              EVLOCK_UNLOCK(_event_debug_map_lock, 0);                \
 +              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) {                                     \
 +#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);                  \
 +              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,                    \
 +                      event_errx(EVENT_ERR_ABORT_,                    \
                            "%s called on an already added event %p"    \
-                           " (events: 0x%x, fd: %d, flags: 0x%x)",     \
+                           " (events: 0x%x, fd: "EV_SOCK_FMT", "       \
+                           "flags: 0x%x)",                             \
                            __func__, (ev), (ev)->ev_events,            \
-                           (ev)->ev_fd, (ev)->ev_flags);               \
+                           EV_SOCK_ARG((ev)->ev_fd), (ev)->ev_flags);  \
                }                                                       \
 -              EVLOCK_UNLOCK(_event_debug_map_lock, 0);                \
 +              EVLOCK_UNLOCK(event_debug_map_lock_, 0);                \
        }                                                               \
        } while (0)
  #else
@@@ -2186,12 -2027,12 +2190,12 @@@ event_add_nolock_(struct event *ev, con
        int notify = 0;
  
        EVENT_BASE_ASSERT_LOCKED(base);
 -      _event_debug_assert_is_setup(ev);
 +      event_debug_assert_is_setup_(ev);
  
        event_debug((
-                "event_add: event: %p (fd %d), %s%s%scall %p",
+                "event_add: event: %p (fd "EV_SOCK_FMT"), %s%s%scall %p",
                 ev,
-                (int)ev->ev_fd,
+                EV_SOCK_ARG(ev->ev_fd),
                 ev->ev_events & EV_READ ? "EV_READ " : " ",
                 ev->ev_events & EV_WRITE ? "EV_WRITE " : " ",
                 tv ? "EV_TIMEOUT " : " ",
@@@ -2457,29 -2285,22 +2461,29 @@@ event_active_nolock_(struct event *ev, 
  {
        struct event_base *base;
  
-       event_debug(("event_active: %p (fd %d), res %d, callback %p",
-               ev, (int)ev->ev_fd, (int)res, ev->ev_callback));
+       event_debug(("event_active: %p (fd "EV_SOCK_FMT"), res %d, callback %p",
+               ev, EV_SOCK_ARG(ev->ev_fd), (int)res, ev->ev_callback));
  
 +      base = ev->ev_base;
 +      EVENT_BASE_ASSERT_LOCKED(base);
  
 -      /* We get different kinds of events, add them together */
 -      if (ev->ev_flags & EVLIST_ACTIVE) {
 +      switch ((ev->ev_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER))) {
 +      default:
 +      case EVLIST_ACTIVE|EVLIST_ACTIVE_LATER:
 +              EVUTIL_ASSERT(0);
 +              break;
 +      case EVLIST_ACTIVE:
 +              /* We get different kinds of events, add them together */
                ev->ev_res |= res;
                return;
 +      case EVLIST_ACTIVE_LATER:
 +              ev->ev_res |= res;
 +              break;
 +      case 0:
 +              ev->ev_res = res;
 +              break;
        }
  
 -      base = ev->ev_base;
 -
 -      EVENT_BASE_ASSERT_LOCKED(base);
 -
 -      ev->ev_res = res;
 -
        if (ev->ev_pri < base->event_running_priority)
                base->event_continue = 1;
  
@@@ -2718,131 -2485,53 +2722,131 @@@ timeout_process(struct event_base *base
                        break;
  
                /* delete this event from the I/O queues */
 -              event_del_internal(ev);
 +              event_del_nolock_(ev);
 +
 +              event_debug(("timeout_process: event: %p, call %p",
 +                       ev, ev->ev_callback));
 +              event_active_nolock_(ev, EV_TIMEOUT, 1);
 +      }
 +}
  
 -              event_debug(("timeout_process: call %p",
 -                       ev->ev_callback));
 -              event_active_nolock(ev, EV_TIMEOUT, 1);
 +#if (EVLIST_INTERNAL >> 4) != 1
 +#error "Mismatch for value of EVLIST_INTERNAL"
 +#endif
 +/* These are a fancy way to spell
 +     if (flags & EVLIST_INTERNAL)
 +         base->event_count--/++;
 +*/
 +#define DECR_EVENT_COUNT(base,flags) \
 +      ((base)->event_count -= (~((flags) >> 4) & 1))
 +#define INCR_EVENT_COUNT(base,flags) \
 +      ((base)->event_count += (~((flags) >> 4) & 1))
 +
 +static void
 +event_queue_remove_inserted(struct event_base *base, struct event *ev)
 +{
 +      EVENT_BASE_ASSERT_LOCKED(base);
 +      if (EVUTIL_FAILURE_CHECK(!(ev->ev_flags & EVLIST_INSERTED))) {
 +              event_errx(1, "%s: %p(fd %d) not on queue %x", __func__,
 +                         ev, ev->ev_fd, EVLIST_INSERTED);
 +              return;
        }
 +      DECR_EVENT_COUNT(base, ev->ev_flags);
 +      ev->ev_flags &= ~EVLIST_INSERTED;
  }
 +static void
 +event_queue_remove_active(struct event_base *base, struct event_callback *evcb)
 +{
 +      EVENT_BASE_ASSERT_LOCKED(base);
 +      if (EVUTIL_FAILURE_CHECK(!(evcb->evcb_flags & EVLIST_ACTIVE))) {
 +              event_errx(1, "%s: %p not on queue %x", __func__,
 +                         evcb, EVLIST_ACTIVE);
 +              return;
 +      }
 +      DECR_EVENT_COUNT(base, evcb->evcb_flags);
 +      evcb->evcb_flags &= ~EVLIST_ACTIVE;
 +      base->event_count_active--;
  
 -/* Remove 'ev' from 'queue' (EVLIST_...) in base. */
 +      TAILQ_REMOVE(&base->activequeues[evcb->evcb_pri],
 +          evcb, evcb_active_next);
 +}
  static void
 -event_queue_remove(struct event_base *base, struct event *ev, int queue)
 +event_queue_remove_active_later(struct event_base *base, struct event_callback *evcb)
  {
        EVENT_BASE_ASSERT_LOCKED(base);
 +      if (EVUTIL_FAILURE_CHECK(!(evcb->evcb_flags & EVLIST_ACTIVE_LATER))) {
 +              event_errx(1, "%s: %p not on queue %x", __func__,
 +                         evcb, EVLIST_ACTIVE_LATER);
 +              return;
 +      }
 +      DECR_EVENT_COUNT(base, evcb->evcb_flags);
 +      evcb->evcb_flags &= ~EVLIST_ACTIVE_LATER;
 +      base->event_count_active--;
  
 -      if (!(ev->ev_flags & queue)) {
 +      TAILQ_REMOVE(&base->active_later_queue, evcb, evcb_active_next);
 +}
 +static void
 +event_queue_remove_timeout(struct event_base *base, struct event *ev)
 +{
 +      EVENT_BASE_ASSERT_LOCKED(base);
 +      if (EVUTIL_FAILURE_CHECK(!(ev->ev_flags & EVLIST_TIMEOUT))) {
-               event_errx(1, "%s: %p(fd %d) not on queue %x", __func__,
-                          ev, ev->ev_fd, EVLIST_TIMEOUT);
+               event_errx(1, "%s: %p(fd "EV_SOCK_FMT") not on queue %x", __func__,
 -                  ev, EV_SOCK_ARG(ev->ev_fd), queue);
++                  ev, EV_SOCK_ARG(ev->ev_fd), EVLIST_TIMEOUT);
                return;
        }
 +      DECR_EVENT_COUNT(base, ev->ev_flags);
 +      ev->ev_flags &= ~EVLIST_TIMEOUT;
  
 -      if (~ev->ev_flags & EVLIST_INTERNAL)
 -              base->event_count--;
 +      if (is_common_timeout(&ev->ev_timeout, base)) {
 +              struct common_timeout_list *ctl =
 +                  get_common_timeout_list(base, &ev->ev_timeout);
 +              TAILQ_REMOVE(&ctl->events, ev,
 +                  ev_timeout_pos.ev_next_with_common_timeout);
 +      } else {
 +              min_heap_erase_(&base->timeheap, ev);
 +      }
 +}
  
 -      ev->ev_flags &= ~queue;
 -      switch (queue) {
 -      case EVLIST_INSERTED:
 -              TAILQ_REMOVE(&base->eventqueue, ev, ev_next);
 +#ifdef USE_REINSERT_TIMEOUT
 +/* Remove and reinsert 'ev' into the timeout queue. */
 +static void
 +event_queue_reinsert_timeout(struct event_base *base, struct event *ev,
 +    int was_common, int is_common, int old_timeout_idx)
 +{
 +      struct common_timeout_list *ctl;
 +      if (!(ev->ev_flags & EVLIST_TIMEOUT)) {
 +              event_queue_insert_timeout(base, ev);
 +              return;
 +      }
 +
 +      switch ((was_common<<1) | is_common) {
 +      case 3: /* Changing from one common timeout to another */
 +              ctl = base->common_timeout_queues[old_timeout_idx];
 +              TAILQ_REMOVE(&ctl->events, ev,
 +                  ev_timeout_pos.ev_next_with_common_timeout);
 +              ctl = get_common_timeout_list(base, &ev->ev_timeout);
 +              insert_common_timeout_inorder(ctl, ev);
                break;
 -      case EVLIST_ACTIVE:
 -              base->event_count_active--;
 -              TAILQ_REMOVE(&base->activequeues[ev->ev_pri],
 -                  ev, ev_active_next);
 +      case 2: /* Was common; is no longer common */
 +              ctl = base->common_timeout_queues[old_timeout_idx];
 +              TAILQ_REMOVE(&ctl->events, ev,
 +                  ev_timeout_pos.ev_next_with_common_timeout);
 +              min_heap_push_(&base->timeheap, ev);
                break;
 -      case EVLIST_TIMEOUT:
 -              if (is_common_timeout(&ev->ev_timeout, base)) {
 -                      struct common_timeout_list *ctl =
 -                          get_common_timeout_list(base, &ev->ev_timeout);
 -                      TAILQ_REMOVE(&ctl->events, ev,
 -                          ev_timeout_pos.ev_next_with_common_timeout);
 -              } else {
 -                      min_heap_erase(&base->timeheap, ev);
 -              }
 +      case 1: /* Wasn't common; has become common. */
 +              min_heap_erase_(&base->timeheap, ev);
 +              ctl = get_common_timeout_list(base, &ev->ev_timeout);
 +              insert_common_timeout_inorder(ctl, ev);
 +              break;
 +      case 0: /* was in heap; is still on heap. */
 +              min_heap_adjust_(&base->timeheap, ev);
                break;
        default:
 -              event_errx(1, "%s: unknown queue %x", __func__, queue);
 +              EVUTIL_ASSERT(0); /* unreachable */
 +              break;
        }
  }
 +#endif
  
  /* Add 'ev' to the common timeout list in 'ev'. */
  static void
@@@ -2876,23 -2565,7 +2880,23 @@@ insert_common_timeout_inorder(struct co
  }
  
  static void
 -event_queue_insert(struct event_base *base, struct event *ev, int queue)
 +event_queue_insert_inserted(struct event_base *base, struct event *ev)
 +{
 +      EVENT_BASE_ASSERT_LOCKED(base);
 +
 +      if (EVUTIL_FAILURE_CHECK(ev->ev_flags & EVLIST_INSERTED)) {
-               event_errx(1, "%s: %p(fd %d) already inserted", __func__,
-                          ev, ev->ev_fd);
++              event_errx(1, "%s: %p(fd "EV_SOCK_FMT") already inserted", __func__,
++                  ev, EV_SOCK_ARG(ev->ev_fd));
 +              return;
 +      }
 +
 +      INCR_EVENT_COUNT(base, ev->ev_flags);
 +
 +      ev->ev_flags |= EVLIST_INSERTED;
 +}
 +
 +static void
 +event_queue_insert_active(struct event_base *base, struct event_callback *evcb)
  {
        EVENT_BASE_ASSERT_LOCKED(base);
  
@@@ -2920,49 -2579,30 +2924,49 @@@ event_queue_insert_active_later(struct 
                return;
        }
  
 -      if (~ev->ev_flags & EVLIST_INTERNAL)
 -              base->event_count++;
 +      INCR_EVENT_COUNT(base, evcb->evcb_flags);
 +      evcb->evcb_flags |= EVLIST_ACTIVE_LATER;
 +      base->event_count_active++;
 +      EVUTIL_ASSERT(evcb->evcb_pri < base->nactivequeues);
 +      TAILQ_INSERT_TAIL(&base->active_later_queue, evcb, evcb_active_next);
 +}
  
 -      ev->ev_flags |= queue;
 -      switch (queue) {
 -      case EVLIST_INSERTED:
 -              TAILQ_INSERT_TAIL(&base->eventqueue, ev, ev_next);
 -              break;
 -      case EVLIST_ACTIVE:
 -              base->event_count_active++;
 -              TAILQ_INSERT_TAIL(&base->activequeues[ev->ev_pri],
 -                  ev,ev_active_next);
 -              break;
 -      case EVLIST_TIMEOUT: {
 -              if (is_common_timeout(&ev->ev_timeout, base)) {
 -                      struct common_timeout_list *ctl =
 -                          get_common_timeout_list(base, &ev->ev_timeout);
 -                      insert_common_timeout_inorder(ctl, ev);
 -              } else
 -                      min_heap_push(&base->timeheap, ev);
 -              break;
 +static void
 +event_queue_insert_timeout(struct event_base *base, struct event *ev)
 +{
 +      EVENT_BASE_ASSERT_LOCKED(base);
 +
 +      if (EVUTIL_FAILURE_CHECK(ev->ev_flags & EVLIST_TIMEOUT)) {
-               event_errx(1, "%s: %p(fd %d) already on timeout", __func__,
-                          ev, ev->ev_fd);
++              event_errx(1, "%s: %p(fd "EV_SOCK_FMT") already on timeout", __func__,
++                  ev, EV_SOCK_ARG(ev->ev_fd));
 +              return;
        }
 -      default:
 -              event_errx(1, "%s: unknown queue %x", __func__, queue);
 +
 +      INCR_EVENT_COUNT(base, ev->ev_flags);
 +
 +      ev->ev_flags |= EVLIST_TIMEOUT;
 +
 +      if (is_common_timeout(&ev->ev_timeout, base)) {
 +              struct common_timeout_list *ctl =
 +                  get_common_timeout_list(base, &ev->ev_timeout);
 +              insert_common_timeout_inorder(ctl, ev);
 +      } else {
 +              min_heap_push_(&base->timeheap, ev);
 +      }
 +}
 +
 +static void
 +event_queue_make_later_events_active(struct event_base *base)
 +{
 +      struct event_callback *evcb;
 +      EVENT_BASE_ASSERT_LOCKED(base);
 +
 +      while ((evcb = TAILQ_FIRST(&base->active_later_queue))) {
 +              TAILQ_REMOVE(&base->active_later_queue, evcb, evcb_active_next);
 +              evcb->evcb_flags = (evcb->evcb_flags & ~EVLIST_ACTIVE_LATER) | EVLIST_ACTIVE;
 +              EVUTIL_ASSERT(evcb->evcb_pri < base->nactivequeues);
 +              TAILQ_INSERT_TAIL(&base->activequeues[evcb->evcb_pri], evcb, evcb_active_next);
 +              base->n_deferreds_queued += (evcb->evcb_closure == EV_CLOSURE_CB_SELF);
        }
  }
  
@@@ -3189,150 -2816,38 +3193,150 @@@ evthread_make_base_notifiable_nolock_(s
        base->th_notify.ev_flags |= EVLIST_INTERNAL;
        event_priority_set(&base->th_notify, 0);
  
 -      return event_add(&base->th_notify, NULL);
 +      return event_add_nolock_(&base->th_notify, NULL, 0);
  }
  
 -void
 -event_base_dump_events(struct event_base *base, FILE *output)
 +int
 +event_base_foreach_event_nolock_(struct event_base *base,
 +    event_base_foreach_event_cb fn, void *arg)
  {
 -      struct event *e;
 -      int i;
 -      fprintf(output, "Inserted events:\n");
 -      TAILQ_FOREACH(e, &base->eventqueue, ev_next) {
 -              fprintf(output, "  %p [fd "EV_SOCK_FMT"]%s%s%s%s%s\n",
 -                              (void*)e, EV_SOCK_ARG(e->ev_fd),
 -                              (e->ev_events&EV_READ)?" Read":"",
 -                              (e->ev_events&EV_WRITE)?" Write":"",
 -                              (e->ev_events&EV_SIGNAL)?" Signal":"",
 -                              (e->ev_events&EV_TIMEOUT)?" Timeout":"",
 -                              (e->ev_events&EV_PERSIST)?" Persist":"");
 +      int r, i;
 +      unsigned u;
 +      struct event *ev;
 +
 +      /* Start out with all the EVLIST_INSERTED events. */
 +      if ((r = evmap_foreach_event_(base, fn, arg)))
 +              return r;
 +
 +      /* Okay, now we deal with those events that have timeouts and are in
 +       * the min-heap. */
 +      for (u = 0; u < base->timeheap.n; ++u) {
 +              ev = base->timeheap.p[u];
 +              if (ev->ev_flags & EVLIST_INSERTED) {
 +                      /* we already processed this one */
 +                      continue;
 +              }
 +              if ((r = fn(base, ev, arg)))
 +                      return r;
 +      }
  
 +      /* Now for the events in one of the timeout queues.
 +       * the min-heap. */
 +      for (i = 0; i < base->n_common_timeouts; ++i) {
 +              struct common_timeout_list *ctl =
 +                  base->common_timeout_queues[i];
 +              TAILQ_FOREACH(ev, &ctl->events,
 +                  ev_timeout_pos.ev_next_with_common_timeout) {
 +                      if (ev->ev_flags & EVLIST_INSERTED) {
 +                              /* we already processed this one */
 +                              continue;
 +                      }
 +                      if ((r = fn(base, ev, arg)))
 +                              return r;
 +              }
        }
 +
 +      /* Finally, we deal wit all the active events that we haven't touched
 +       * yet. */
        for (i = 0; i < base->nactivequeues; ++i) {
 -              if (TAILQ_EMPTY(&base->activequeues[i]))
 -                      continue;
 -              fprintf(output, "Active events [priority %d]:\n", i);
 -              TAILQ_FOREACH(e, &base->eventqueue, ev_next) {
 -                      fprintf(output, "  %p [fd "EV_SOCK_FMT"]%s%s%s%s\n",
 -                                      (void*)e, EV_SOCK_ARG(e->ev_fd),
 -                                      (e->ev_res&EV_READ)?" Read active":"",
 -                                      (e->ev_res&EV_WRITE)?" Write active":"",
 -                                      (e->ev_res&EV_SIGNAL)?" Signal active":"",
 -                                      (e->ev_res&EV_TIMEOUT)?" Timeout active":"");
 +              struct event_callback *evcb;
 +              TAILQ_FOREACH(evcb, &base->activequeues[i], evcb_active_next) {
 +                      if ((evcb->evcb_flags & (EVLIST_INIT|EVLIST_INSERTED|EVLIST_TIMEOUT)) != EVLIST_INIT) {
 +                              /* This isn't an event (evlist_init clear), or
 +                               * we already processed it. (inserted or
 +                               * timeout set */
 +                              continue;
 +                      }
 +                      ev = event_callback_to_event(evcb);
 +                      if ((r = fn(base, ev, arg)))
 +                              return r;
                }
        }
-       fprintf(output, "  %p [%s %ld]%s%s%s%s%s",
-           (void*)e, gloss, (long)e->ev_fd,
 +
 +      return 0;
 +}
 +
 +/* Helper for event_base_dump_events: called on each event in the event base;
 + * dumps only the inserted events. */
 +static int
 +dump_inserted_event_fn(const struct event_base *base, const struct event *e, void *arg)
 +{
 +      FILE *output = arg;
 +      const char *gloss = (e->ev_events & EV_SIGNAL) ?
 +          "sig" : "fd ";
 +
 +      if (! (e->ev_flags & (EVLIST_INSERTED|EVLIST_TIMEOUT)))
 +              return 0;
 +
-       fprintf(output, "  %p [%s %ld, priority=%d]%s%s%s%s active%s%s\n",
-           (void*)e, gloss, (long)e->ev_fd, e->ev_pri,
++      fprintf(output, "  %p [%s "EV_SOCK_FMT"]%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_SIGNAL)?" Signal":"",
 +          (e->ev_events&EV_PERSIST)?" Persist":"",
 +          (e->ev_flags&EVLIST_INTERNAL)?" Internal":"");
 +      if (e->ev_flags & EVLIST_TIMEOUT) {
 +              struct timeval tv;
 +              tv.tv_sec = e->ev_timeout.tv_sec;
 +              tv.tv_usec = e->ev_timeout.tv_usec & MICROSECONDS_MASK;
 +              evutil_timeradd(&tv, &base->tv_clock_diff, &tv);
 +              fprintf(output, " Timeout=%ld.%06d",
 +                  (long)tv.tv_sec, (int)(tv.tv_usec & MICROSECONDS_MASK));
 +      }
 +      fputc('\n', output);
 +
 +      return 0;
 +}
 +
 +/* Helper for event_base_dump_events: called on each event in the event base;
 + * dumps only the active events. */
 +static int
 +dump_active_event_fn(const struct event_base *base, const struct event *e, void *arg)
 +{
 +      FILE *output = arg;
 +      const char *gloss = (e->ev_events & EV_SIGNAL) ?
 +          "sig" : "fd ";
 +
 +      if (! (e->ev_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER)))
 +              return 0;
 +
++      fprintf(output, "  %p [%s "EV_SOCK_FMT", priority=%d]%s%s%s%s active%s%s\n",
++          (void*)e, gloss, EV_SOCK_ARG(e->ev_fd), e->ev_pri,
 +          (e->ev_res&EV_READ)?" Read":"",
 +          (e->ev_res&EV_WRITE)?" Write":"",
 +          (e->ev_res&EV_SIGNAL)?" Signal":"",
 +          (e->ev_res&EV_TIMEOUT)?" Timeout":"",
 +          (e->ev_flags&EVLIST_INTERNAL)?" [Internal]":"",
 +          (e->ev_flags&EVLIST_ACTIVE_LATER)?" [NextTime]":"");
 +
 +      return 0;
 +}
 +
 +int
 +event_base_foreach_event(struct event_base *base,
 +    event_base_foreach_event_cb fn, void *arg)
 +{
 +      int r;
 +      if ((!fn) || (!base)) {
 +              return -1;
 +      }
 +      EVBASE_ACQUIRE_LOCK(base, th_base_lock);
 +      r = event_base_foreach_event_nolock_(base, fn, arg);
 +      EVBASE_RELEASE_LOCK(base, th_base_lock);
 +      return r;
 +}
 +
 +
 +void
 +event_base_dump_events(struct event_base *base, FILE *output)
 +{
 +      EVBASE_ACQUIRE_LOCK(base, th_base_lock);
 +      fprintf(output, "Inserted events:\n");
 +      event_base_foreach_event_nolock_(base, dump_inserted_event_fn, output);
 +
 +      fprintf(output, "Active events:\n");
 +      event_base_foreach_event_nolock_(base, dump_active_event_fn, output);
 +      EVBASE_RELEASE_LOCK(base, th_base_lock);
  }
  
  void
diff --cc http.c
index babcd2d786f00f947e1a1053d723793698efcc42,bd4fd47c42ba5b07a195a50db19432923df3e1f3..b096705a0eb7101eb715f19dcd55de7292b15aad
--- 1/http.c
--- 2/http.c
+++ b/http.c
@@@ -2125,8 -2037,9 +2125,9 @@@ evhttp_read_header(struct evhttp_connec
                break;
  
        default:
-               event_warnx("%s: bad header on %d", __func__, fd);
+               event_warnx("%s: bad header on "EV_SOCK_FMT, __func__,
+                   EV_SOCK_ARG(fd));
 -              evhttp_connection_fail(evcon, EVCON_HTTP_INVALID_HEADER);
 +              evhttp_connection_fail_(evcon, EVCON_HTTP_INVALID_HEADER);
                break;
        }
        /* request may have been freed above */
index 8ed265607f84b5d481ec0244ddaf68a83c505580,a1483e63e54b590af1704761207f38d76541dbef..27b0b530d5c1972873357e7f22715ce0ba3413fe
  #include <string.h>
  #include <errno.h>
  
 -#include <event.h>
 +#include <event2/event.h>
  
  static void
- fifo_read(int fd, short event, void *arg)
+ fifo_read(evutil_socket_t fd, short event, void *arg)
  {
        char buf[255];
        int len;
        DWORD dwBytesRead;
  #endif
  
 -      /* Reschedule this event */
 -      event_add(ev, NULL);
 -
        fprintf(stderr, "fifo_read called with fd: %d, event: %d, arg: %p\n",
-               fd, event, arg);
+           (int)fd, event, arg);
 -#ifdef WIN32
 +#ifdef _WIN32
        len = ReadFile((HANDLE)fd, buf, sizeof(buf) - 1, &dwBytesRead, NULL);
  
        /* Check for end of file. */
@@@ -130,19 -122,13 +130,19 @@@ main(int argc, char **argv
        fprintf(stderr, "Write data to %s\n", fifo);
  #endif
        /* Initalize the event library */
 -      event_init();
 +      base = event_base_new();
  
        /* Initalize one event */
 -#ifdef WIN32
 -      event_set(&evfifo, (evutil_socket_t)socket, EV_READ, fifo_read, &evfifo);
 +#ifdef _WIN32
-       evfifo = event_new(base, (int)socket, EV_READ|EV_PERSIST, fifo_read,
++      evfifo = event_new(base, (evutil_socket_t)socket, EV_READ|EV_PERSIST, fifo_read,
 +                           event_self_cbarg());
  #else
 -      event_set(&evfifo, socket, EV_READ, fifo_read, &evfifo);
 +      /* catch SIGINT so that event.fifo can be cleaned up */
 +      signal_int = evsignal_new(base, SIGINT, signal_cb, base);
 +      event_add(signal_int, NULL);
 +
 +      evfifo = event_new(base, socket, EV_READ|EV_PERSIST, fifo_read,
 +                           event_self_cbarg());
  #endif
  
        /* Add it to the active events, without a timeout */
index 5d432bf00a1d8a2ff59182defaff89f608832eaa,f969e23493a3f57434915f70c9993493fd739089..a61642f325e3fb5db281c4597b2527e4efe9bff7
@@@ -48,12 -48,11 +48,11 @@@ signal_cb(evutil_socket_t fd, short eve
  int
  main(int argc, char **argv)
  {
 -      struct event signal_int;
 +      struct event *signal_int;
        struct event_base* base;
 -#ifdef WIN32
 +#ifdef _WIN32
        WORD wVersionRequested;
        WSADATA wsaData;
-       int     err;
  
        wVersionRequested = MAKEWORD(2, 2);
  
index 8d5e869b9b51d08b6dd808524784b033048e79fa,77d4e206a79b397b0f42fa028b9dc3bb2112e415..c94c18a5004efd21e2405ac6be0c98573bf79c1f
@@@ -71,10 -71,9 +71,9 @@@ main(int argc, char **argv
        struct event_base *base;
        int flags;
  
 -#ifdef WIN32
 +#ifdef _WIN32
        WORD wVersionRequested;
        WSADATA wsaData;
-       int     err;
  
        wVersionRequested = MAKEWORD(2, 2);
  
diff --cc test/bench.c
index 7686c71c7393f45bd801a48e70ea3168eb29ac62,9ae02ea8ce4fc8252f56ebca815b90cc0b4c848c..2f5271b2e36d5c4a44e03f54cc3d99cd09d13f49
@@@ -130,9 -130,9 +130,9 @@@ main(int argc, char **argv
  #endif
        int i, c;
        struct timeval *tv;
-       int *cp;
+       evutil_socket_t *cp;
  
 -#ifdef WIN32
 +#ifdef _WIN32
        WSADATA WSAData;
        WSAStartup(0x101, &WSAData);
  #endif
Simple merge
index 335ed44d1e9dd7816aa16392e0fd01e6e6c516f2,19ee4e3a9385e8fa7d2d9944e5a17d39b443014e..63454c9cd0343401c3cfcec78a4c89b60174c637
@@@ -75,7 -74,8 +75,8 @@@
  #include "event2/util.h"
  
  #include "bufferevent-internal.h"
 -#ifdef WIN32
+ #include "util-internal.h"
 +#ifdef _WIN32
  #include "iocp-internal.h"
  #endif
  
Simple merge
index ed90f8172297f116ddf011f082589cfb8448c468,1649e9dfb909bcd0580396bf748b317b9ec22f1c..11e5f8d94c7909c19c70093f69a44611c737e781
@@@ -415,17 -389,16 +415,16 @@@ struct testlist_alias_t testaliases[] 
  int
  main(int argc, const char **argv)
  {
 -#ifdef WIN32
 +#ifdef _WIN32
        WORD wVersionRequested;
        WSADATA wsaData;
-       int     err;
  
        wVersionRequested = MAKEWORD(2, 2);
  
-       err = WSAStartup(wVersionRequested, &wsaData);
+       (void) WSAStartup(wVersionRequested, &wsaData);
  #endif
  
 -#ifndef WIN32
 +#ifndef _WIN32
        if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
                return 1;
  #endif
Simple merge
Simple merge
Simple merge
index 509c258e1226d721ed15149acee9c1f5cab87a65,2d88f3460cfa07ac1a37b2e4070a779ed130653c..206eb6013eecaae401a671c4c8aad639c6495175
@@@ -171,10 -171,9 +171,9 @@@ main(int argc, char **argv
  
        double usage, secPassed, secUsed;
  
 -#ifdef WIN32
 +#ifdef _WIN32
        WORD wVersionRequested;
        WSADATA wsaData;
-       int     err;
  
        wVersionRequested = MAKEWORD(2, 2);
  
diff --cc test/test-eof.c
index 9ac4f8d9997c415af258ba23d34b74a928b26261,741a2d812cc7244790000c3b86534f31f3224461..a9ca5343a2cef093b9bbf4bb611ddefe1d9e8cf1
@@@ -92,10 -92,9 +92,9 @@@ main(int argc, char **argv
        const char *test = "test string";
        evutil_socket_t pair[2];
  
 -#ifdef WIN32
 +#ifdef _WIN32
        WORD wVersionRequested;
        WSADATA wsaData;
-       int     err;
  
        wVersionRequested = MAKEWORD(2, 2);
  
index 3d28f0b1c876dc61810656e5da823ea7660d4b68,fc18f4d1150b581bb0363e42ab75b3a2158f7753..92fbc6b1465947bbb76649ff64288f1108408913
  int
  main(int argc, char **argv)
  {
 -#ifdef WIN32
 +#ifdef _WIN32
        WORD wVersionRequested;
        WSADATA wsaData;
-       int     err;
  
        wVersionRequested = MAKEWORD(2, 2);
  
index b53ffe66372d3d7ec2497cb5b0f01f3e94d4a170,815657ec715b6ff48766365ffa8adcab2824b9f1..aa171aa4ea732b0eb9880772012089a9760918d6
@@@ -544,15 -422,14 +544,14 @@@ main(int argc, char **argv
        int i,j;
        double ratio;
  
 -#ifdef WIN32
 +#ifdef _WIN32
        WORD wVersionRequested = MAKEWORD(2,2);
        WSADATA wsaData;
-       int err;
  
-       err = WSAStartup(wVersionRequested, &wsaData);
+       (void) WSAStartup(wVersionRequested, &wsaData);
  #endif
  
 -#ifndef WIN32
 +#ifndef _WIN32
        if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
                return 1;
  #endif
index 8b763c160d7e4e669dfcb1f65cf8f2e032d6dd7e,ca47205dcb50aa133fb7e3ccee80c08f11b691fb..dcd6639a56fb88fe0f0a6f95c8be064c4987aca7
@@@ -84,10 -84,9 +84,9 @@@ main(int argc, char **argv
  {
        struct timeval tv;
        int i;
 -#ifdef WIN32
 +#ifdef _WIN32
        WORD wVersionRequested;
        WSADATA wsaData;
-       int     err;
  
        wVersionRequested = MAKEWORD(2, 2);
  
index 7df0e9c94c101731c000bf2ce84e1829f1f81a7d,1ac89eda3b5c55ae087050177b49f061acc22fa4..c379f287cb503d862e3f8f67103b2508bf163872
@@@ -85,17 -85,16 +85,16 @@@ main(int argc, char **argv
  {
        struct event ev;
  
 -#ifdef WIN32
 +#ifdef _WIN32
        WORD wVersionRequested;
        WSADATA wsaData;
-       int     err;
  
        wVersionRequested = MAKEWORD(2, 2);
  
-       err = WSAStartup(wVersionRequested, &wsaData);
+       (void) WSAStartup(wVersionRequested, &wsaData);
  #endif
  
 -#ifndef WIN32
 +#ifndef _WIN32
        if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
                return (1);
  #endif
diff --cc util-internal.h
Simple merge