1 /*
2 * Copyright (c) 2003, 2004 Niels Provos <provos@citi.umich.edu>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifdef WIN32
29 #include <winsock2.h>
30 #include <windows.h>
31 #endif
32
33 #ifdef HAVE_CONFIG_H
34 #include "config.h"
35 #endif
36
37 #include <sys/types.h>
38 #include <sys/stat.h>
39 #ifdef HAVE_SYS_TIME_H
40 #include <sys/time.h>
41 #endif
42 #include <sys/queue.h>
43 #ifndef WIN32
44 #include <sys/socket.h>
45 #include <sys/wait.h>
46 #include <signal.h>
47 #include <unistd.h>
48 #include <netdb.h>
49 #endif
50 #include <assert.h>
51 #include <fcntl.h>
52 #include <signal.h>
53 #include <stdlib.h>
54 #include <stdio.h>
55 #include <string.h>
56 #include <errno.h>
57
58 #include "event.h"
59 #include "evutil.h"
60 #include "event-internal.h"
61 #include "log.h"
62
63 #include "regress.h"
64 #ifndef WIN32
65 #include "regress.gen.h"
66 #endif
67
68 int pair[2];
69 int test_ok;
70 static int called;
71 static char wbuf[4096];
72 static char rbuf[4096];
73 static int woff;
74 static int roff;
75 static int usepersist;
76 static struct timeval tset;
77 static struct timeval tcalled;
78 static struct event_base *global_base;
79
80 #define TEST1 "this is a test"
81 #define SECONDS 1
82
83 #ifndef SHUT_WR
84 #define SHUT_WR 1
85 #endif
86
87 #ifdef WIN32
88 #define write(fd,buf,len) send((fd),(buf),(len),0)
89 #define read(fd,buf,len) recv((fd),(buf),(len),0)
90 #endif
91
92 static void
simple_read_cb(int fd,short event,void * arg)93 simple_read_cb(int fd, short event, void *arg)
94 {
95 char buf[256];
96 int len;
97
98 if (arg == NULL)
99 return;
100
101 len = read(fd, buf, sizeof(buf));
102
103 if (len) {
104 if (!called) {
105 if (event_add(arg, NULL) == -1)
106 exit(1);
107 }
108 } else if (called == 1)
109 test_ok = 1;
110
111 called++;
112 }
113
114 static void
simple_write_cb(int fd,short event,void * arg)115 simple_write_cb(int fd, short event, void *arg)
116 {
117 int len;
118
119 if (arg == NULL)
120 return;
121
122 len = write(fd, TEST1, strlen(TEST1) + 1);
123 if (len == -1)
124 test_ok = 0;
125 else
126 test_ok = 1;
127 }
128
129 static void
multiple_write_cb(int fd,short event,void * arg)130 multiple_write_cb(int fd, short event, void *arg)
131 {
132 struct event *ev = arg;
133 int len;
134
135 len = 128;
136 if (woff + len >= sizeof(wbuf))
137 len = sizeof(wbuf) - woff;
138
139 len = write(fd, wbuf + woff, len);
140 if (len == -1) {
141 fprintf(stderr, "%s: write\n", __func__);
142 if (usepersist)
143 event_del(ev);
144 return;
145 }
146
147 woff += len;
148
149 if (woff >= sizeof(wbuf)) {
150 shutdown(fd, SHUT_WR);
151 if (usepersist)
152 event_del(ev);
153 return;
154 }
155
156 if (!usepersist) {
157 if (event_add(ev, NULL) == -1)
158 exit(1);
159 }
160 }
161
162 static void
multiple_read_cb(int fd,short event,void * arg)163 multiple_read_cb(int fd, short event, void *arg)
164 {
165 struct event *ev = arg;
166 int len;
167
168 len = read(fd, rbuf + roff, sizeof(rbuf) - roff);
169 if (len == -1)
170 fprintf(stderr, "%s: read\n", __func__);
171 if (len <= 0) {
172 if (usepersist)
173 event_del(ev);
174 return;
175 }
176
177 roff += len;
178 if (!usepersist) {
179 if (event_add(ev, NULL) == -1)
180 exit(1);
181 }
182 }
183
184 static void
timeout_cb(int fd,short event,void * arg)185 timeout_cb(int fd, short event, void *arg)
186 {
187 struct timeval tv;
188 int diff;
189
190 evutil_gettimeofday(&tcalled, NULL);
191 if (evutil_timercmp(&tcalled, &tset, >))
192 evutil_timersub(&tcalled, &tset, &tv);
193 else
194 evutil_timersub(&tset, &tcalled, &tv);
195
196 diff = tv.tv_sec*1000 + tv.tv_usec/1000 - SECONDS * 1000;
197 if (diff < 0)
198 diff = -diff;
199
200 if (diff < 100)
201 test_ok = 1;
202 }
203
204 #ifndef WIN32
205 static void
signal_cb_sa(int sig)206 signal_cb_sa(int sig)
207 {
208 test_ok = 2;
209 }
210
211 static void
signal_cb(int fd,short event,void * arg)212 signal_cb(int fd, short event, void *arg)
213 {
214 struct event *ev = arg;
215
216 signal_del(ev);
217 test_ok = 1;
218 }
219 #endif
220
221 struct both {
222 struct event ev;
223 int nread;
224 };
225
226 static void
combined_read_cb(int fd,short event,void * arg)227 combined_read_cb(int fd, short event, void *arg)
228 {
229 struct both *both = arg;
230 char buf[128];
231 int len;
232
233 len = read(fd, buf, sizeof(buf));
234 if (len == -1)
235 fprintf(stderr, "%s: read\n", __func__);
236 if (len <= 0)
237 return;
238
239 both->nread += len;
240 if (event_add(&both->ev, NULL) == -1)
241 exit(1);
242 }
243
244 static void
combined_write_cb(int fd,short event,void * arg)245 combined_write_cb(int fd, short event, void *arg)
246 {
247 struct both *both = arg;
248 char buf[128];
249 int len;
250
251 len = sizeof(buf);
252 if (len > both->nread)
253 len = both->nread;
254
255 len = write(fd, buf, len);
256 if (len == -1)
257 fprintf(stderr, "%s: write\n", __func__);
258 if (len <= 0) {
259 shutdown(fd, SHUT_WR);
260 return;
261 }
262
263 both->nread -= len;
264 if (event_add(&both->ev, NULL) == -1)
265 exit(1);
266 }
267
268 /* Test infrastructure */
269
270 static int
setup_test(const char * name)271 setup_test(const char *name)
272 {
273
274 fprintf(stdout, "%s", name);
275
276 if (evutil_socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == -1) {
277 fprintf(stderr, "%s: socketpair\n", __func__);
278 exit(1);
279 }
280
281 #ifdef HAVE_FCNTL
282 if (fcntl(pair[0], F_SETFL, O_NONBLOCK) == -1)
283 fprintf(stderr, "fcntl(O_NONBLOCK)");
284
285 if (fcntl(pair[1], F_SETFL, O_NONBLOCK) == -1)
286 fprintf(stderr, "fcntl(O_NONBLOCK)");
287 #endif
288
289 test_ok = 0;
290 called = 0;
291 return (0);
292 }
293
294 static int
cleanup_test(void)295 cleanup_test(void)
296 {
297 #ifndef WIN32
298 close(pair[0]);
299 close(pair[1]);
300 #else
301 CloseHandle((HANDLE)pair[0]);
302 CloseHandle((HANDLE)pair[1]);
303 #endif
304 if (test_ok)
305 fprintf(stdout, "OK\n");
306 else {
307 fprintf(stdout, "FAILED\n");
308 exit(1);
309 }
310 test_ok = 0;
311 return (0);
312 }
313
314 static void
test_registerfds(void)315 test_registerfds(void)
316 {
317 int i, j;
318 int pair[2];
319 struct event read_evs[512];
320 struct event write_evs[512];
321
322 struct event_base *base = event_base_new();
323
324 fprintf(stdout, "Testing register fds: ");
325
326 for (i = 0; i < 512; ++i) {
327 if (evutil_socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == -1) {
328 /* run up to the limit of file descriptors */
329 break;
330 }
331 event_set(&read_evs[i], pair[0],
332 EV_READ|EV_PERSIST, simple_read_cb, NULL);
333 event_base_set(base, &read_evs[i]);
334 event_add(&read_evs[i], NULL);
335 event_set(&write_evs[i], pair[1],
336 EV_WRITE|EV_PERSIST, simple_write_cb, NULL);
337 event_base_set(base, &write_evs[i]);
338 event_add(&write_evs[i], NULL);
339
340 /* just loop once */
341 event_base_loop(base, EVLOOP_ONCE);
342 }
343
344 /* now delete everything */
345 for (j = 0; j < i; ++j) {
346 event_del(&read_evs[j]);
347 event_del(&write_evs[j]);
348 #ifndef WIN32
349 close(read_evs[j].ev_fd);
350 close(write_evs[j].ev_fd);
351 #else
352 CloseHandle((HANDLE)read_evs[j].ev_fd);
353 CloseHandle((HANDLE)write_evs[j].ev_fd);
354 #endif
355
356 /* just loop once */
357 event_base_loop(base, EVLOOP_ONCE);
358 }
359
360 event_base_free(base);
361
362 fprintf(stdout, "OK\n");
363 }
364
365 static void
test_simpleread(void)366 test_simpleread(void)
367 {
368 struct event ev;
369
370 /* Very simple read test */
371 setup_test("Simple read: ");
372
373 write(pair[0], TEST1, strlen(TEST1)+1);
374 shutdown(pair[0], SHUT_WR);
375
376 event_set(&ev, pair[1], EV_READ, simple_read_cb, &ev);
377 if (event_add(&ev, NULL) == -1)
378 exit(1);
379 event_dispatch();
380
381 cleanup_test();
382 }
383
384 static void
test_simplewrite(void)385 test_simplewrite(void)
386 {
387 struct event ev;
388
389 /* Very simple write test */
390 setup_test("Simple write: ");
391
392 event_set(&ev, pair[0], EV_WRITE, simple_write_cb, &ev);
393 if (event_add(&ev, NULL) == -1)
394 exit(1);
395 event_dispatch();
396
397 cleanup_test();
398 }
399
400 static void
test_multiple(void)401 test_multiple(void)
402 {
403 struct event ev, ev2;
404 int i;
405
406 /* Multiple read and write test */
407 setup_test("Multiple read/write: ");
408 memset(rbuf, 0, sizeof(rbuf));
409 for (i = 0; i < sizeof(wbuf); i++)
410 wbuf[i] = i;
411
412 roff = woff = 0;
413 usepersist = 0;
414
415 event_set(&ev, pair[0], EV_WRITE, multiple_write_cb, &ev);
416 if (event_add(&ev, NULL) == -1)
417 exit(1);
418 event_set(&ev2, pair[1], EV_READ, multiple_read_cb, &ev2);
419 if (event_add(&ev2, NULL) == -1)
420 exit(1);
421 event_dispatch();
422
423 if (roff == woff)
424 test_ok = memcmp(rbuf, wbuf, sizeof(wbuf)) == 0;
425
426 cleanup_test();
427 }
428
429 static void
test_persistent(void)430 test_persistent(void)
431 {
432 struct event ev, ev2;
433 int i;
434
435 /* Multiple read and write test with persist */
436 setup_test("Persist read/write: ");
437 memset(rbuf, 0, sizeof(rbuf));
438 for (i = 0; i < sizeof(wbuf); i++)
439 wbuf[i] = i;
440
441 roff = woff = 0;
442 usepersist = 1;
443
444 event_set(&ev, pair[0], EV_WRITE|EV_PERSIST, multiple_write_cb, &ev);
445 if (event_add(&ev, NULL) == -1)
446 exit(1);
447 event_set(&ev2, pair[1], EV_READ|EV_PERSIST, multiple_read_cb, &ev2);
448 if (event_add(&ev2, NULL) == -1)
449 exit(1);
450 event_dispatch();
451
452 if (roff == woff)
453 test_ok = memcmp(rbuf, wbuf, sizeof(wbuf)) == 0;
454
455 cleanup_test();
456 }
457
458 static void
test_combined(void)459 test_combined(void)
460 {
461 struct both r1, r2, w1, w2;
462
463 setup_test("Combined read/write: ");
464 memset(&r1, 0, sizeof(r1));
465 memset(&r2, 0, sizeof(r2));
466 memset(&w1, 0, sizeof(w1));
467 memset(&w2, 0, sizeof(w2));
468
469 w1.nread = 4096;
470 w2.nread = 8192;
471
472 event_set(&r1.ev, pair[0], EV_READ, combined_read_cb, &r1);
473 event_set(&w1.ev, pair[0], EV_WRITE, combined_write_cb, &w1);
474 event_set(&r2.ev, pair[1], EV_READ, combined_read_cb, &r2);
475 event_set(&w2.ev, pair[1], EV_WRITE, combined_write_cb, &w2);
476 if (event_add(&r1.ev, NULL) == -1)
477 exit(1);
478 if (event_add(&w1.ev, NULL))
479 exit(1);
480 if (event_add(&r2.ev, NULL))
481 exit(1);
482 if (event_add(&w2.ev, NULL))
483 exit(1);
484
485 event_dispatch();
486
487 if (r1.nread == 8192 && r2.nread == 4096)
488 test_ok = 1;
489
490 cleanup_test();
491 }
492
493 static void
test_simpletimeout(void)494 test_simpletimeout(void)
495 {
496 struct timeval tv;
497 struct event ev;
498
499 setup_test("Simple timeout: ");
500
501 tv.tv_usec = 0;
502 tv.tv_sec = SECONDS;
503 evtimer_set(&ev, timeout_cb, NULL);
504 evtimer_add(&ev, &tv);
505
506 evutil_gettimeofday(&tset, NULL);
507 event_dispatch();
508
509 cleanup_test();
510 }
511
512 #ifndef WIN32
513 extern struct event_base *current_base;
514
515 static void
child_signal_cb(int fd,short event,void * arg)516 child_signal_cb(int fd, short event, void *arg)
517 {
518 struct timeval tv;
519 int *pint = arg;
520
521 *pint = 1;
522
523 tv.tv_usec = 500000;
524 tv.tv_sec = 0;
525 event_loopexit(&tv);
526 }
527
528 static void
test_fork(void)529 test_fork(void)
530 {
531 int status, got_sigchld = 0;
532 struct event ev, sig_ev;
533 pid_t pid;
534
535 setup_test("After fork: ");
536
537 write(pair[0], TEST1, strlen(TEST1)+1);
538
539 event_set(&ev, pair[1], EV_READ, simple_read_cb, &ev);
540 if (event_add(&ev, NULL) == -1)
541 exit(1);
542
543 signal_set(&sig_ev, SIGCHLD, child_signal_cb, &got_sigchld);
544 signal_add(&sig_ev, NULL);
545
546 if ((pid = fork()) == 0) {
547 /* in the child */
548 if (event_reinit(current_base) == -1) {
549 fprintf(stderr, "FAILED (reinit)\n");
550 exit(1);
551 }
552
553 signal_del(&sig_ev);
554
555 called = 0;
556
557 event_dispatch();
558
559 /* we do not send an EOF; simple_read_cb requires an EOF
560 * to set test_ok. we just verify that the callback was
561 * called. */
562 exit(test_ok != 0 || called != 2 ? -2 : 76);
563 }
564
565 /* wait for the child to read the data */
566 sleep(1);
567
568 write(pair[0], TEST1, strlen(TEST1)+1);
569
570 if (waitpid(pid, &status, 0) == -1) {
571 fprintf(stderr, "FAILED (fork)\n");
572 exit(1);
573 }
574
575 if (WEXITSTATUS(status) != 76) {
576 fprintf(stderr, "FAILED (exit): %d\n", WEXITSTATUS(status));
577 exit(1);
578 }
579
580 /* test that the current event loop still works */
581 write(pair[0], TEST1, strlen(TEST1)+1);
582 shutdown(pair[0], SHUT_WR);
583
584 event_dispatch();
585
586 if (!got_sigchld) {
587 fprintf(stdout, "FAILED (sigchld)\n");
588 exit(1);
589 }
590
591 signal_del(&sig_ev);
592
593 cleanup_test();
594 }
595
596 static void
test_simplesignal(void)597 test_simplesignal(void)
598 {
599 struct event ev;
600 struct itimerval itv;
601
602 setup_test("Simple signal: ");
603 signal_set(&ev, SIGALRM, signal_cb, &ev);
604 signal_add(&ev, NULL);
605 /* find bugs in which operations are re-ordered */
606 signal_del(&ev);
607 signal_add(&ev, NULL);
608
609 memset(&itv, 0, sizeof(itv));
610 itv.it_value.tv_sec = 1;
611 if (setitimer(ITIMER_REAL, &itv, NULL) == -1)
612 goto skip_simplesignal;
613
614 event_dispatch();
615 skip_simplesignal:
616 if (signal_del(&ev) == -1)
617 test_ok = 0;
618
619 cleanup_test();
620 }
621
622 static void
test_multiplesignal(void)623 test_multiplesignal(void)
624 {
625 struct event ev_one, ev_two;
626 struct itimerval itv;
627
628 setup_test("Multiple signal: ");
629
630 signal_set(&ev_one, SIGALRM, signal_cb, &ev_one);
631 signal_add(&ev_one, NULL);
632
633 signal_set(&ev_two, SIGALRM, signal_cb, &ev_two);
634 signal_add(&ev_two, NULL);
635
636 memset(&itv, 0, sizeof(itv));
637 itv.it_value.tv_sec = 1;
638 if (setitimer(ITIMER_REAL, &itv, NULL) == -1)
639 goto skip_simplesignal;
640
641 event_dispatch();
642
643 skip_simplesignal:
644 if (signal_del(&ev_one) == -1)
645 test_ok = 0;
646 if (signal_del(&ev_two) == -1)
647 test_ok = 0;
648
649 cleanup_test();
650 }
651
652 static void
test_immediatesignal(void)653 test_immediatesignal(void)
654 {
655 struct event ev;
656
657 test_ok = 0;
658 printf("Immediate signal: ");
659 signal_set(&ev, SIGUSR1, signal_cb, &ev);
660 signal_add(&ev, NULL);
661 raise(SIGUSR1);
662 event_loop(EVLOOP_NONBLOCK);
663 signal_del(&ev);
664 cleanup_test();
665 }
666
667 static void
test_signal_dealloc(void)668 test_signal_dealloc(void)
669 {
670 /* make sure that signal_event is event_del'ed and pipe closed */
671 struct event ev;
672 struct event_base *base = event_init();
673 printf("Signal dealloc: ");
674 signal_set(&ev, SIGUSR1, signal_cb, &ev);
675 signal_add(&ev, NULL);
676 signal_del(&ev);
677 event_base_free(base);
678 /* If we got here without asserting, we're fine. */
679 test_ok = 1;
680 cleanup_test();
681 }
682
683 static void
test_signal_pipeloss(void)684 test_signal_pipeloss(void)
685 {
686 /* make sure that the base1 pipe is closed correctly. */
687 struct event_base *base1, *base2;
688 int pipe1;
689 test_ok = 0;
690 printf("Signal pipeloss: ");
691 base1 = event_init();
692 pipe1 = base1->sig.ev_signal_pair[0];
693 base2 = event_init();
694 event_base_free(base2);
695 event_base_free(base1);
696 if (close(pipe1) != -1 || errno!=EBADF) {
697 /* fd must be closed, so second close gives -1, EBADF */
698 printf("signal pipe not closed. ");
699 test_ok = 0;
700 } else {
701 test_ok = 1;
702 }
703 cleanup_test();
704 }
705
706 /*
707 * make two bases to catch signals, use both of them. this only works
708 * for event mechanisms that use our signal pipe trick. kqueue handles
709 * signals internally, and all interested kqueues get all the signals.
710 */
711 static void
test_signal_switchbase(void)712 test_signal_switchbase(void)
713 {
714 struct event ev1, ev2;
715 struct event_base *base1, *base2;
716 int is_kqueue;
717 test_ok = 0;
718 printf("Signal switchbase: ");
719 base1 = event_init();
720 base2 = event_init();
721 is_kqueue = !strcmp(event_get_method(),"kqueue");
722 signal_set(&ev1, SIGUSR1, signal_cb, &ev1);
723 signal_set(&ev2, SIGUSR1, signal_cb, &ev2);
724 if (event_base_set(base1, &ev1) ||
725 event_base_set(base2, &ev2) ||
726 event_add(&ev1, NULL) ||
727 event_add(&ev2, NULL)) {
728 fprintf(stderr, "%s: cannot set base, add\n", __func__);
729 exit(1);
730 }
731
732 test_ok = 0;
733 /* can handle signal before loop is called */
734 raise(SIGUSR1);
735 event_base_loop(base2, EVLOOP_NONBLOCK);
736 if (is_kqueue) {
737 if (!test_ok)
738 goto done;
739 test_ok = 0;
740 }
741 event_base_loop(base1, EVLOOP_NONBLOCK);
742 if (test_ok && !is_kqueue) {
743 test_ok = 0;
744
745 /* set base1 to handle signals */
746 event_base_loop(base1, EVLOOP_NONBLOCK);
747 raise(SIGUSR1);
748 event_base_loop(base1, EVLOOP_NONBLOCK);
749 event_base_loop(base2, EVLOOP_NONBLOCK);
750 }
751 done:
752 event_base_free(base1);
753 event_base_free(base2);
754 cleanup_test();
755 }
756
757 /*
758 * assert that a signal event removed from the event queue really is
759 * removed - with no possibility of it's parent handler being fired.
760 */
761 static void
test_signal_assert(void)762 test_signal_assert(void)
763 {
764 struct event ev;
765 struct event_base *base = event_init();
766 test_ok = 0;
767 printf("Signal handler assert: ");
768 /* use SIGCONT so we don't kill ourselves when we signal to nowhere */
769 signal_set(&ev, SIGCONT, signal_cb, &ev);
770 signal_add(&ev, NULL);
771 /*
772 * if signal_del() fails to reset the handler, it's current handler
773 * will still point to evsignal_handler().
774 */
775 signal_del(&ev);
776
777 raise(SIGCONT);
778 /* only way to verify we were in evsignal_handler() */
779 if (base->sig.evsignal_caught)
780 test_ok = 0;
781 else
782 test_ok = 1;
783
784 event_base_free(base);
785 cleanup_test();
786 return;
787 }
788
789 /*
790 * assert that we restore our previous signal handler properly.
791 */
792 static void
test_signal_restore(void)793 test_signal_restore(void)
794 {
795 struct event ev;
796 struct event_base *base = event_init();
797 #ifdef HAVE_SIGACTION
798 struct sigaction sa;
799 #endif
800
801 test_ok = 0;
802 printf("Signal handler restore: ");
803 #ifdef HAVE_SIGACTION
804 sa.sa_handler = signal_cb_sa;
805 sa.sa_flags = 0x0;
806 sigemptyset(&sa.sa_mask);
807 if (sigaction(SIGUSR1, &sa, NULL) == -1)
808 goto out;
809 #else
810 if (signal(SIGUSR1, signal_cb_sa) == SIG_ERR)
811 goto out;
812 #endif
813 signal_set(&ev, SIGUSR1, signal_cb, &ev);
814 signal_add(&ev, NULL);
815 signal_del(&ev);
816
817 raise(SIGUSR1);
818 /* 1 == signal_cb, 2 == signal_cb_sa, we want our previous handler */
819 if (test_ok != 2)
820 test_ok = 0;
821 out:
822 event_base_free(base);
823 cleanup_test();
824 return;
825 }
826
827 static void
signal_cb_swp(int sig,short event,void * arg)828 signal_cb_swp(int sig, short event, void *arg)
829 {
830 called++;
831 if (called < 5)
832 raise(sig);
833 else
834 event_loopexit(NULL);
835 }
836 static void
timeout_cb_swp(int fd,short event,void * arg)837 timeout_cb_swp(int fd, short event, void *arg)
838 {
839 if (called == -1) {
840 struct timeval tv = {5, 0};
841
842 called = 0;
843 evtimer_add((struct event *)arg, &tv);
844 raise(SIGUSR1);
845 return;
846 }
847 test_ok = 0;
848 event_loopexit(NULL);
849 }
850
851 static void
test_signal_while_processing(void)852 test_signal_while_processing(void)
853 {
854 struct event_base *base = event_init();
855 struct event ev, ev_timer;
856 struct timeval tv = {0, 0};
857
858 setup_test("Receiving a signal while processing other signal: ");
859
860 called = -1;
861 test_ok = 1;
862 signal_set(&ev, SIGUSR1, signal_cb_swp, NULL);
863 signal_add(&ev, NULL);
864 evtimer_set(&ev_timer, timeout_cb_swp, &ev_timer);
865 evtimer_add(&ev_timer, &tv);
866 event_dispatch();
867
868 event_base_free(base);
869 cleanup_test();
870 return;
871 }
872 #endif
873
874 static void
test_free_active_base(void)875 test_free_active_base(void)
876 {
877 struct event_base *base1;
878 struct event ev1;
879 setup_test("Free active base: ");
880 base1 = event_init();
881 event_set(&ev1, pair[1], EV_READ, simple_read_cb, &ev1);
882 event_base_set(base1, &ev1);
883 event_add(&ev1, NULL);
884 /* event_del(&ev1); */
885 event_base_free(base1);
886 test_ok = 1;
887 cleanup_test();
888 }
889
890 static void
test_event_base_new(void)891 test_event_base_new(void)
892 {
893 struct event_base *base;
894 struct event ev1;
895 setup_test("Event base new: ");
896
897 write(pair[0], TEST1, strlen(TEST1)+1);
898 shutdown(pair[0], SHUT_WR);
899
900 base = event_base_new();
901 event_set(&ev1, pair[1], EV_READ, simple_read_cb, &ev1);
902 event_base_set(base, &ev1);
903 event_add(&ev1, NULL);
904
905 event_base_dispatch(base);
906
907 event_base_free(base);
908 test_ok = 1;
909 cleanup_test();
910 }
911
912 static void
test_loopexit(void)913 test_loopexit(void)
914 {
915 struct timeval tv, tv_start, tv_end;
916 struct event ev;
917
918 setup_test("Loop exit: ");
919
920 tv.tv_usec = 0;
921 tv.tv_sec = 60*60*24;
922 evtimer_set(&ev, timeout_cb, NULL);
923 evtimer_add(&ev, &tv);
924
925 tv.tv_usec = 0;
926 tv.tv_sec = 1;
927 event_loopexit(&tv);
928
929 evutil_gettimeofday(&tv_start, NULL);
930 event_dispatch();
931 evutil_gettimeofday(&tv_end, NULL);
932 evutil_timersub(&tv_end, &tv_start, &tv_end);
933
934 evtimer_del(&ev);
935
936 if (tv.tv_sec < 2)
937 test_ok = 1;
938
939 cleanup_test();
940 }
941
942 static void
test_loopexit_multiple(void)943 test_loopexit_multiple(void)
944 {
945 struct timeval tv;
946 struct event_base *base;
947
948 setup_test("Loop Multiple exit: ");
949
950 base = event_base_new();
951
952 tv.tv_usec = 0;
953 tv.tv_sec = 1;
954 event_base_loopexit(base, &tv);
955
956 tv.tv_usec = 0;
957 tv.tv_sec = 2;
958 event_base_loopexit(base, &tv);
959
960 event_base_dispatch(base);
961
962 event_base_free(base);
963
964 test_ok = 1;
965
966 cleanup_test();
967 }
968
969 static void
break_cb(int fd,short events,void * arg)970 break_cb(int fd, short events, void *arg)
971 {
972 test_ok = 1;
973 event_loopbreak();
974 }
975
976 static void
fail_cb(int fd,short events,void * arg)977 fail_cb(int fd, short events, void *arg)
978 {
979 test_ok = 0;
980 }
981
982 static void
test_loopbreak(void)983 test_loopbreak(void)
984 {
985 struct event ev1, ev2;
986 struct timeval tv;
987
988 setup_test("Loop break: ");
989
990 tv.tv_sec = 0;
991 tv.tv_usec = 0;
992 evtimer_set(&ev1, break_cb, NULL);
993 evtimer_add(&ev1, &tv);
994 evtimer_set(&ev2, fail_cb, NULL);
995 evtimer_add(&ev2, &tv);
996
997 event_dispatch();
998
999 evtimer_del(&ev1);
1000 evtimer_del(&ev2);
1001
1002 cleanup_test();
1003 }
1004
1005 static void
test_evbuffer(void)1006 test_evbuffer(void) {
1007
1008 struct evbuffer *evb = evbuffer_new();
1009 setup_test("Testing Evbuffer: ");
1010
1011 evbuffer_add_printf(evb, "%s/%d", "hello", 1);
1012
1013 if (EVBUFFER_LENGTH(evb) == 7 &&
1014 strcmp((char*)EVBUFFER_DATA(evb), "hello/1") == 0)
1015 test_ok = 1;
1016
1017 evbuffer_free(evb);
1018
1019 cleanup_test();
1020 }
1021
1022 static void
test_evbuffer_find(void)1023 test_evbuffer_find(void)
1024 {
1025 u_char* p;
1026 const char* test1 = "1234567890\r\n";
1027 const char* test2 = "1234567890\r";
1028 #define EVBUFFER_INITIAL_LENGTH 256
1029 char test3[EVBUFFER_INITIAL_LENGTH];
1030 unsigned int i;
1031 struct evbuffer * buf = evbuffer_new();
1032
1033 /* make sure evbuffer_find doesn't match past the end of the buffer */
1034 fprintf(stdout, "Testing evbuffer_find 1: ");
1035 evbuffer_add(buf, (u_char*)test1, strlen(test1));
1036 evbuffer_drain(buf, strlen(test1));
1037 evbuffer_add(buf, (u_char*)test2, strlen(test2));
1038 p = evbuffer_find(buf, (u_char*)"\r\n", 2);
1039 if (p == NULL) {
1040 fprintf(stdout, "OK\n");
1041 } else {
1042 fprintf(stdout, "FAILED\n");
1043 exit(1);
1044 }
1045
1046 /*
1047 * drain the buffer and do another find; in r309 this would
1048 * read past the allocated buffer causing a valgrind error.
1049 */
1050 fprintf(stdout, "Testing evbuffer_find 2: ");
1051 evbuffer_drain(buf, strlen(test2));
1052 for (i = 0; i < EVBUFFER_INITIAL_LENGTH; ++i)
1053 test3[i] = 'a';
1054 test3[EVBUFFER_INITIAL_LENGTH - 1] = 'x';
1055 evbuffer_add(buf, (u_char *)test3, EVBUFFER_INITIAL_LENGTH);
1056 p = evbuffer_find(buf, (u_char *)"xy", 2);
1057 if (p == NULL) {
1058 printf("OK\n");
1059 } else {
1060 fprintf(stdout, "FAILED\n");
1061 exit(1);
1062 }
1063
1064 /* simple test for match at end of allocated buffer */
1065 fprintf(stdout, "Testing evbuffer_find 3: ");
1066 p = evbuffer_find(buf, (u_char *)"ax", 2);
1067 if (p != NULL && strncmp((char*)p, "ax", 2) == 0) {
1068 printf("OK\n");
1069 } else {
1070 fprintf(stdout, "FAILED\n");
1071 exit(1);
1072 }
1073
1074 evbuffer_free(buf);
1075 }
1076
1077 /*
1078 * simple bufferevent test
1079 */
1080
1081 static void
readcb(struct bufferevent * bev,void * arg)1082 readcb(struct bufferevent *bev, void *arg)
1083 {
1084 if (EVBUFFER_LENGTH(bev->input) == 8333) {
1085 bufferevent_disable(bev, EV_READ);
1086 test_ok++;
1087 }
1088 }
1089
1090 static void
writecb(struct bufferevent * bev,void * arg)1091 writecb(struct bufferevent *bev, void *arg)
1092 {
1093 if (EVBUFFER_LENGTH(bev->output) == 0)
1094 test_ok++;
1095 }
1096
1097 static void
errorcb(struct bufferevent * bev,short what,void * arg)1098 errorcb(struct bufferevent *bev, short what, void *arg)
1099 {
1100 test_ok = -2;
1101 }
1102
1103 static void
test_bufferevent(void)1104 test_bufferevent(void)
1105 {
1106 struct bufferevent *bev1, *bev2;
1107 char buffer[8333];
1108 int i;
1109
1110 setup_test("Bufferevent: ");
1111
1112 bev1 = bufferevent_new(pair[0], readcb, writecb, errorcb, NULL);
1113 bev2 = bufferevent_new(pair[1], readcb, writecb, errorcb, NULL);
1114
1115 bufferevent_disable(bev1, EV_READ);
1116 bufferevent_enable(bev2, EV_READ);
1117
1118 for (i = 0; i < sizeof(buffer); i++)
1119 buffer[i] = i;
1120
1121 bufferevent_write(bev1, buffer, sizeof(buffer));
1122
1123 event_dispatch();
1124
1125 bufferevent_free(bev1);
1126 bufferevent_free(bev2);
1127
1128 if (test_ok != 2)
1129 test_ok = 0;
1130
1131 cleanup_test();
1132 }
1133
1134 /*
1135 * test watermarks and bufferevent
1136 */
1137
1138 static void
wm_readcb(struct bufferevent * bev,void * arg)1139 wm_readcb(struct bufferevent *bev, void *arg)
1140 {
1141 int len = EVBUFFER_LENGTH(bev->input);
1142 static int nread;
1143
1144 assert(len >= 10 && len <= 20);
1145
1146 evbuffer_drain(bev->input, len);
1147
1148 nread += len;
1149 if (nread == 65000) {
1150 bufferevent_disable(bev, EV_READ);
1151 test_ok++;
1152 }
1153 }
1154
1155 static void
wm_writecb(struct bufferevent * bev,void * arg)1156 wm_writecb(struct bufferevent *bev, void *arg)
1157 {
1158 if (EVBUFFER_LENGTH(bev->output) == 0)
1159 test_ok++;
1160 }
1161
1162 static void
wm_errorcb(struct bufferevent * bev,short what,void * arg)1163 wm_errorcb(struct bufferevent *bev, short what, void *arg)
1164 {
1165 test_ok = -2;
1166 }
1167
1168 static void
test_bufferevent_watermarks(void)1169 test_bufferevent_watermarks(void)
1170 {
1171 struct bufferevent *bev1, *bev2;
1172 char buffer[65000];
1173 int i;
1174
1175 setup_test("Bufferevent Watermarks: ");
1176
1177 bev1 = bufferevent_new(pair[0], NULL, wm_writecb, wm_errorcb, NULL);
1178 bev2 = bufferevent_new(pair[1], wm_readcb, NULL, wm_errorcb, NULL);
1179
1180 bufferevent_disable(bev1, EV_READ);
1181 bufferevent_enable(bev2, EV_READ);
1182
1183 for (i = 0; i < sizeof(buffer); i++)
1184 buffer[i] = i;
1185
1186 bufferevent_write(bev1, buffer, sizeof(buffer));
1187
1188 /* limit the reading on the receiving bufferevent */
1189 bufferevent_setwatermark(bev2, EV_READ, 10, 20);
1190
1191 event_dispatch();
1192
1193 bufferevent_free(bev1);
1194 bufferevent_free(bev2);
1195
1196 if (test_ok != 2)
1197 test_ok = 0;
1198
1199 cleanup_test();
1200 }
1201
1202 struct test_pri_event {
1203 struct event ev;
1204 int count;
1205 };
1206
1207 static void
test_priorities_cb(int fd,short what,void * arg)1208 test_priorities_cb(int fd, short what, void *arg)
1209 {
1210 struct test_pri_event *pri = arg;
1211 struct timeval tv;
1212
1213 if (pri->count == 3) {
1214 event_loopexit(NULL);
1215 return;
1216 }
1217
1218 pri->count++;
1219
1220 evutil_timerclear(&tv);
1221 event_add(&pri->ev, &tv);
1222 }
1223
1224 static void
test_priorities(int npriorities)1225 test_priorities(int npriorities)
1226 {
1227 char buf[32];
1228 struct test_pri_event one, two;
1229 struct timeval tv;
1230
1231 evutil_snprintf(buf, sizeof(buf), "Testing Priorities %d: ", npriorities);
1232 setup_test(buf);
1233
1234 event_base_priority_init(global_base, npriorities);
1235
1236 memset(&one, 0, sizeof(one));
1237 memset(&two, 0, sizeof(two));
1238
1239 timeout_set(&one.ev, test_priorities_cb, &one);
1240 if (event_priority_set(&one.ev, 0) == -1) {
1241 fprintf(stderr, "%s: failed to set priority", __func__);
1242 exit(1);
1243 }
1244
1245 timeout_set(&two.ev, test_priorities_cb, &two);
1246 if (event_priority_set(&two.ev, npriorities - 1) == -1) {
1247 fprintf(stderr, "%s: failed to set priority", __func__);
1248 exit(1);
1249 }
1250
1251 evutil_timerclear(&tv);
1252
1253 if (event_add(&one.ev, &tv) == -1)
1254 exit(1);
1255 if (event_add(&two.ev, &tv) == -1)
1256 exit(1);
1257
1258 event_dispatch();
1259
1260 event_del(&one.ev);
1261 event_del(&two.ev);
1262
1263 if (npriorities == 1) {
1264 if (one.count == 3 && two.count == 3)
1265 test_ok = 1;
1266 } else if (npriorities == 2) {
1267 /* Two is called once because event_loopexit is priority 1 */
1268 if (one.count == 3 && two.count == 1)
1269 test_ok = 1;
1270 } else {
1271 if (one.count == 3 && two.count == 0)
1272 test_ok = 1;
1273 }
1274
1275 cleanup_test();
1276 }
1277
1278 static void
test_multiple_cb(int fd,short event,void * arg)1279 test_multiple_cb(int fd, short event, void *arg)
1280 {
1281 if (event & EV_READ)
1282 test_ok |= 1;
1283 else if (event & EV_WRITE)
1284 test_ok |= 2;
1285 }
1286
1287 static void
test_multiple_events_for_same_fd(void)1288 test_multiple_events_for_same_fd(void)
1289 {
1290 struct event e1, e2;
1291
1292 setup_test("Multiple events for same fd: ");
1293
1294 event_set(&e1, pair[0], EV_READ, test_multiple_cb, NULL);
1295 event_add(&e1, NULL);
1296 event_set(&e2, pair[0], EV_WRITE, test_multiple_cb, NULL);
1297 event_add(&e2, NULL);
1298 event_loop(EVLOOP_ONCE);
1299 event_del(&e2);
1300 write(pair[1], TEST1, strlen(TEST1)+1);
1301 event_loop(EVLOOP_ONCE);
1302 event_del(&e1);
1303
1304 if (test_ok != 3)
1305 test_ok = 0;
1306
1307 cleanup_test();
1308 }
1309
1310 int evtag_decode_int(uint32_t *pnumber, struct evbuffer *evbuf);
1311 int evtag_encode_tag(struct evbuffer *evbuf, uint32_t number);
1312 int evtag_decode_tag(uint32_t *pnumber, struct evbuffer *evbuf);
1313
1314 static void
read_once_cb(int fd,short event,void * arg)1315 read_once_cb(int fd, short event, void *arg)
1316 {
1317 char buf[256];
1318 int len;
1319
1320 len = read(fd, buf, sizeof(buf));
1321
1322 if (called) {
1323 test_ok = 0;
1324 } else if (len) {
1325 /* Assumes global pair[0] can be used for writing */
1326 write(pair[0], TEST1, strlen(TEST1)+1);
1327 test_ok = 1;
1328 }
1329
1330 called++;
1331 }
1332
1333 static void
test_want_only_once(void)1334 test_want_only_once(void)
1335 {
1336 struct event ev;
1337 struct timeval tv;
1338
1339 /* Very simple read test */
1340 setup_test("Want read only once: ");
1341
1342 write(pair[0], TEST1, strlen(TEST1)+1);
1343
1344 /* Setup the loop termination */
1345 evutil_timerclear(&tv);
1346 tv.tv_sec = 1;
1347 event_loopexit(&tv);
1348
1349 event_set(&ev, pair[1], EV_READ, read_once_cb, &ev);
1350 if (event_add(&ev, NULL) == -1)
1351 exit(1);
1352 event_dispatch();
1353
1354 cleanup_test();
1355 }
1356
1357 #define TEST_MAX_INT 6
1358
1359 static void
evtag_int_test(void)1360 evtag_int_test(void)
1361 {
1362 struct evbuffer *tmp = evbuffer_new();
1363 uint32_t integers[TEST_MAX_INT] = {
1364 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
1365 };
1366 uint32_t integer;
1367 int i;
1368
1369 for (i = 0; i < TEST_MAX_INT; i++) {
1370 int oldlen, newlen;
1371 oldlen = EVBUFFER_LENGTH(tmp);
1372 encode_int(tmp, integers[i]);
1373 newlen = EVBUFFER_LENGTH(tmp);
1374 fprintf(stdout, "\t\tencoded 0x%08x with %d bytes\n",
1375 integers[i], newlen - oldlen);
1376 }
1377
1378 for (i = 0; i < TEST_MAX_INT; i++) {
1379 if (evtag_decode_int(&integer, tmp) == -1) {
1380 fprintf(stderr, "decode %d failed", i);
1381 exit(1);
1382 }
1383 if (integer != integers[i]) {
1384 fprintf(stderr, "got %x, wanted %x",
1385 integer, integers[i]);
1386 exit(1);
1387 }
1388 }
1389
1390 if (EVBUFFER_LENGTH(tmp) != 0) {
1391 fprintf(stderr, "trailing data");
1392 exit(1);
1393 }
1394 evbuffer_free(tmp);
1395
1396 fprintf(stdout, "\t%s: OK\n", __func__);
1397 }
1398
1399 static void
evtag_fuzz(void)1400 evtag_fuzz(void)
1401 {
1402 u_char buffer[4096];
1403 struct evbuffer *tmp = evbuffer_new();
1404 struct timeval tv;
1405 int i, j;
1406
1407 int not_failed = 0;
1408 for (j = 0; j < 100; j++) {
1409 for (i = 0; i < sizeof(buffer); i++)
1410 buffer[i] = rand();
1411 evbuffer_drain(tmp, -1);
1412 evbuffer_add(tmp, buffer, sizeof(buffer));
1413
1414 if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1)
1415 not_failed++;
1416 }
1417
1418 /* The majority of decodes should fail */
1419 if (not_failed >= 10) {
1420 fprintf(stderr, "evtag_unmarshal should have failed");
1421 exit(1);
1422 }
1423
1424 /* Now insert some corruption into the tag length field */
1425 evbuffer_drain(tmp, -1);
1426 evutil_timerclear(&tv);
1427 tv.tv_sec = 1;
1428 evtag_marshal_timeval(tmp, 0, &tv);
1429 evbuffer_add(tmp, buffer, sizeof(buffer));
1430
1431 EVBUFFER_DATA(tmp)[1] = 0xff;
1432 if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1) {
1433 fprintf(stderr, "evtag_unmarshal_timeval should have failed");
1434 exit(1);
1435 }
1436
1437 evbuffer_free(tmp);
1438
1439 fprintf(stdout, "\t%s: OK\n", __func__);
1440 }
1441
1442 static void
evtag_tag_encoding(void)1443 evtag_tag_encoding(void)
1444 {
1445 struct evbuffer *tmp = evbuffer_new();
1446 uint32_t integers[TEST_MAX_INT] = {
1447 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
1448 };
1449 uint32_t integer;
1450 int i;
1451
1452 for (i = 0; i < TEST_MAX_INT; i++) {
1453 int oldlen, newlen;
1454 oldlen = EVBUFFER_LENGTH(tmp);
1455 evtag_encode_tag(tmp, integers[i]);
1456 newlen = EVBUFFER_LENGTH(tmp);
1457 fprintf(stdout, "\t\tencoded 0x%08x with %d bytes\n",
1458 integers[i], newlen - oldlen);
1459 }
1460
1461 for (i = 0; i < TEST_MAX_INT; i++) {
1462 if (evtag_decode_tag(&integer, tmp) == -1) {
1463 fprintf(stderr, "decode %d failed", i);
1464 exit(1);
1465 }
1466 if (integer != integers[i]) {
1467 fprintf(stderr, "got %x, wanted %x",
1468 integer, integers[i]);
1469 exit(1);
1470 }
1471 }
1472
1473 if (EVBUFFER_LENGTH(tmp) != 0) {
1474 fprintf(stderr, "trailing data");
1475 exit(1);
1476 }
1477 evbuffer_free(tmp);
1478
1479 fprintf(stdout, "\t%s: OK\n", __func__);
1480 }
1481
1482 static void
evtag_test(void)1483 evtag_test(void)
1484 {
1485 fprintf(stdout, "Testing Tagging:\n");
1486
1487 evtag_init();
1488 evtag_int_test();
1489 evtag_fuzz();
1490
1491 evtag_tag_encoding();
1492
1493 fprintf(stdout, "OK\n");
1494 }
1495
1496 #ifndef WIN32
1497 static void
rpc_test(void)1498 rpc_test(void)
1499 {
1500 struct msg *msg, *msg2;
1501 struct kill *attack;
1502 struct run *run;
1503 struct evbuffer *tmp = evbuffer_new();
1504 struct timeval tv_start, tv_end;
1505 uint32_t tag;
1506 int i;
1507
1508 fprintf(stdout, "Testing RPC: ");
1509
1510 msg = msg_new();
1511 EVTAG_ASSIGN(msg, from_name, "niels");
1512 EVTAG_ASSIGN(msg, to_name, "phoenix");
1513
1514 if (EVTAG_GET(msg, attack, &attack) == -1) {
1515 fprintf(stderr, "Failed to set kill message.\n");
1516 exit(1);
1517 }
1518
1519 EVTAG_ASSIGN(attack, weapon, "feather");
1520 EVTAG_ASSIGN(attack, action, "tickle");
1521
1522 evutil_gettimeofday(&tv_start, NULL);
1523 for (i = 0; i < 1000; ++i) {
1524 run = EVTAG_ADD(msg, run);
1525 if (run == NULL) {
1526 fprintf(stderr, "Failed to add run message.\n");
1527 exit(1);
1528 }
1529 EVTAG_ASSIGN(run, how, "very fast but with some data in it");
1530 EVTAG_ASSIGN(run, fixed_bytes,
1531 (unsigned char*)"012345678901234567890123");
1532 }
1533
1534 if (msg_complete(msg) == -1) {
1535 fprintf(stderr, "Failed to make complete message.\n");
1536 exit(1);
1537 }
1538
1539 evtag_marshal_msg(tmp, 0xdeaf, msg);
1540
1541 if (evtag_peek(tmp, &tag) == -1) {
1542 fprintf(stderr, "Failed to peak tag.\n");
1543 exit (1);
1544 }
1545
1546 if (tag != 0xdeaf) {
1547 fprintf(stderr, "Got incorrect tag: %0x.\n", tag);
1548 exit (1);
1549 }
1550
1551 msg2 = msg_new();
1552 if (evtag_unmarshal_msg(tmp, 0xdeaf, msg2) == -1) {
1553 fprintf(stderr, "Failed to unmarshal message.\n");
1554 exit(1);
1555 }
1556
1557 evutil_gettimeofday(&tv_end, NULL);
1558 evutil_timersub(&tv_end, &tv_start, &tv_end);
1559 fprintf(stderr, "(%.1f us/add) ",
1560 (float)tv_end.tv_sec/(float)i * 1000000.0 +
1561 tv_end.tv_usec / (float)i);
1562
1563 if (!EVTAG_HAS(msg2, from_name) ||
1564 !EVTAG_HAS(msg2, to_name) ||
1565 !EVTAG_HAS(msg2, attack)) {
1566 fprintf(stderr, "Missing data structures.\n");
1567 exit(1);
1568 }
1569
1570 if (EVTAG_LEN(msg2, run) != i) {
1571 fprintf(stderr, "Wrong number of run messages.\n");
1572 exit(1);
1573 }
1574
1575 msg_free(msg);
1576 msg_free(msg2);
1577
1578 evbuffer_free(tmp);
1579
1580 fprintf(stdout, "OK\n");
1581 }
1582 #endif
1583
1584 static void
test_evutil_strtoll(void)1585 test_evutil_strtoll(void)
1586 {
1587 const char *s;
1588 char *endptr;
1589 setup_test("evutil_stroll: ");
1590 test_ok = 0;
1591
1592 if (evutil_strtoll("5000000000", NULL, 10) != ((ev_int64_t)5000000)*1000)
1593 goto err;
1594 if (evutil_strtoll("-5000000000", NULL, 10) != ((ev_int64_t)5000000)*-1000)
1595 goto err;
1596 s = " 99999stuff";
1597 if (evutil_strtoll(s, &endptr, 10) != (ev_int64_t)99999)
1598 goto err;
1599 if (endptr != s+6)
1600 goto err;
1601 if (evutil_strtoll("foo", NULL, 10) != 0)
1602 goto err;
1603
1604 test_ok = 1;
1605 err:
1606 cleanup_test();
1607 }
1608
1609
1610 int
main(int argc,char ** argv)1611 main (int argc, char **argv)
1612 {
1613 #ifdef WIN32
1614 WORD wVersionRequested;
1615 WSADATA wsaData;
1616 int err;
1617
1618 wVersionRequested = MAKEWORD( 2, 2 );
1619
1620 err = WSAStartup( wVersionRequested, &wsaData );
1621 #endif
1622
1623 #ifndef WIN32
1624 if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
1625 return (1);
1626 #endif
1627 setvbuf(stdout, NULL, _IONBF, 0);
1628
1629 /* Initalize the event library */
1630 global_base = event_init();
1631
1632 test_registerfds();
1633
1634 test_evutil_strtoll();
1635
1636 /* use the global event base and need to be called first */
1637 test_priorities(1);
1638 test_priorities(2);
1639 test_priorities(3);
1640
1641 test_evbuffer();
1642 test_evbuffer_find();
1643
1644 test_bufferevent();
1645 test_bufferevent_watermarks();
1646
1647 test_free_active_base();
1648
1649 test_event_base_new();
1650
1651 http_suite();
1652
1653 #ifndef WIN32
1654 rpc_suite();
1655 #endif
1656
1657 dns_suite();
1658
1659 #ifndef WIN32
1660 test_fork();
1661 #endif
1662
1663 test_simpleread();
1664
1665 test_simplewrite();
1666
1667 test_multiple();
1668
1669 test_persistent();
1670
1671 test_combined();
1672
1673 test_simpletimeout();
1674 #ifndef WIN32
1675 test_simplesignal();
1676 test_multiplesignal();
1677 test_immediatesignal();
1678 #endif
1679 test_loopexit();
1680 test_loopbreak();
1681
1682 test_loopexit_multiple();
1683
1684 test_multiple_events_for_same_fd();
1685
1686 test_want_only_once();
1687
1688 evtag_test();
1689
1690 #ifndef WIN32
1691 rpc_test();
1692
1693 test_signal_dealloc();
1694 test_signal_pipeloss();
1695 test_signal_switchbase();
1696 test_signal_restore();
1697 test_signal_assert();
1698 test_signal_while_processing();
1699 #endif
1700
1701 return (0);
1702 }
1703
1704