posix: upgrade libevent from 1.4.7 to 1.4.13

third_party/libevent/signal.c

 /*      $OpenBSD: select.c,v 1.2 2002/06/25 15:50:15 mickey Exp $       */
 
 /*
  * Copyright 2000-2002 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
@@ skipping 53 matching lines @@
 #include "log.h"
 
 struct event_base *evsignal_base = NULL;
 
 static void evsignal_handler(int sig);
 
 /* Callback for when the signal handler write a byte to our signaling socket */
 static void
 evsignal_cb(int fd, short what, void *arg)
 {
-        static char signals[100];
+        static char signals[1];
 #ifdef WIN32
         SSIZE_T n;
 #else
         ssize_t n;
 #endif
 
         n = recv(fd, signals, sizeof(signals), 0);
         if (n == -1)
                 event_err(1, "%s: read", __func__);
 }
 
 #ifdef HAVE_SETFD
 #define FD_CLOSEONEXEC(x) do { \
         if (fcntl(x, F_SETFD, 1) == -1) \
                 event_warn("fcntl(%d, F_SETFD)", x); \
 } while (0)
 #else
 #define FD_CLOSEONEXEC(x)
 #endif
 
-void
+int
 evsignal_init(struct event_base *base)
 {
         int i;
 
         /* 
          * Our signal handler is going to write to one end of the socket
          * pair to wake up our event loop.  The event loop then scans for
          * signals that got delivered.
          */
         if (evutil_socketpair(
-                    AF_UNIX, SOCK_STREAM, 0, base->sig.ev_signal_pair) == -1)
+                    AF_UNIX, SOCK_STREAM, 0, base->sig.ev_signal_pair) == -1) {
+#ifdef WIN32
+                /* Make this nonfatal on win32, where sometimes people
+                   have localhost firewalled. */
+                event_warn("%s: socketpair", __func__);
+#else
                 event_err(1, "%s: socketpair", __func__);
+#endif
+                return -1;
+        }
 
         FD_CLOSEONEXEC(base->sig.ev_signal_pair[0]);
         FD_CLOSEONEXEC(base->sig.ev_signal_pair[1]);
         base->sig.sh_old = NULL;
         base->sig.sh_old_max = 0;
         base->sig.evsignal_caught = 0;
         memset(&base->sig.evsigcaught, 0, sizeof(sig_atomic_t)*NSIG);
         /* initialize the queues for all events */
         for (i = 0; i < NSIG; ++i)
                 TAILQ_INIT(&base->sig.evsigevents[i]);
 
         evutil_make_socket_nonblocking(base->sig.ev_signal_pair[0]);
 
         event_set(&base->sig.ev_signal, base->sig.ev_signal_pair[1],
                 EV_READ | EV_PERSIST, evsignal_cb, &base->sig.ev_signal);
         base->sig.ev_signal.ev_base = base;
         base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL;
+
+        return 0;
 }
 
 /* Helper: set the signal handler for evsignal to handler in base, so that
  * we can restore the original handler when we clear the current one. */
 int
 _evsignal_set_handler(struct event_base *base,
                       int evsignal, void (*handler)(int))
 {
 #ifdef HAVE_SIGACTION
         struct sigaction sa;
@@ skipping 168 matching lines @@
         struct evsignal_info *sig = &base->sig;
         struct event *ev, *next_ev;
         sig_atomic_t ncalls;
         int i;
         
         base->sig.evsignal_caught = 0;
         for (i = 1; i < NSIG; ++i) {
                 ncalls = sig->evsigcaught[i];
                 if (ncalls == 0)
                         continue;
+                sig->evsigcaught[i] -= ncalls;
 
                 for (ev = TAILQ_FIRST(&sig->evsigevents[i]);
                     ev != NULL; ev = next_ev) {
                         next_ev = TAILQ_NEXT(ev, ev_signal_next);
                         if (!(ev->ev_events & EV_PERSIST))
                                 event_del(ev);
                         event_active(ev, EV_SIGNAL, ncalls);
                 }
 
-                sig->evsigcaught[i] = 0;
         }
 }
 
 void
 evsignal_dealloc(struct event_base *base)
 {
         int i = 0;
         if (base->sig.ev_signal_added) {
                 event_del(&base->sig.ev_signal);
                 base->sig.ev_signal_added = 0;
         }
         for (i = 0; i < NSIG; ++i) {
                 if (i < base->sig.sh_old_max && base->sig.sh_old[i] != NULL)
                         _evsignal_restore_handler(base, i);
         }
 
         EVUTIL_CLOSESOCKET(base->sig.ev_signal_pair[0]);
         base->sig.ev_signal_pair[0] = -1;
         EVUTIL_CLOSESOCKET(base->sig.ev_signal_pair[1]);
         base->sig.ev_signal_pair[1] = -1;
         base->sig.sh_old_max = 0;
 
         /* per index frees are handled in evsignal_del() */
         free(base->sig.sh_old);
 }