1 /*
2 * Copyright (c) 2003, 2004 Niels Provos <[email protected]>
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_readln(void)1023 test_evbuffer_readln(void)
1024 {
1025 struct evbuffer *evb = evbuffer_new();
1026 struct evbuffer *evb_tmp = evbuffer_new();
1027 const char *s;
1028 char *cp = NULL;
1029 size_t sz;
1030
1031 #define tt_line_eq(content) \
1032 if (!cp || sz != strlen(content) || strcmp(cp, content)) { \
1033 fprintf(stdout, "FAILED\n"); \
1034 exit(1); \
1035 }
1036 #define tt_assert(expression) \
1037 if (!(expression)) { \
1038 fprintf(stdout, "FAILED\n"); \
1039 exit(1); \
1040 } \
1041
1042 /* Test EOL_ANY. */
1043 fprintf(stdout, "Testing evbuffer_readln EOL_ANY: ");
1044
1045 s = "complex silly newline\r\n\n\r\n\n\rmore\0\n";
1046 evbuffer_add(evb, s, strlen(s)+2);
1047 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_ANY);
1048 tt_line_eq("complex silly newline");
1049 free(cp);
1050 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_ANY);
1051 if (!cp || sz != 5 || memcmp(cp, "more\0\0", 6)) {
1052 fprintf(stdout, "FAILED\n");
1053 exit(1);
1054 }
1055 if (evb->totallen == 0) {
1056 fprintf(stdout, "FAILED\n");
1057 exit(1);
1058 }
1059 s = "\nno newline";
1060 evbuffer_add(evb, s, strlen(s));
1061 free(cp);
1062 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_ANY);
1063 tt_line_eq("");
1064 free(cp);
1065 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_ANY);
1066 tt_assert(!cp);
1067 evbuffer_drain(evb, EVBUFFER_LENGTH(evb));
1068 tt_assert(EVBUFFER_LENGTH(evb) == 0);
1069
1070 fprintf(stdout, "OK\n");
1071
1072 /* Test EOL_CRLF */
1073 fprintf(stdout, "Testing evbuffer_readln EOL_CRLF: ");
1074
1075 s = "Line with\rin the middle\nLine with good crlf\r\n\nfinal\n";
1076 evbuffer_add(evb, s, strlen(s));
1077 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF);
1078 tt_line_eq("Line with\rin the middle");
1079 free(cp);
1080
1081 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF);
1082 tt_line_eq("Line with good crlf");
1083 free(cp);
1084
1085 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF);
1086 tt_line_eq("");
1087 free(cp);
1088
1089 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF);
1090 tt_line_eq("final");
1091 s = "x";
1092 evbuffer_add(evb, s, 1);
1093 free(cp);
1094 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF);
1095 tt_assert(!cp);
1096
1097 fprintf(stdout, "OK\n");
1098
1099 /* Test CRLF_STRICT */
1100 fprintf(stdout, "Testing evbuffer_readln CRLF_STRICT: ");
1101
1102 s = " and a bad crlf\nand a good one\r\n\r\nMore\r";
1103 evbuffer_add(evb, s, strlen(s));
1104 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1105 tt_line_eq("x and a bad crlf\nand a good one");
1106 free(cp);
1107
1108 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1109 tt_line_eq("");
1110 free(cp);
1111
1112 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1113 tt_assert(!cp);
1114 evbuffer_add(evb, "\n", 1);
1115
1116 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1117 tt_line_eq("More");
1118 free(cp);
1119 tt_assert(EVBUFFER_LENGTH(evb) == 0);
1120
1121 s = "An internal CR\r is not an eol\r\nNor is a lack of one";
1122 evbuffer_add(evb, s, strlen(s));
1123 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1124 tt_line_eq("An internal CR\r is not an eol");
1125 free(cp);
1126
1127 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1128 tt_assert(!cp);
1129
1130 evbuffer_add(evb, "\r\n", 2);
1131 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1132 tt_line_eq("Nor is a lack of one");
1133 free(cp);
1134 tt_assert(EVBUFFER_LENGTH(evb) == 0);
1135
1136 fprintf(stdout, "OK\n");
1137
1138 /* Test LF */
1139 fprintf(stdout, "Testing evbuffer_readln LF: ");
1140
1141 s = "An\rand a nl\n\nText";
1142 evbuffer_add(evb, s, strlen(s));
1143
1144 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
1145 tt_line_eq("An\rand a nl");
1146 free(cp);
1147
1148 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
1149 tt_line_eq("");
1150 free(cp);
1151
1152 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
1153 tt_assert(!cp);
1154 free(cp);
1155 evbuffer_add(evb, "\n", 1);
1156 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
1157 tt_line_eq("Text");
1158 free(cp);
1159
1160 fprintf(stdout, "OK\n");
1161
1162 /* Test CRLF_STRICT - across boundaries */
1163 fprintf(stdout,
1164 "Testing evbuffer_readln CRLF_STRICT across boundaries: ");
1165
1166 s = " and a bad crlf\nand a good one\r";
1167 evbuffer_add(evb_tmp, s, strlen(s));
1168 evbuffer_add_buffer(evb, evb_tmp);
1169 s = "\n\r";
1170 evbuffer_add(evb_tmp, s, strlen(s));
1171 evbuffer_add_buffer(evb, evb_tmp);
1172 s = "\nMore\r";
1173 evbuffer_add(evb_tmp, s, strlen(s));
1174 evbuffer_add_buffer(evb, evb_tmp);
1175
1176 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1177 tt_line_eq(" and a bad crlf\nand a good one");
1178 free(cp);
1179
1180 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1181 tt_line_eq("");
1182 free(cp);
1183
1184 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1185 tt_assert(!cp);
1186 free(cp);
1187 evbuffer_add(evb, "\n", 1);
1188 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1189 tt_line_eq("More");
1190 free(cp); cp = NULL;
1191 if (EVBUFFER_LENGTH(evb) != 0) {
1192 fprintf(stdout, "FAILED\n");
1193 exit(1);
1194 }
1195
1196 fprintf(stdout, "OK\n");
1197
1198 /* Test memory problem */
1199 fprintf(stdout, "Testing evbuffer_readln memory problem: ");
1200
1201 s = "one line\ntwo line\nblue line";
1202 evbuffer_add(evb_tmp, s, strlen(s));
1203 evbuffer_add_buffer(evb, evb_tmp);
1204
1205 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
1206 tt_line_eq("one line");
1207 free(cp); cp = NULL;
1208
1209 cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
1210 tt_line_eq("two line");
1211 free(cp); cp = NULL;
1212
1213 fprintf(stdout, "OK\n");
1214
1215 test_ok = 1;
1216 evbuffer_free(evb);
1217 evbuffer_free(evb_tmp);
1218 if (cp) free(cp);
1219 }
1220
1221 static void
test_evbuffer_find(void)1222 test_evbuffer_find(void)
1223 {
1224 u_char* p;
1225 const char* test1 = "1234567890\r\n";
1226 const char* test2 = "1234567890\r";
1227 #define EVBUFFER_INITIAL_LENGTH 256
1228 char test3[EVBUFFER_INITIAL_LENGTH];
1229 unsigned int i;
1230 struct evbuffer * buf = evbuffer_new();
1231
1232 /* make sure evbuffer_find doesn't match past the end of the buffer */
1233 fprintf(stdout, "Testing evbuffer_find 1: ");
1234 evbuffer_add(buf, (u_char*)test1, strlen(test1));
1235 evbuffer_drain(buf, strlen(test1));
1236 evbuffer_add(buf, (u_char*)test2, strlen(test2));
1237 p = evbuffer_find(buf, (u_char*)"\r\n", 2);
1238 if (p == NULL) {
1239 fprintf(stdout, "OK\n");
1240 } else {
1241 fprintf(stdout, "FAILED\n");
1242 exit(1);
1243 }
1244
1245 /*
1246 * drain the buffer and do another find; in r309 this would
1247 * read past the allocated buffer causing a valgrind error.
1248 */
1249 fprintf(stdout, "Testing evbuffer_find 2: ");
1250 evbuffer_drain(buf, strlen(test2));
1251 for (i = 0; i < EVBUFFER_INITIAL_LENGTH; ++i)
1252 test3[i] = 'a';
1253 test3[EVBUFFER_INITIAL_LENGTH - 1] = 'x';
1254 evbuffer_add(buf, (u_char *)test3, EVBUFFER_INITIAL_LENGTH);
1255 p = evbuffer_find(buf, (u_char *)"xy", 2);
1256 if (p == NULL) {
1257 printf("OK\n");
1258 } else {
1259 fprintf(stdout, "FAILED\n");
1260 exit(1);
1261 }
1262
1263 /* simple test for match at end of allocated buffer */
1264 fprintf(stdout, "Testing evbuffer_find 3: ");
1265 p = evbuffer_find(buf, (u_char *)"ax", 2);
1266 if (p != NULL && strncmp((char*)p, "ax", 2) == 0) {
1267 printf("OK\n");
1268 } else {
1269 fprintf(stdout, "FAILED\n");
1270 exit(1);
1271 }
1272
1273 evbuffer_free(buf);
1274 }
1275
1276 /*
1277 * simple bufferevent test
1278 */
1279
1280 static void
readcb(struct bufferevent * bev,void * arg)1281 readcb(struct bufferevent *bev, void *arg)
1282 {
1283 if (EVBUFFER_LENGTH(bev->input) == 8333) {
1284 bufferevent_disable(bev, EV_READ);
1285 test_ok++;
1286 }
1287 }
1288
1289 static void
writecb(struct bufferevent * bev,void * arg)1290 writecb(struct bufferevent *bev, void *arg)
1291 {
1292 if (EVBUFFER_LENGTH(bev->output) == 0)
1293 test_ok++;
1294 }
1295
1296 static void
errorcb(struct bufferevent * bev,short what,void * arg)1297 errorcb(struct bufferevent *bev, short what, void *arg)
1298 {
1299 test_ok = -2;
1300 }
1301
1302 static void
test_bufferevent(void)1303 test_bufferevent(void)
1304 {
1305 struct bufferevent *bev1, *bev2;
1306 char buffer[8333];
1307 int i;
1308
1309 setup_test("Bufferevent: ");
1310
1311 bev1 = bufferevent_new(pair[0], readcb, writecb, errorcb, NULL);
1312 bev2 = bufferevent_new(pair[1], readcb, writecb, errorcb, NULL);
1313
1314 bufferevent_disable(bev1, EV_READ);
1315 bufferevent_enable(bev2, EV_READ);
1316
1317 for (i = 0; i < sizeof(buffer); i++)
1318 buffer[i] = i;
1319
1320 bufferevent_write(bev1, buffer, sizeof(buffer));
1321
1322 event_dispatch();
1323
1324 bufferevent_free(bev1);
1325 bufferevent_free(bev2);
1326
1327 if (test_ok != 2)
1328 test_ok = 0;
1329
1330 cleanup_test();
1331 }
1332
1333 /*
1334 * test watermarks and bufferevent
1335 */
1336
1337 static void
wm_readcb(struct bufferevent * bev,void * arg)1338 wm_readcb(struct bufferevent *bev, void *arg)
1339 {
1340 int len = EVBUFFER_LENGTH(bev->input);
1341 static int nread;
1342
1343 assert(len >= 10 && len <= 20);
1344
1345 evbuffer_drain(bev->input, len);
1346
1347 nread += len;
1348 if (nread == 65000) {
1349 bufferevent_disable(bev, EV_READ);
1350 test_ok++;
1351 }
1352 }
1353
1354 static void
wm_writecb(struct bufferevent * bev,void * arg)1355 wm_writecb(struct bufferevent *bev, void *arg)
1356 {
1357 if (EVBUFFER_LENGTH(bev->output) == 0)
1358 test_ok++;
1359 }
1360
1361 static void
wm_errorcb(struct bufferevent * bev,short what,void * arg)1362 wm_errorcb(struct bufferevent *bev, short what, void *arg)
1363 {
1364 test_ok = -2;
1365 }
1366
1367 static void
test_bufferevent_watermarks(void)1368 test_bufferevent_watermarks(void)
1369 {
1370 struct bufferevent *bev1, *bev2;
1371 char buffer[65000];
1372 int i;
1373
1374 setup_test("Bufferevent Watermarks: ");
1375
1376 bev1 = bufferevent_new(pair[0], NULL, wm_writecb, wm_errorcb, NULL);
1377 bev2 = bufferevent_new(pair[1], wm_readcb, NULL, wm_errorcb, NULL);
1378
1379 bufferevent_disable(bev1, EV_READ);
1380 bufferevent_enable(bev2, EV_READ);
1381
1382 for (i = 0; i < sizeof(buffer); i++)
1383 buffer[i] = i;
1384
1385 bufferevent_write(bev1, buffer, sizeof(buffer));
1386
1387 /* limit the reading on the receiving bufferevent */
1388 bufferevent_setwatermark(bev2, EV_READ, 10, 20);
1389
1390 event_dispatch();
1391
1392 bufferevent_free(bev1);
1393 bufferevent_free(bev2);
1394
1395 if (test_ok != 2)
1396 test_ok = 0;
1397
1398 cleanup_test();
1399 }
1400
1401 struct test_pri_event {
1402 struct event ev;
1403 int count;
1404 };
1405
1406 static void
test_priorities_cb(int fd,short what,void * arg)1407 test_priorities_cb(int fd, short what, void *arg)
1408 {
1409 struct test_pri_event *pri = arg;
1410 struct timeval tv;
1411
1412 if (pri->count == 3) {
1413 event_loopexit(NULL);
1414 return;
1415 }
1416
1417 pri->count++;
1418
1419 evutil_timerclear(&tv);
1420 event_add(&pri->ev, &tv);
1421 }
1422
1423 static void
test_priorities(int npriorities)1424 test_priorities(int npriorities)
1425 {
1426 char buf[32];
1427 struct test_pri_event one, two;
1428 struct timeval tv;
1429
1430 evutil_snprintf(buf, sizeof(buf), "Testing Priorities %d: ", npriorities);
1431 setup_test(buf);
1432
1433 event_base_priority_init(global_base, npriorities);
1434
1435 memset(&one, 0, sizeof(one));
1436 memset(&two, 0, sizeof(two));
1437
1438 timeout_set(&one.ev, test_priorities_cb, &one);
1439 if (event_priority_set(&one.ev, 0) == -1) {
1440 fprintf(stderr, "%s: failed to set priority", __func__);
1441 exit(1);
1442 }
1443
1444 timeout_set(&two.ev, test_priorities_cb, &two);
1445 if (event_priority_set(&two.ev, npriorities - 1) == -1) {
1446 fprintf(stderr, "%s: failed to set priority", __func__);
1447 exit(1);
1448 }
1449
1450 evutil_timerclear(&tv);
1451
1452 if (event_add(&one.ev, &tv) == -1)
1453 exit(1);
1454 if (event_add(&two.ev, &tv) == -1)
1455 exit(1);
1456
1457 event_dispatch();
1458
1459 event_del(&one.ev);
1460 event_del(&two.ev);
1461
1462 if (npriorities == 1) {
1463 if (one.count == 3 && two.count == 3)
1464 test_ok = 1;
1465 } else if (npriorities == 2) {
1466 /* Two is called once because event_loopexit is priority 1 */
1467 if (one.count == 3 && two.count == 1)
1468 test_ok = 1;
1469 } else {
1470 if (one.count == 3 && two.count == 0)
1471 test_ok = 1;
1472 }
1473
1474 cleanup_test();
1475 }
1476
1477 static void
test_multiple_cb(int fd,short event,void * arg)1478 test_multiple_cb(int fd, short event, void *arg)
1479 {
1480 if (event & EV_READ)
1481 test_ok |= 1;
1482 else if (event & EV_WRITE)
1483 test_ok |= 2;
1484 }
1485
1486 static void
test_multiple_events_for_same_fd(void)1487 test_multiple_events_for_same_fd(void)
1488 {
1489 struct event e1, e2;
1490
1491 setup_test("Multiple events for same fd: ");
1492
1493 event_set(&e1, pair[0], EV_READ, test_multiple_cb, NULL);
1494 event_add(&e1, NULL);
1495 event_set(&e2, pair[0], EV_WRITE, test_multiple_cb, NULL);
1496 event_add(&e2, NULL);
1497 event_loop(EVLOOP_ONCE);
1498 event_del(&e2);
1499 write(pair[1], TEST1, strlen(TEST1)+1);
1500 event_loop(EVLOOP_ONCE);
1501 event_del(&e1);
1502
1503 if (test_ok != 3)
1504 test_ok = 0;
1505
1506 cleanup_test();
1507 }
1508
1509 int evtag_decode_int(uint32_t *pnumber, struct evbuffer *evbuf);
1510 int evtag_encode_tag(struct evbuffer *evbuf, uint32_t number);
1511 int evtag_decode_tag(uint32_t *pnumber, struct evbuffer *evbuf);
1512
1513 static void
read_once_cb(int fd,short event,void * arg)1514 read_once_cb(int fd, short event, void *arg)
1515 {
1516 char buf[256];
1517 int len;
1518
1519 len = read(fd, buf, sizeof(buf));
1520
1521 if (called) {
1522 test_ok = 0;
1523 } else if (len) {
1524 /* Assumes global pair[0] can be used for writing */
1525 write(pair[0], TEST1, strlen(TEST1)+1);
1526 test_ok = 1;
1527 }
1528
1529 called++;
1530 }
1531
1532 static void
test_want_only_once(void)1533 test_want_only_once(void)
1534 {
1535 struct event ev;
1536 struct timeval tv;
1537
1538 /* Very simple read test */
1539 setup_test("Want read only once: ");
1540
1541 write(pair[0], TEST1, strlen(TEST1)+1);
1542
1543 /* Setup the loop termination */
1544 evutil_timerclear(&tv);
1545 tv.tv_sec = 1;
1546 event_loopexit(&tv);
1547
1548 event_set(&ev, pair[1], EV_READ, read_once_cb, &ev);
1549 if (event_add(&ev, NULL) == -1)
1550 exit(1);
1551 event_dispatch();
1552
1553 cleanup_test();
1554 }
1555
1556 #define TEST_MAX_INT 6
1557
1558 static void
evtag_int_test(void)1559 evtag_int_test(void)
1560 {
1561 struct evbuffer *tmp = evbuffer_new();
1562 uint32_t integers[TEST_MAX_INT] = {
1563 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
1564 };
1565 uint32_t integer;
1566 int i;
1567
1568 for (i = 0; i < TEST_MAX_INT; i++) {
1569 int oldlen, newlen;
1570 oldlen = EVBUFFER_LENGTH(tmp);
1571 encode_int(tmp, integers[i]);
1572 newlen = EVBUFFER_LENGTH(tmp);
1573 fprintf(stdout, "\t\tencoded 0x%08x with %d bytes\n",
1574 integers[i], newlen - oldlen);
1575 }
1576
1577 for (i = 0; i < TEST_MAX_INT; i++) {
1578 if (evtag_decode_int(&integer, tmp) == -1) {
1579 fprintf(stderr, "decode %d failed", i);
1580 exit(1);
1581 }
1582 if (integer != integers[i]) {
1583 fprintf(stderr, "got %x, wanted %x",
1584 integer, integers[i]);
1585 exit(1);
1586 }
1587 }
1588
1589 if (EVBUFFER_LENGTH(tmp) != 0) {
1590 fprintf(stderr, "trailing data");
1591 exit(1);
1592 }
1593 evbuffer_free(tmp);
1594
1595 fprintf(stdout, "\t%s: OK\n", __func__);
1596 }
1597
1598 static void
evtag_fuzz(void)1599 evtag_fuzz(void)
1600 {
1601 u_char buffer[4096];
1602 struct evbuffer *tmp = evbuffer_new();
1603 struct timeval tv;
1604 int i, j;
1605
1606 int not_failed = 0;
1607 for (j = 0; j < 100; j++) {
1608 for (i = 0; i < sizeof(buffer); i++)
1609 buffer[i] = rand();
1610 evbuffer_drain(tmp, -1);
1611 evbuffer_add(tmp, buffer, sizeof(buffer));
1612
1613 if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1)
1614 not_failed++;
1615 }
1616
1617 /* The majority of decodes should fail */
1618 if (not_failed >= 10) {
1619 fprintf(stderr, "evtag_unmarshal should have failed");
1620 exit(1);
1621 }
1622
1623 /* Now insert some corruption into the tag length field */
1624 evbuffer_drain(tmp, -1);
1625 evutil_timerclear(&tv);
1626 tv.tv_sec = 1;
1627 evtag_marshal_timeval(tmp, 0, &tv);
1628 evbuffer_add(tmp, buffer, sizeof(buffer));
1629
1630 EVBUFFER_DATA(tmp)[1] = 0xff;
1631 if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1) {
1632 fprintf(stderr, "evtag_unmarshal_timeval should have failed");
1633 exit(1);
1634 }
1635
1636 evbuffer_free(tmp);
1637
1638 fprintf(stdout, "\t%s: OK\n", __func__);
1639 }
1640
1641 static void
evtag_tag_encoding(void)1642 evtag_tag_encoding(void)
1643 {
1644 struct evbuffer *tmp = evbuffer_new();
1645 uint32_t integers[TEST_MAX_INT] = {
1646 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
1647 };
1648 uint32_t integer;
1649 int i;
1650
1651 for (i = 0; i < TEST_MAX_INT; i++) {
1652 int oldlen, newlen;
1653 oldlen = EVBUFFER_LENGTH(tmp);
1654 evtag_encode_tag(tmp, integers[i]);
1655 newlen = EVBUFFER_LENGTH(tmp);
1656 fprintf(stdout, "\t\tencoded 0x%08x with %d bytes\n",
1657 integers[i], newlen - oldlen);
1658 }
1659
1660 for (i = 0; i < TEST_MAX_INT; i++) {
1661 if (evtag_decode_tag(&integer, tmp) == -1) {
1662 fprintf(stderr, "decode %d failed", i);
1663 exit(1);
1664 }
1665 if (integer != integers[i]) {
1666 fprintf(stderr, "got %x, wanted %x",
1667 integer, integers[i]);
1668 exit(1);
1669 }
1670 }
1671
1672 if (EVBUFFER_LENGTH(tmp) != 0) {
1673 fprintf(stderr, "trailing data");
1674 exit(1);
1675 }
1676 evbuffer_free(tmp);
1677
1678 fprintf(stdout, "\t%s: OK\n", __func__);
1679 }
1680
1681 static void
evtag_test(void)1682 evtag_test(void)
1683 {
1684 fprintf(stdout, "Testing Tagging:\n");
1685
1686 evtag_init();
1687 evtag_int_test();
1688 evtag_fuzz();
1689
1690 evtag_tag_encoding();
1691
1692 fprintf(stdout, "OK\n");
1693 }
1694
1695 #ifndef WIN32
1696 static void
rpc_test(void)1697 rpc_test(void)
1698 {
1699 struct msg *msg, *msg2;
1700 struct kill *attack;
1701 struct run *run;
1702 struct evbuffer *tmp = evbuffer_new();
1703 struct timeval tv_start, tv_end;
1704 uint32_t tag;
1705 int i;
1706
1707 fprintf(stdout, "Testing RPC: ");
1708
1709 msg = msg_new();
1710 EVTAG_ASSIGN(msg, from_name, "niels");
1711 EVTAG_ASSIGN(msg, to_name, "phoenix");
1712
1713 if (EVTAG_GET(msg, attack, &attack) == -1) {
1714 fprintf(stderr, "Failed to set kill message.\n");
1715 exit(1);
1716 }
1717
1718 EVTAG_ASSIGN(attack, weapon, "feather");
1719 EVTAG_ASSIGN(attack, action, "tickle");
1720
1721 evutil_gettimeofday(&tv_start, NULL);
1722 for (i = 0; i < 1000; ++i) {
1723 run = EVTAG_ADD(msg, run);
1724 if (run == NULL) {
1725 fprintf(stderr, "Failed to add run message.\n");
1726 exit(1);
1727 }
1728 EVTAG_ASSIGN(run, how, "very fast but with some data in it");
1729 EVTAG_ASSIGN(run, fixed_bytes,
1730 (unsigned char*)"012345678901234567890123");
1731 }
1732
1733 if (msg_complete(msg) == -1) {
1734 fprintf(stderr, "Failed to make complete message.\n");
1735 exit(1);
1736 }
1737
1738 evtag_marshal_msg(tmp, 0xdeaf, msg);
1739
1740 if (evtag_peek(tmp, &tag) == -1) {
1741 fprintf(stderr, "Failed to peak tag.\n");
1742 exit (1);
1743 }
1744
1745 if (tag != 0xdeaf) {
1746 fprintf(stderr, "Got incorrect tag: %0x.\n", tag);
1747 exit (1);
1748 }
1749
1750 msg2 = msg_new();
1751 if (evtag_unmarshal_msg(tmp, 0xdeaf, msg2) == -1) {
1752 fprintf(stderr, "Failed to unmarshal message.\n");
1753 exit(1);
1754 }
1755
1756 evutil_gettimeofday(&tv_end, NULL);
1757 evutil_timersub(&tv_end, &tv_start, &tv_end);
1758 fprintf(stderr, "(%.1f us/add) ",
1759 (float)tv_end.tv_sec/(float)i * 1000000.0 +
1760 tv_end.tv_usec / (float)i);
1761
1762 if (!EVTAG_HAS(msg2, from_name) ||
1763 !EVTAG_HAS(msg2, to_name) ||
1764 !EVTAG_HAS(msg2, attack)) {
1765 fprintf(stderr, "Missing data structures.\n");
1766 exit(1);
1767 }
1768
1769 if (EVTAG_LEN(msg2, run) != i) {
1770 fprintf(stderr, "Wrong number of run messages.\n");
1771 exit(1);
1772 }
1773
1774 msg_free(msg);
1775 msg_free(msg2);
1776
1777 evbuffer_free(tmp);
1778
1779 fprintf(stdout, "OK\n");
1780 }
1781 #endif
1782
1783 static void
test_evutil_strtoll(void)1784 test_evutil_strtoll(void)
1785 {
1786 const char *s;
1787 char *endptr;
1788 setup_test("evutil_stroll: ");
1789 test_ok = 0;
1790
1791 if (evutil_strtoll("5000000000", NULL, 10) != ((ev_int64_t)5000000)*1000)
1792 goto err;
1793 if (evutil_strtoll("-5000000000", NULL, 10) != ((ev_int64_t)5000000)*-1000)
1794 goto err;
1795 s = " 99999stuff";
1796 if (evutil_strtoll(s, &endptr, 10) != (ev_int64_t)99999)
1797 goto err;
1798 if (endptr != s+6)
1799 goto err;
1800 if (evutil_strtoll("foo", NULL, 10) != 0)
1801 goto err;
1802
1803 test_ok = 1;
1804 err:
1805 cleanup_test();
1806 }
1807
1808
1809 int
main(int argc,char ** argv)1810 main (int argc, char **argv)
1811 {
1812 #ifdef WIN32
1813 WORD wVersionRequested;
1814 WSADATA wsaData;
1815 int err;
1816
1817 wVersionRequested = MAKEWORD( 2, 2 );
1818
1819 err = WSAStartup( wVersionRequested, &wsaData );
1820 #endif
1821
1822 #ifndef WIN32
1823 if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
1824 return (1);
1825 #endif
1826 setvbuf(stdout, NULL, _IONBF, 0);
1827
1828 /* Initalize the event library */
1829 global_base = event_init();
1830
1831 test_registerfds();
1832
1833 test_evutil_strtoll();
1834
1835 /* use the global event base and need to be called first */
1836 test_priorities(1);
1837 test_priorities(2);
1838 test_priorities(3);
1839
1840 test_evbuffer();
1841 test_evbuffer_find();
1842 test_evbuffer_readln();
1843
1844 test_bufferevent();
1845 test_bufferevent_watermarks();
1846
1847 test_free_active_base();
1848
1849 test_event_base_new();
1850
1851 http_suite();
1852
1853 #ifndef WIN32
1854 rpc_suite();
1855 #endif
1856
1857 dns_suite();
1858
1859 #ifndef WIN32
1860 test_fork();
1861 #endif
1862
1863 test_simpleread();
1864
1865 test_simplewrite();
1866
1867 test_multiple();
1868
1869 test_persistent();
1870
1871 test_combined();
1872
1873 test_simpletimeout();
1874 #ifndef WIN32
1875 test_simplesignal();
1876 test_multiplesignal();
1877 test_immediatesignal();
1878 #endif
1879 test_loopexit();
1880 test_loopbreak();
1881
1882 test_loopexit_multiple();
1883
1884 test_multiple_events_for_same_fd();
1885
1886 test_want_only_once();
1887
1888 evtag_test();
1889
1890 #ifndef WIN32
1891 rpc_test();
1892
1893 test_signal_dealloc();
1894 test_signal_pipeloss();
1895 test_signal_switchbase();
1896 test_signal_restore();
1897 test_signal_assert();
1898 test_signal_while_processing();
1899 #endif
1900
1901 return (0);
1902 }
1903
1904