posix: upgrade libevent from 1.4.7 to 1.4.13

third_party/libevent/test/regress.c

 /*
  * Copyright (c) 2003, 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 25 matching lines @@
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #ifdef HAVE_SYS_TIME_H
 #include <sys/time.h>
 #endif
 #include <sys/queue.h>
 #ifndef WIN32
 #include <sys/socket.h>
 #include <sys/wait.h>
-#include <sys/signal.h>
+#include <signal.h>
 #include <unistd.h>
 #include <netdb.h>
 #endif
 #include <assert.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
@@ skipping 31 matching lines @@
 #define write(fd,buf,len) send((fd),(buf),(len),0)
 #define read(fd,buf,len) recv((fd),(buf),(len),0)
 #endif
 
 static void
 simple_read_cb(int fd, short event, void *arg)
 {
         char buf[256];
         int len;
 
+        if (arg == NULL)
+                return;
+
         len = read(fd, buf, sizeof(buf));
 
         if (len) {
                 if (!called) {
                         if (event_add(arg, NULL) == -1)
                                 exit(1);
                 }
         } else if (called == 1)
                 test_ok = 1;
 
         called++;
 }
 
 static void
 simple_write_cb(int fd, short event, void *arg)
 {
         int len;
 
+        if (arg == NULL)
+                return;
+
         len = write(fd, TEST1, strlen(TEST1) + 1);
         if (len == -1)
                 test_ok = 0;
         else
                 test_ok = 1;
 }
 
 static void
 multiple_write_cb(int fd, short event, void *arg)
 {
@@ skipping 62 matching lines @@
                 evutil_timersub(&tset, &tcalled, &tv);
 
         diff = tv.tv_sec*1000 + tv.tv_usec/1000 - SECONDS * 1000;
         if (diff < 0)
                 diff = -diff;
 
         if (diff < 100)
                 test_ok = 1;
 }
 
+#ifndef WIN32
 static void
 signal_cb_sa(int sig)
 {
         test_ok = 2;
 }
 
 static void
 signal_cb(int fd, short event, void *arg)
 {
         struct event *ev = arg;
 
         signal_del(ev);
         test_ok = 1;
 }
+#endif
 
 struct both {
         struct event ev;
         int nread;
 };
 
 static void
 combined_read_cb(int fd, short event, void *arg)
 {
         struct both *both = arg;
@@ skipping 75 matching lines @@
                 fprintf(stdout, "OK\n");
         else {
                 fprintf(stdout, "FAILED\n");
                 exit(1);
         }
         test_ok = 0;
         return (0);
 }
 
 static void
+test_registerfds(void)
+{
+        int i, j;
+        int pair[2];
+        struct event read_evs[512];
+        struct event write_evs[512];
+
+        struct event_base *base = event_base_new();
+
+        fprintf(stdout, "Testing register fds: ");
+
+        for (i = 0; i < 512; ++i) {
+                if (evutil_socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == -1) {
+                        /* run up to the limit of file descriptors */
+                        break;
+                }
+                event_set(&read_evs[i], pair[0],
+                    EV_READ|EV_PERSIST, simple_read_cb, NULL);
+                event_base_set(base, &read_evs[i]);
+                event_add(&read_evs[i], NULL);
+                event_set(&write_evs[i], pair[1],
+                    EV_WRITE|EV_PERSIST, simple_write_cb, NULL);
+                event_base_set(base, &write_evs[i]);
+                event_add(&write_evs[i], NULL);
+
+                /* just loop once */
+                event_base_loop(base, EVLOOP_ONCE);
+        }
+
+        /* now delete everything */
+        for (j = 0; j < i; ++j) {
+                event_del(&read_evs[j]);
+                event_del(&write_evs[j]);
+#ifndef WIN32
+                close(read_evs[j].ev_fd);
+                close(write_evs[j].ev_fd);
+#else
+                CloseHandle((HANDLE)read_evs[j].ev_fd);
+                CloseHandle((HANDLE)write_evs[j].ev_fd);
+#endif
+
+                /* just loop once */
+                event_base_loop(base, EVLOOP_ONCE);
+        }
+
+        event_base_free(base);
+
+        fprintf(stdout, "OK\n");
+}
+
+static void
 test_simpleread(void)
 {
         struct event ev;
 
         /* Very simple read test */
         setup_test("Simple read: ");
         
         write(pair[0], TEST1, strlen(TEST1)+1);
         shutdown(pair[0], SHUT_WR);
 
@@ skipping 440 matching lines @@
 
         raise(SIGUSR1);
         /* 1 == signal_cb, 2 == signal_cb_sa, we want our previous handler */
         if (test_ok != 2)
                 test_ok = 0;
 out:
         event_base_free(base);
         cleanup_test();
         return;
 }
+
+static void
+signal_cb_swp(int sig, short event, void *arg)
+{
+        called++;
+        if (called < 5)
+                raise(sig);
+        else
+                event_loopexit(NULL);
+}
+static void
+timeout_cb_swp(int fd, short event, void *arg)
+{
+        if (called == -1) {
+                struct timeval tv = {5, 0};
+
+                called = 0;
+                evtimer_add((struct event *)arg, &tv);
+                raise(SIGUSR1);
+                return;
+        }
+        test_ok = 0;
+        event_loopexit(NULL);
+}
+
+static void
+test_signal_while_processing(void)
+{
+        struct event_base *base = event_init();
+        struct event ev, ev_timer;
+        struct timeval tv = {0, 0};
+
+        setup_test("Receiving a signal while processing other signal: ");
+
+        called = -1;
+        test_ok = 1;
+        signal_set(&ev, SIGUSR1, signal_cb_swp, NULL);
+        signal_add(&ev, NULL);
+        evtimer_set(&ev_timer, timeout_cb_swp, &ev_timer);
+        evtimer_add(&ev_timer, &tv);
+        event_dispatch();
+
+        event_base_free(base);
+        cleanup_test();
+        return;
+}
 #endif
 
 static void
 test_free_active_base(void)
 {
         struct event_base *base1;
         struct event ev1;
         setup_test("Free active base: ");
         base1 = event_init();
         event_set(&ev1, pair[1], EV_READ, simple_read_cb, &ev1);
@@ skipping 731 matching lines @@
 #ifdef WIN32
         WORD wVersionRequested;
         WSADATA wsaData;
         int     err;
 
         wVersionRequested = MAKEWORD( 2, 2 );
 
         err = WSAStartup( wVersionRequested, &wsaData );
 #endif
 
+#ifndef WIN32
+        if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
+                return (1);
+#endif
         setvbuf(stdout, NULL, _IONBF, 0);
 
         /* Initalize the event library */
         global_base = event_init();
 
+        test_registerfds();
+
         test_evutil_strtoll();
 
         /* use the global event base and need to be called first */
         test_priorities(1);
         test_priorities(2);
         test_priorities(3);
 
         test_evbuffer();
         test_evbuffer_find();
         
@@ skipping 44 matching lines @@
         evtag_test();
 
 #ifndef WIN32
         rpc_test();
 
         test_signal_dealloc();
         test_signal_pipeloss();
         test_signal_switchbase();
         test_signal_restore();
         test_signal_assert();
+        test_signal_while_processing();
 #endif
         
         return (0);
 }