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 68int pair[2]; 69int test_ok; 70static int called; 71static char wbuf[4096]; 72static char rbuf[4096]; 73static int woff; 74static int roff; 75static int usepersist; 76static struct timeval tset; 77static struct timeval tcalled; 78static 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 92static void 93simple_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 114static void 115simple_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 129static void 130multiple_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 162static void 163multiple_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 184static void 185timeout_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 205static void 206signal_cb_sa(int sig) 207{ 208 test_ok = 2; 209} 210 211static void 212signal_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 221struct both { 222 struct event ev; 223 int nread; 224}; 225 226static void 227combined_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 244static void 245combined_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 270static int 271setup_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 294static int 295cleanup_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 314static void 315test_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 365static void 366test_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 384static void 385test_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 400static void 401test_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 429static void 430test_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 458static void 459test_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 493static void 494test_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 513extern struct event_base *current_base; 514 515static void 516child_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 528static void 529test_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 596static void 597test_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 622static void 623test_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 652static void 653test_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 667static void 668test_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 683static void 684test_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 */ 711static void 712test_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 */ 761static void 762test_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 */ 792static void 793test_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; 821out: 822 event_base_free(base); 823 cleanup_test(); 824 return; 825} 826 827static void 828signal_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} 836static void 837timeout_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 851static void 852test_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 874static void 875test_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 890static void 891test_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 912static void 913test_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 942static void 943test_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 969static void 970break_cb(int fd, short events, void *arg) 971{ 972 test_ok = 1; 973 event_loopbreak(); 974} 975 976static void 977fail_cb(int fd, short events, void *arg) 978{ 979 test_ok = 0; 980} 981 982static void 983test_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 1005static void 1006test_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 1022static void 1023test_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 1221static void 1222test_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 1280static void 1281readcb(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 1289static void 1290writecb(struct bufferevent *bev, void *arg) 1291{ 1292 if (EVBUFFER_LENGTH(bev->output) == 0) 1293 test_ok++; 1294} 1295 1296static void 1297errorcb(struct bufferevent *bev, short what, void *arg) 1298{ 1299 test_ok = -2; 1300} 1301 1302static void 1303test_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 1337static void 1338wm_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 1354static void 1355wm_writecb(struct bufferevent *bev, void *arg) 1356{ 1357 if (EVBUFFER_LENGTH(bev->output) == 0) 1358 test_ok++; 1359} 1360 1361static void 1362wm_errorcb(struct bufferevent *bev, short what, void *arg) 1363{ 1364 test_ok = -2; 1365} 1366 1367static void 1368test_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 1401struct test_pri_event { 1402 struct event ev; 1403 int count; 1404}; 1405 1406static void 1407test_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 1423static void 1424test_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 1477static void 1478test_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 1486static void 1487test_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 1509int evtag_decode_int(uint32_t *pnumber, struct evbuffer *evbuf); 1510int evtag_encode_tag(struct evbuffer *evbuf, uint32_t number); 1511int evtag_decode_tag(uint32_t *pnumber, struct evbuffer *evbuf); 1512 1513static void 1514read_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 1532static void 1533test_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 1558static void 1559evtag_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 1598static void 1599evtag_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 1641static void 1642evtag_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 1681static void 1682evtag_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 1696static void 1697rpc_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 1783static void 1784test_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 1809int 1810main (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