Revert "Revert "Upgrade to 2.1.8-stable (2017-01-22)." and "Probably Mac build fix?""

This reverts commit 83a0c9c65a60a92d3ea5542596b3ba56db492c37.

Bug: 64543673
Test: make checkbuild
Test: Manual tombstoned test
Change-Id: I84bb128d1dec433195f2cbdbf70236ba17fa9955

1 files changed, 71 insertions, 37 deletions

diff --git a/signal.c b/signal.c
index 423f12a..3f46295 100644
--- a/signal.c
+++ b/signal.c
@@ -27,30 +27,31 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include "event2/event-config.h"
+#include "evconfig-private.h"
 
-#ifdef WIN32
+#ifdef _WIN32
 #define WIN32_LEAN_AND_MEAN
 #include <winsock2.h>
 #include <windows.h>
 #undef WIN32_LEAN_AND_MEAN
 #endif
 #include <sys/types.h>
-#ifdef _EVENT_HAVE_SYS_TIME_H
+#ifdef EVENT__HAVE_SYS_TIME_H
 #include <sys/time.h>
 #endif
 #include <sys/queue.h>
-#ifdef _EVENT_HAVE_SYS_SOCKET_H
+#ifdef EVENT__HAVE_SYS_SOCKET_H
 #include <sys/socket.h>
 #endif
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#ifdef _EVENT_HAVE_UNISTD_H
+#ifdef EVENT__HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #include <errno.h>
-#ifdef _EVENT_HAVE_FCNTL_H
+#ifdef EVENT__HAVE_FCNTL_H
 #include <fcntl.h>
 #endif
 
@@ -81,7 +82,7 @@
   on Linux do a reasonable thing using signalfd.
 */
 
-#ifndef WIN32
+#ifndef _WIN32
 /* Windows wants us to call our signal handlers as __cdecl.  Nobody else
  * expects you to do anything crazy like this. */
 #define __cdecl
@@ -100,7 +101,7 @@ static const struct eventop evsigops = {
 	0, 0, 0
 };
 
-#ifndef _EVENT_DISABLE_THREAD_SUPPORT
+#ifndef EVENT__DISABLE_THREAD_SUPPORT
 /* Lock for evsig_base and evsig_base_n_signals_added fields. */
 static void *evsig_base_lock = NULL;
 #endif
@@ -116,12 +117,12 @@ static void __cdecl evsig_handler(int sig);
 #define EVSIGBASE_UNLOCK() EVLOCK_UNLOCK(evsig_base_lock, 0)
 
 void
-evsig_set_base(struct event_base *base)
+evsig_set_base_(struct event_base *base)
 {
 	EVSIGBASE_LOCK();
 	evsig_base = base;
 	evsig_base_n_signals_added = base->sig.ev_n_signals_added;
-	evsig_base_fd = base->sig.ev_signal_pair[0];
+	evsig_base_fd = base->sig.ev_signal_pair[1];
 	EVSIGBASE_UNLOCK();
 }
 
