Restoring authorship annotation for <kikht@yandex-team.ru>. Commit 2 of 2.

1 files changed, 73 insertions, 73 deletions

diff --git a/contrib/libs/libevent/signal.c b/contrib/libs/libevent/signal.c
index 875dbcf9b9..89f5fc1717 100644
--- a/contrib/libs/libevent/signal.c
+++ b/contrib/libs/libevent/signal.c
@@ -27,31 +27,31 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include "event2/event-config.h"
-#include "evconfig-private.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
 
@@ -82,13 +82,13 @@
   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. */
-#ifndef __cdecl 
+#ifndef __cdecl
 #define __cdecl
 #endif
-#endif 
+#endif
 
 static int evsig_add(struct event_base *, evutil_socket_t, short, short, void *);
 static int evsig_del(struct event_base *, evutil_socket_t, short, short, void *);
@@ -103,7 +103,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
@@ -119,12 +119,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[1]; 
+	evsig_base_fd = base->sig.ev_signal_pair[1];
 	EVSIGBASE_UNLOCK();
 }
 
@@ -143,11 +143,11 @@ evsig_cb(evutil_socket_t fd, short what, void *arg)
 	memset(&ncaught, 0, sizeof(ncaught));
 
 	while (1) {
-#ifdef _WIN32 
+#ifdef _WIN32
 		n = recv(fd, signals, sizeof(signals), 0);
-#else 
-		n = read(fd, signals, sizeof(signals)); 
-#endif 
+#else
+		n = read(fd, signals, sizeof(signals));
+#endif
 		if (n == -1) {
 			int err = evutil_socket_geterror(fd);
 			if (! EVUTIL_ERR_RW_RETRIABLE(err))
@@ -167,21 +167,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_make_internal_pipe_(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__);
@@ -191,13 +191,13 @@ evsig_init_(struct event_base *base)
 		return -1;
 	}
 
-	if (base->sig.sh_old) { 
-		mm_free(base->sig.sh_old); 
-	} 
+	if (base->sig.sh_old) {
+		mm_free(base->sig.sh_old);
+	}
 	base->sig.sh_old = NULL;
 	base->sig.sh_old_max = 0;
 
-	event_assign(&base->sig.ev_signal, base, base->sig.ev_signal_pair[0], 
+	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;
@@ -211,10 +211,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;
@@ -251,7 +251,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;
@@ -297,17 +297,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[1]; 
+	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_nolock_(&sig->ev_signal, NULL, 0)) 
+		if (event_add_nolock_(&sig->ev_signal, NULL, 0))
 			goto err;
 		sig->ev_signal_added = 1;
 	}
@@ -323,26 +323,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; 
-	} 
- 
+	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;
@@ -372,14 +372,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;
@@ -391,41 +391,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 
+#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 
+#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) {
@@ -452,30 +452,30 @@ evsig_dealloc_(struct event_base *base)
 	}
 }
 
-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 
+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