@@ -140,7 +141,11 @@ evsig_cb(evutil_socket_t fd, short what, void *arg)
 	memset(&ncaught, 0, sizeof(ncaught));
 
 	while (1) {
+#ifdef _WIN32
 		n = recv(fd, signals, sizeof(signals), 0);
+#else
+		n = read(fd, signals, sizeof(signals));
+#endif
 		if (n == -1) {
 			int err = evutil_socket_geterror(fd);
 			if (! EVUTIL_ERR_RW_RETRIABLE(err))
@@ -160,22 +165,21 @@ evsig_cb(evutil_socket_t fd, short what, void *arg)
 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
 	for (i = 0; i < NSIG; ++i) {
 		if (ncaught[i])
-			evmap_signal_active(base, i, ncaught[i]);
+			evmap_signal_active_(base, i, ncaught[i]);
 	}
 	EVBASE_RELEASE_LOCK(base, th_base_lock);
 }
 
 int
-evsig_init(struct event_base *base)
+evsig_init_(struct event_base *base)
 {
 	/*
 	 * 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) {
-#ifdef WIN32
+	if (evutil_make_internal_pipe_(base->sig.ev_signal_pair) == -1) {
+#ifdef _WIN32
 		/* Make this nonfatal on win32, where sometimes people
 		   have localhost firewalled. */
 		event_sock_warn(-1, "%s: socketpair", __func__);
@@ -185,15 +189,13 @@ evsig_init(struct event_base *base)
 		return -1;
 	}
 
-	evutil_make_socket_closeonexec(base->sig.ev_signal_pair[0]);
-	evutil_make_socket_closeonexec(base->sig.ev_signal_pair[1]);
+	if (base->sig.sh_old) {
+		mm_free(base->sig.sh_old);
+	}
 	base->sig.sh_old = NULL;
 	base->sig.sh_old_max = 0;
 
-	evutil_make_socket_nonblocking(base->sig.ev_signal_pair[0]);
-	evutil_make_socket_nonblocking(base->sig.ev_signal_pair[1]);
-
-	event_assign(&base->sig.ev_signal, base, base->sig.ev_signal_pair[1],
+	event_assign(&base->sig.ev_signal, base, base->sig.ev_signal_pair[0],
 		EV_READ | EV_PERSIST, evsig_cb, base);
 
 	base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL;
@@ -207,10 +209,10 @@ evsig_init(struct event_base *base)
 /* 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
-_evsig_set_handler(struct event_base *base,
+evsig_set_handler_(struct event_base *base,
     int evsignal, void (__cdecl *handler)(int))
 {
-#ifdef _EVENT_HAVE_SIGACTION
+#ifdef EVENT__HAVE_SIGACTION
 	struct sigaction sa;
 #else
 	ev_sighandler_t sh;
@@ -247,7 +249,7 @@ _evsig_set_handler(struct event_base *base,
 	}
 
 	/* save previous handler and setup new handler */
-#ifdef _EVENT_HAVE_SIGACTION
+#ifdef EVENT__HAVE_SIGACTION
 	memset(&sa, 0, sizeof(sa));
 	sa.sa_handler = handler;
 	sa.sa_flags |= SA_RESTART;
@@ -293,17 +295,17 @@ evsig_add(struct event_base *base, evutil_socket_t evsignal, short old, short ev
 	}
 	evsig_base = base;
 	evsig_base_n_signals_added = ++sig->ev_n_signals_added;
-	evsig_base_fd = base->sig.ev_signal_pair[0];
+	evsig_base_fd = base->sig.ev_signal_pair[1];
 	EVSIGBASE_UNLOCK();
 
 	event_debug(("%s: %d: changing signal handler", __func__, (int)evsignal));
-	if (_evsig_set_handler(base, (int)evsignal, evsig_handler) == -1) {
+	if (evsig_set_handler_(base, (int)evsignal, evsig_handler) == -1) {
 		goto err;
 	}
 
 
 	if (!sig->ev_signal_added) {
-		if (event_add(&sig->ev_signal, NULL))
+		if (event_add_nolock_(&sig->ev_signal, NULL, 0))
 			goto err;
 		sig->ev_signal_added = 1;
 	}
@@ -319,20 +321,26 @@ err:
 }
 
 int
-_evsig_restore_handler(struct event_base *base, int evsignal)
+evsig_restore_handler_(struct event_base *base, int evsignal)
 {
 	int ret = 0;
 	struct evsig_info *sig = &base->sig;
-#ifdef _EVENT_HAVE_SIGACTION
+#ifdef EVENT__HAVE_SIGACTION
 	struct sigaction *sh;
 #else
 	ev_sighandler_t *sh;
 #endif
 
+	if (evsignal >= sig->sh_old_max) {
+		/* Can't actually restore. */
+		/* XXXX.*/
+		return 0;
+	}
+
 	/* restore previous handler */
 	sh = sig->sh_old[evsignal];
 	sig->sh_old[evsignal] = NULL;
-#ifdef _EVENT_HAVE_SIGACTION
+#ifdef EVENT__HAVE_SIGACTION
 	if (sigaction(evsignal, sh, NULL) == -1) {
 		event_warn("sigaction");
 		ret = -1;
@@ -362,14 +370,14 @@ evsig_del(struct event_base *base, evutil_socket_t evsignal, short old, short ev
 	--base->sig.ev_n_signals_added;
 	EVSIGBASE_UNLOCK();
 
-	return (_evsig_restore_handler(base, (int)evsignal));
+	return (evsig_restore_handler_(base, (int)evsignal));
 }
 
 static void __cdecl
 evsig_handler(int sig)
 {
 	int save_errno = errno;
-#ifdef WIN32
+#ifdef _WIN32
 	int socket_errno = EVUTIL_SOCKET_ERROR();
 #endif
 	ev_uint8_t msg;
@@ -381,34 +389,41 @@ evsig_handler(int sig)
 		return;
 	}
 
-#ifndef _EVENT_HAVE_SIGACTION
+#ifndef EVENT__HAVE_SIGACTION
 	signal(sig, evsig_handler);
 #endif
 
 	/* Wake up our notification mechanism */
 	msg = sig;
+#ifdef _WIN32
 	send(evsig_base_fd, (char*)&msg, 1, 0);
+#else
+	{
+		int r = write(evsig_base_fd, (char*)&msg, 1);
+		(void)r; /* Suppress 'unused return value' and 'unused var' */
+	}
+#endif
 	errno = save_errno;
-#ifdef WIN32
+#ifdef _WIN32
 	EVUTIL_SET_SOCKET_ERROR(socket_errno);
 #endif
 }
 
 void
-evsig_dealloc(struct event_base *base)
+evsig_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;
 	}
-	/* debug event is created in evsig_init/event_assign even when
+	/* debug event is created in evsig_init_/event_assign even when
 	 * ev_signal_added == 0, so unassign is required */
 	event_debug_unassign(&base->sig.ev_signal);
 
 	for (i = 0; i < NSIG; ++i) {
 		if (i < base->sig.sh_old_max && base->sig.sh_old[i] != NULL)
-			_evsig_restore_handler(base, i);
+			evsig_restore_handler_(base, i);
 	}
 	EVSIGBASE_LOCK();
 	if (base == evsig_base) {
@@ -435,11 +450,30 @@ evsig_dealloc(struct event_base *base)
 	}
 }
 
-#ifndef _EVENT_DISABLE_THREAD_SUPPORT
+static void
+evsig_free_globals_locks(void)
+{
+#ifndef EVENT__DISABLE_THREAD_SUPPORT
+	if (evsig_base_lock != NULL) {
+		EVTHREAD_FREE_LOCK(evsig_base_lock, 0);
+		evsig_base_lock = NULL;
+	}
+#endif
+	return;
+}
+
+void
+evsig_free_globals_(void)
+{
+	evsig_free_globals_locks();
+}
+
+#ifndef EVENT__DISABLE_THREAD_SUPPORT
 int
 evsig_global_setup_locks_(const int enable_locks)
 {
 	EVTHREAD_SETUP_GLOBAL_LOCK(evsig_base_lock, 0);
 	return 0;
 }
+
 #endif