1 /* $NetBSD: regress.c,v 1.1.1.1 2013/12/27 23:31:29 christos Exp $ */ 2 3 /* 4 * Copyright (c) 2003-2007 Niels Provos <provos@citi.umich.edu> 5 * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. The name of the author may not be used to endorse or promote products 16 * derived from this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 #include "util-internal.h" 30 31 #ifdef _WIN32 32 #include <winsock2.h> 33 #include <windows.h> 34 #endif 35 36 #include "event2/event-config.h" 37 38 #include <sys/types.h> 39 #include <sys/stat.h> 40 #ifdef EVENT__HAVE_SYS_TIME_H 41 #include <sys/time.h> 42 #endif 43 #include <sys/queue.h> 44 #ifndef _WIN32 45 #include <sys/socket.h> 46 #include <sys/wait.h> 47 #include <signal.h> 48 #include <unistd.h> 49 #include <netdb.h> 50 #endif 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 #include <assert.h> 58 #include <ctype.h> 59 60 #include "event2/event.h" 61 #include "event2/event_struct.h" 62 #include "event2/event_compat.h" 63 #include "event2/tag.h" 64 #include "event2/buffer.h" 65 #include "event2/buffer_compat.h" 66 #include "event2/util.h" 67 #include "event-internal.h" 68 #include "evthread-internal.h" 69 #include "log-internal.h" 70 #include "time-internal.h" 71 72 #include "regress.h" 73 74 #ifndef _WIN32 75 #include "regress.gen.h" 76 #endif 77 78 evutil_socket_t pair[2]; 79 int test_ok; 80 int called; 81 struct event_base *global_base; 82 83 static char wbuf[4096]; 84 static char rbuf[4096]; 85 static int woff; 86 static int roff; 87 static int usepersist; 88 static struct timeval tset; 89 static struct timeval tcalled; 90 91 92 #define TEST1 "this is a test" 93 94 #ifndef SHUT_WR 95 #define SHUT_WR 1 96 #endif 97 98 #ifdef _WIN32 99 #define write(fd,buf,len) send((fd),(buf),(int)(len),0) 100 #define read(fd,buf,len) recv((fd),(buf),(int)(len),0) 101 #endif 102 103 struct basic_cb_args 104 { 105 struct event_base *eb; 106 struct event *ev; 107 unsigned int callcount; 108 }; 109 110 static void 111 simple_read_cb(evutil_socket_t fd, short event, void *arg) 112 { 113 char buf[256]; 114 int len; 115 116 len = read(fd, buf, sizeof(buf)); 117 118 if (len) { 119 if (!called) { 120 if (event_add(arg, NULL) == -1) 121 exit(1); 122 } 123 } else if (called == 1) 124 test_ok = 1; 125 126 called++; 127 } 128 129 static void 130 basic_read_cb(evutil_socket_t fd, short event, void *data) 131 { 132 char buf[256]; 133 int len; 134 struct basic_cb_args *arg = data; 135 136 len = read(fd, buf, sizeof(buf)); 137 138 if (len < 0) { 139 tt_fail_perror("read (callback)"); 140 } else { 141 switch (arg->callcount++) { 142 case 0: /* first call: expect to read data; cycle */ 143 if (len > 0) 144 return; 145 146 tt_fail_msg("EOF before data read"); 147 break; 148 149 case 1: /* second call: expect EOF; stop */ 150 if (len > 0) 151 tt_fail_msg("not all data read on first cycle"); 152 break; 153 154 default: /* third call: should not happen */ 155 tt_fail_msg("too many cycles"); 156 } 157 } 158 159 event_del(arg->ev); 160 event_base_loopexit(arg->eb, NULL); 161 } 162 163 static void 164 dummy_read_cb(evutil_socket_t fd, short event, void *arg) 165 { 166 } 167 168 static void 169 simple_write_cb(evutil_socket_t fd, short event, void *arg) 170 { 171 int len; 172 173 len = write(fd, TEST1, strlen(TEST1) + 1); 174 if (len == -1) 175 test_ok = 0; 176 else 177 test_ok = 1; 178 } 179 180 static void 181 multiple_write_cb(evutil_socket_t fd, short event, void *arg) 182 { 183 struct event *ev = arg; 184 int len; 185 186 len = 128; 187 if (woff + len >= (int)sizeof(wbuf)) 188 len = sizeof(wbuf) - woff; 189 190 len = write(fd, wbuf + woff, len); 191 if (len == -1) { 192 fprintf(stderr, "%s: write\n", __func__); 193 if (usepersist) 194 event_del(ev); 195 return; 196 } 197 198 woff += len; 199 200 if (woff >= (int)sizeof(wbuf)) { 201 shutdown(fd, SHUT_WR); 202 if (usepersist) 203 event_del(ev); 204 return; 205 } 206 207 if (!usepersist) { 208 if (event_add(ev, NULL) == -1) 209 exit(1); 210 } 211 } 212 213 static void 214 multiple_read_cb(evutil_socket_t fd, short event, void *arg) 215 { 216 struct event *ev = arg; 217 int len; 218 219 len = read(fd, rbuf + roff, sizeof(rbuf) - roff); 220 if (len == -1) 221 fprintf(stderr, "%s: read\n", __func__); 222 if (len <= 0) { 223 if (usepersist) 224 event_del(ev); 225 return; 226 } 227 228 roff += len; 229 if (!usepersist) { 230 if (event_add(ev, NULL) == -1) 231 exit(1); 232 } 233 } 234 235 static void 236 timeout_cb(evutil_socket_t fd, short event, void *arg) 237 { 238 evutil_gettimeofday(&tcalled, NULL); 239 } 240 241 struct both { 242 struct event ev; 243 int nread; 244 }; 245 246 static void 247 combined_read_cb(evutil_socket_t fd, short event, void *arg) 248 { 249 struct both *both = arg; 250 char buf[128]; 251 int len; 252 253 len = read(fd, buf, sizeof(buf)); 254 if (len == -1) 255 fprintf(stderr, "%s: read\n", __func__); 256 if (len <= 0) 257 return; 258 259 both->nread += len; 260 if (event_add(&both->ev, NULL) == -1) 261 exit(1); 262 } 263 264 static void 265 combined_write_cb(evutil_socket_t fd, short event, void *arg) 266 { 267 struct both *both = arg; 268 char buf[128]; 269 int len; 270 271 len = sizeof(buf); 272 if (len > both->nread) 273 len = both->nread; 274 275 memset(buf, 'q', len); 276 277 len = write(fd, buf, len); 278 if (len == -1) 279 fprintf(stderr, "%s: write\n", __func__); 280 if (len <= 0) { 281 shutdown(fd, SHUT_WR); 282 return; 283 } 284 285 both->nread -= len; 286 if (event_add(&both->ev, NULL) == -1) 287 exit(1); 288 } 289 290 /* These macros used to replicate the work of the legacy test wrapper code */ 291 #define setup_test(x) do { \ 292 if (!in_legacy_test_wrapper) { \ 293 TT_FAIL(("Legacy test %s not wrapped properly", x)); \ 294 return; \ 295 } \ 296 } while (0) 297 #define cleanup_test() setup_test("cleanup") 298 299 static void 300 test_simpleread(void) 301 { 302 struct event ev; 303 304 /* Very simple read test */ 305 setup_test("Simple read: "); 306 307 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) { 308 tt_fail_perror("write"); 309 } 310 311 shutdown(pair[0], SHUT_WR); 312 313 event_set(&ev, pair[1], EV_READ, simple_read_cb, &ev); 314 if (event_add(&ev, NULL) == -1) 315 exit(1); 316 event_dispatch(); 317 318 cleanup_test(); 319 } 320 321 static void 322 test_simplewrite(void) 323 { 324 struct event ev; 325 326 /* Very simple write test */ 327 setup_test("Simple write: "); 328 329 event_set(&ev, pair[0], EV_WRITE, simple_write_cb, &ev); 330 if (event_add(&ev, NULL) == -1) 331 exit(1); 332 event_dispatch(); 333 334 cleanup_test(); 335 } 336 337 static void 338 simpleread_multiple_cb(evutil_socket_t fd, short event, void *arg) 339 { 340 if (++called == 2) 341 test_ok = 1; 342 } 343 344 static void 345 test_simpleread_multiple(void) 346 { 347 struct event one, two; 348 349 /* Very simple read test */ 350 setup_test("Simple read to multiple evens: "); 351 352 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) { 353 tt_fail_perror("write"); 354 } 355 356 shutdown(pair[0], SHUT_WR); 357 358 event_set(&one, pair[1], EV_READ, simpleread_multiple_cb, NULL); 359 if (event_add(&one, NULL) == -1) 360 exit(1); 361 event_set(&two, pair[1], EV_READ, simpleread_multiple_cb, NULL); 362 if (event_add(&two, NULL) == -1) 363 exit(1); 364 event_dispatch(); 365 366 cleanup_test(); 367 } 368 369 static int have_closed = 0; 370 static int premature_event = 0; 371 static void 372 simpleclose_close_fd_cb(evutil_socket_t s, short what, void *ptr) 373 { 374 evutil_socket_t **fds = ptr; 375 TT_BLATHER(("Closing")); 376 evutil_closesocket(*fds[0]); 377 evutil_closesocket(*fds[1]); 378 *fds[0] = -1; 379 *fds[1] = -1; 380 have_closed = 1; 381 } 382 383 static void 384 record_event_cb(evutil_socket_t s, short what, void *ptr) 385 { 386 short *whatp = ptr; 387 if (!have_closed) 388 premature_event = 1; 389 *whatp = what; 390 TT_BLATHER(("Recorded %d on socket %d", (int)what, (int)s)); 391 } 392 393 static void 394 test_simpleclose(void *ptr) 395 { 396 /* Test that a close of FD is detected as a read and as a write. */ 397 struct event_base *base = event_base_new(); 398 evutil_socket_t pair1[2]={-1,-1}, pair2[2] = {-1, -1}; 399 evutil_socket_t *to_close[2]; 400 struct event *rev=NULL, *wev=NULL, *closeev=NULL; 401 struct timeval tv; 402 short got_read_on_close = 0, got_write_on_close = 0; 403 char buf[1024]; 404 memset(buf, 99, sizeof(buf)); 405 #ifdef _WIN32 406 #define LOCAL_SOCKETPAIR_AF AF_INET 407 #else 408 #define LOCAL_SOCKETPAIR_AF AF_UNIX 409 #endif 410 if (evutil_socketpair(LOCAL_SOCKETPAIR_AF, SOCK_STREAM, 0, pair1)<0) 411 TT_DIE(("socketpair: %s", strerror(errno))); 412 if (evutil_socketpair(LOCAL_SOCKETPAIR_AF, SOCK_STREAM, 0, pair2)<0) 413 TT_DIE(("socketpair: %s", strerror(errno))); 414 if (evutil_make_socket_nonblocking(pair1[1]) < 0) 415 TT_DIE(("make_socket_nonblocking")); 416 if (evutil_make_socket_nonblocking(pair2[1]) < 0) 417 TT_DIE(("make_socket_nonblocking")); 418 419 /** Stuff pair2[1] full of data, until write fails */ 420 while (1) { 421 int r = write(pair2[1], buf, sizeof(buf)); 422 if (r<0) { 423 int err = evutil_socket_geterror(pair2[1]); 424 if (! EVUTIL_ERR_RW_RETRIABLE(err)) 425 TT_DIE(("write failed strangely: %s", 426 evutil_socket_error_to_string(err))); 427 break; 428 } 429 } 430 to_close[0] = &pair1[0]; 431 to_close[1] = &pair2[0]; 432 433 closeev = event_new(base, -1, EV_TIMEOUT, simpleclose_close_fd_cb, 434 to_close); 435 rev = event_new(base, pair1[1], EV_READ, record_event_cb, 436 &got_read_on_close); 437 TT_BLATHER(("Waiting for read on %d", (int)pair1[1])); 438 wev = event_new(base, pair2[1], EV_WRITE, record_event_cb, 439 &got_write_on_close); 440 TT_BLATHER(("Waiting for write on %d", (int)pair2[1])); 441 tv.tv_sec = 0; 442 tv.tv_usec = 100*1000; /* Close pair1[0] after a little while, and make 443 * sure we get a read event. */ 444 event_add(closeev, &tv); 445 event_add(rev, NULL); 446 event_add(wev, NULL); 447 /* Don't let the test go on too long. */ 448 tv.tv_sec = 0; 449 tv.tv_usec = 200*1000; 450 event_base_loopexit(base, &tv); 451 event_base_loop(base, 0); 452 453 tt_int_op(got_read_on_close, ==, EV_READ); 454 tt_int_op(got_write_on_close, ==, EV_WRITE); 455 tt_int_op(premature_event, ==, 0); 456 457 end: 458 if (pair1[0] >= 0) 459 evutil_closesocket(pair1[0]); 460 if (pair1[1] >= 0) 461 evutil_closesocket(pair1[1]); 462 if (pair2[0] >= 0) 463 evutil_closesocket(pair2[0]); 464 if (pair2[1] >= 0) 465 evutil_closesocket(pair2[1]); 466 if (rev) 467 event_free(rev); 468 if (wev) 469 event_free(wev); 470 if (closeev) 471 event_free(closeev); 472 if (base) 473 event_base_free(base); 474 } 475 476 477 static void 478 test_multiple(void) 479 { 480 struct event ev, ev2; 481 int i; 482 483 /* Multiple read and write test */ 484 setup_test("Multiple read/write: "); 485 memset(rbuf, 0, sizeof(rbuf)); 486 for (i = 0; i < (int)sizeof(wbuf); i++) 487 wbuf[i] = i; 488 489 roff = woff = 0; 490 usepersist = 0; 491 492 event_set(&ev, pair[0], EV_WRITE, multiple_write_cb, &ev); 493 if (event_add(&ev, NULL) == -1) 494 exit(1); 495 event_set(&ev2, pair[1], EV_READ, multiple_read_cb, &ev2); 496 if (event_add(&ev2, NULL) == -1) 497 exit(1); 498 event_dispatch(); 499 500 if (roff == woff) 501 test_ok = memcmp(rbuf, wbuf, sizeof(wbuf)) == 0; 502 503 cleanup_test(); 504 } 505 506 static void 507 test_persistent(void) 508 { 509 struct event ev, ev2; 510 int i; 511 512 /* Multiple read and write test with persist */ 513 setup_test("Persist read/write: "); 514 memset(rbuf, 0, sizeof(rbuf)); 515 for (i = 0; i < (int)sizeof(wbuf); i++) 516 wbuf[i] = i; 517 518 roff = woff = 0; 519 usepersist = 1; 520 521 event_set(&ev, pair[0], EV_WRITE|EV_PERSIST, multiple_write_cb, &ev); 522 if (event_add(&ev, NULL) == -1) 523 exit(1); 524 event_set(&ev2, pair[1], EV_READ|EV_PERSIST, multiple_read_cb, &ev2); 525 if (event_add(&ev2, NULL) == -1) 526 exit(1); 527 event_dispatch(); 528 529 if (roff == woff) 530 test_ok = memcmp(rbuf, wbuf, sizeof(wbuf)) == 0; 531 532 cleanup_test(); 533 } 534 535 static void 536 test_combined(void) 537 { 538 struct both r1, r2, w1, w2; 539 540 setup_test("Combined read/write: "); 541 memset(&r1, 0, sizeof(r1)); 542 memset(&r2, 0, sizeof(r2)); 543 memset(&w1, 0, sizeof(w1)); 544 memset(&w2, 0, sizeof(w2)); 545 546 w1.nread = 4096; 547 w2.nread = 8192; 548 549 event_set(&r1.ev, pair[0], EV_READ, combined_read_cb, &r1); 550 event_set(&w1.ev, pair[0], EV_WRITE, combined_write_cb, &w1); 551 event_set(&r2.ev, pair[1], EV_READ, combined_read_cb, &r2); 552 event_set(&w2.ev, pair[1], EV_WRITE, combined_write_cb, &w2); 553 tt_assert(event_add(&r1.ev, NULL) != -1); 554 tt_assert(!event_add(&w1.ev, NULL)); 555 tt_assert(!event_add(&r2.ev, NULL)); 556 tt_assert(!event_add(&w2.ev, NULL)); 557 event_dispatch(); 558 559 if (r1.nread == 8192 && r2.nread == 4096) 560 test_ok = 1; 561 562 end: 563 cleanup_test(); 564 } 565 566 static void 567 test_simpletimeout(void) 568 { 569 struct timeval tv; 570 struct event ev; 571 572 setup_test("Simple timeout: "); 573 574 tv.tv_usec = 200*1000; 575 tv.tv_sec = 0; 576 evutil_timerclear(&tcalled); 577 evtimer_set(&ev, timeout_cb, NULL); 578 evtimer_add(&ev, &tv); 579 580 evutil_gettimeofday(&tset, NULL); 581 event_dispatch(); 582 test_timeval_diff_eq(&tset, &tcalled, 200); 583 584 test_ok = 1; 585 end: 586 cleanup_test(); 587 } 588 589 static void 590 periodic_timeout_cb(evutil_socket_t fd, short event, void *arg) 591 { 592 int *count = arg; 593 594 (*count)++; 595 if (*count == 6) { 596 /* call loopexit only once - on slow machines(?), it is 597 * apparently possible for this to get called twice. */ 598 test_ok = 1; 599 event_base_loopexit(global_base, NULL); 600 } 601 } 602 603 static void 604 test_persistent_timeout(void) 605 { 606 struct timeval tv; 607 struct event ev; 608 int count = 0; 609 610 evutil_timerclear(&tv); 611 tv.tv_usec = 10000; 612 613 event_assign(&ev, global_base, -1, EV_TIMEOUT|EV_PERSIST, 614 periodic_timeout_cb, &count); 615 event_add(&ev, &tv); 616 617 event_dispatch(); 618 619 event_del(&ev); 620 } 621 622 static void 623 test_persistent_timeout_jump(void *ptr) 624 { 625 struct basic_test_data *data = ptr; 626 struct event ev; 627 int count = 0; 628 struct timeval msec100 = { 0, 100 * 1000 }; 629 struct timeval msec50 = { 0, 50 * 1000 }; 630 struct timeval msec300 = { 0, 300 * 1000 }; 631 632 event_assign(&ev, data->base, -1, EV_PERSIST, periodic_timeout_cb, &count); 633 event_add(&ev, &msec100); 634 /* Wait for a bit */ 635 evutil_usleep_(&msec300); 636 event_base_loopexit(data->base, &msec50); 637 event_base_dispatch(data->base); 638 tt_int_op(count, ==, 1); 639 640 end: 641 event_del(&ev); 642 } 643 644 struct persist_active_timeout_called { 645 int n; 646 short events[16]; 647 struct timeval tvs[16]; 648 }; 649 650 static void 651 activate_cb(evutil_socket_t fd, short event, void *arg) 652 { 653 struct event *ev = arg; 654 event_active(ev, EV_READ, 1); 655 } 656 657 static void 658 persist_active_timeout_cb(evutil_socket_t fd, short event, void *arg) 659 { 660 struct persist_active_timeout_called *c = arg; 661 if (c->n < 15) { 662 c->events[c->n] = event; 663 evutil_gettimeofday(&c->tvs[c->n], NULL); 664 ++c->n; 665 } 666 } 667 668 static void 669 test_persistent_active_timeout(void *ptr) 670 { 671 struct timeval tv, tv2, tv_exit, start; 672 struct event ev; 673 struct persist_active_timeout_called res; 674 675 struct basic_test_data *data = ptr; 676 struct event_base *base = data->base; 677 678 memset(&res, 0, sizeof(res)); 679 680 tv.tv_sec = 0; 681 tv.tv_usec = 200 * 1000; 682 event_assign(&ev, base, -1, EV_TIMEOUT|EV_PERSIST, 683 persist_active_timeout_cb, &res); 684 event_add(&ev, &tv); 685 686 tv2.tv_sec = 0; 687 tv2.tv_usec = 100 * 1000; 688 event_base_once(base, -1, EV_TIMEOUT, activate_cb, &ev, &tv2); 689 690 tv_exit.tv_sec = 0; 691 tv_exit.tv_usec = 600 * 1000; 692 event_base_loopexit(base, &tv_exit); 693 694 event_base_assert_ok_(base); 695 evutil_gettimeofday(&start, NULL); 696 697 event_base_dispatch(base); 698 event_base_assert_ok_(base); 699 700 tt_int_op(res.n, ==, 3); 701 tt_int_op(res.events[0], ==, EV_READ); 702 tt_int_op(res.events[1], ==, EV_TIMEOUT); 703 tt_int_op(res.events[2], ==, EV_TIMEOUT); 704 test_timeval_diff_eq(&start, &res.tvs[0], 100); 705 test_timeval_diff_eq(&start, &res.tvs[1], 300); 706 test_timeval_diff_eq(&start, &res.tvs[2], 500); 707 end: 708 event_del(&ev); 709 } 710 711 struct common_timeout_info { 712 struct event ev; 713 struct timeval called_at; 714 int which; 715 int count; 716 }; 717 718 static void 719 common_timeout_cb(evutil_socket_t fd, short event, void *arg) 720 { 721 struct common_timeout_info *ti = arg; 722 ++ti->count; 723 evutil_gettimeofday(&ti->called_at, NULL); 724 if (ti->count >= 4) 725 event_del(&ti->ev); 726 } 727 728 static void 729 test_common_timeout(void *ptr) 730 { 731 struct basic_test_data *data = ptr; 732 733 struct event_base *base = data->base; 734 int i; 735 struct common_timeout_info info[100]; 736 737 struct timeval start; 738 struct timeval tmp_100_ms = { 0, 100*1000 }; 739 struct timeval tmp_200_ms = { 0, 200*1000 }; 740 741 const struct timeval *ms_100, *ms_200; 742 743 ms_100 = event_base_init_common_timeout(base, &tmp_100_ms); 744 ms_200 = event_base_init_common_timeout(base, &tmp_200_ms); 745 tt_assert(ms_100); 746 tt_assert(ms_200); 747 tt_ptr_op(event_base_init_common_timeout(base, &tmp_200_ms), 748 ==, ms_200); 749 tt_int_op(ms_100->tv_sec, ==, 0); 750 tt_int_op(ms_200->tv_sec, ==, 0); 751 tt_int_op(ms_100->tv_usec, ==, 100000|0x50000000); 752 tt_int_op(ms_200->tv_usec, ==, 200000|0x50100000); 753 754 memset(info, 0, sizeof(info)); 755 756 for (i=0; i<100; ++i) { 757 info[i].which = i; 758 event_assign(&info[i].ev, base, -1, EV_TIMEOUT|EV_PERSIST, 759 common_timeout_cb, &info[i]); 760 if (i % 2) { 761 if ((i%20)==1) { 762 /* Glass-box test: Make sure we survive the 763 * transition to non-common timeouts. It's 764 * a little tricky. */ 765 event_add(&info[i].ev, ms_200); 766 event_add(&info[i].ev, &tmp_100_ms); 767 } else if ((i%20)==3) { 768 /* Check heap-to-common too. */ 769 event_add(&info[i].ev, &tmp_200_ms); 770 event_add(&info[i].ev, ms_100); 771 } else if ((i%20)==5) { 772 /* Also check common-to-common. */ 773 event_add(&info[i].ev, ms_200); 774 event_add(&info[i].ev, ms_100); 775 } else { 776 event_add(&info[i].ev, ms_100); 777 } 778 } else { 779 event_add(&info[i].ev, ms_200); 780 } 781 } 782 783 event_base_assert_ok_(base); 784 evutil_gettimeofday(&start, NULL); 785 event_base_dispatch(base); 786 787 event_base_assert_ok_(base); 788 789 for (i=0; i<10; ++i) { 790 tt_int_op(info[i].count, ==, 4); 791 if (i % 2) { 792 test_timeval_diff_eq(&start, &info[i].called_at, 400); 793 } else { 794 test_timeval_diff_eq(&start, &info[i].called_at, 800); 795 } 796 } 797 798 /* Make sure we can free the base with some events in. */ 799 for (i=0; i<100; ++i) { 800 if (i % 2) { 801 event_add(&info[i].ev, ms_100); 802 } else { 803 event_add(&info[i].ev, ms_200); 804 } 805 } 806 807 end: 808 event_base_free(data->base); /* need to do this here before info is 809 * out-of-scope */ 810 data->base = NULL; 811 } 812 813 #ifndef _WIN32 814 static void signal_cb(evutil_socket_t fd, short event, void *arg); 815 816 #define current_base event_global_current_base_ 817 extern struct event_base *current_base; 818 819 static void 820 child_signal_cb(evutil_socket_t fd, short event, void *arg) 821 { 822 struct timeval tv; 823 int *pint = arg; 824 825 *pint = 1; 826 827 tv.tv_usec = 500000; 828 tv.tv_sec = 0; 829 event_loopexit(&tv); 830 } 831 832 static void 833 test_fork(void) 834 { 835 int status, got_sigchld = 0; 836 struct event ev, sig_ev; 837 pid_t pid; 838 839 setup_test("After fork: "); 840 841 tt_assert(current_base); 842 evthread_make_base_notifiable(current_base); 843 844 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) { 845 tt_fail_perror("write"); 846 } 847 848 event_set(&ev, pair[1], EV_READ, simple_read_cb, &ev); 849 if (event_add(&ev, NULL) == -1) 850 exit(1); 851 852 evsignal_set(&sig_ev, SIGCHLD, child_signal_cb, &got_sigchld); 853 evsignal_add(&sig_ev, NULL); 854 855 event_base_assert_ok_(current_base); 856 TT_BLATHER(("Before fork")); 857 if ((pid = regress_fork()) == 0) { 858 /* in the child */ 859 TT_BLATHER(("In child, before reinit")); 860 event_base_assert_ok_(current_base); 861 if (event_reinit(current_base) == -1) { 862 fprintf(stdout, "FAILED (reinit)\n"); 863 exit(1); 864 } 865 TT_BLATHER(("After reinit")); 866 event_base_assert_ok_(current_base); 867 TT_BLATHER(("After assert-ok")); 868 869 evsignal_del(&sig_ev); 870 871 called = 0; 872 873 event_dispatch(); 874 875 event_base_free(current_base); 876 877 /* we do not send an EOF; simple_read_cb requires an EOF 878 * to set test_ok. we just verify that the callback was 879 * called. */ 880 exit(test_ok != 0 || called != 2 ? -2 : 76); 881 } 882 883 /* wait for the child to read the data */ 884 { 885 const struct timeval tv = { 0, 100000 }; 886 evutil_usleep_(&tv); 887 } 888 889 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) { 890 tt_fail_perror("write"); 891 } 892 893 TT_BLATHER(("Before waitpid")); 894 if (waitpid(pid, &status, 0) == -1) { 895 fprintf(stdout, "FAILED (fork)\n"); 896 exit(1); 897 } 898 TT_BLATHER(("After waitpid")); 899 900 if (WEXITSTATUS(status) != 76) { 901 fprintf(stdout, "FAILED (exit): %d\n", WEXITSTATUS(status)); 902 exit(1); 903 } 904 905 /* test that the current event loop still works */ 906 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) { 907 fprintf(stderr, "%s: write\n", __func__); 908 } 909 910 shutdown(pair[0], SHUT_WR); 911 912 event_dispatch(); 913 914 if (!got_sigchld) { 915 fprintf(stdout, "FAILED (sigchld)\n"); 916 exit(1); 917 } 918 919 evsignal_del(&sig_ev); 920 921 end: 922 cleanup_test(); 923 } 924 925 static void 926 signal_cb_sa(int sig) 927 { 928 test_ok = 2; 929 } 930 931 static void 932 signal_cb(evutil_socket_t fd, short event, void *arg) 933 { 934 struct event *ev = arg; 935 936 evsignal_del(ev); 937 test_ok = 1; 938 } 939 940 static void 941 test_simplesignal(void) 942 { 943 struct event ev; 944 struct itimerval itv; 945 946 setup_test("Simple signal: "); 947 evsignal_set(&ev, SIGALRM, signal_cb, &ev); 948 evsignal_add(&ev, NULL); 949 /* find bugs in which operations are re-ordered */ 950 evsignal_del(&ev); 951 evsignal_add(&ev, NULL); 952 953 memset(&itv, 0, sizeof(itv)); 954 itv.it_value.tv_sec = 0; 955 itv.it_value.tv_usec = 100000; 956 if (setitimer(ITIMER_REAL, &itv, NULL) == -1) 957 goto skip_simplesignal; 958 959 event_dispatch(); 960 skip_simplesignal: 961 if (evsignal_del(&ev) == -1) 962 test_ok = 0; 963 964 cleanup_test(); 965 } 966 967 static void 968 test_multiplesignal(void) 969 { 970 struct event ev_one, ev_two; 971 struct itimerval itv; 972 973 setup_test("Multiple signal: "); 974 975 evsignal_set(&ev_one, SIGALRM, signal_cb, &ev_one); 976 evsignal_add(&ev_one, NULL); 977 978 evsignal_set(&ev_two, SIGALRM, signal_cb, &ev_two); 979 evsignal_add(&ev_two, NULL); 980 981 memset(&itv, 0, sizeof(itv)); 982 itv.it_value.tv_sec = 0; 983 itv.it_value.tv_usec = 100000; 984 if (setitimer(ITIMER_REAL, &itv, NULL) == -1) 985 goto skip_simplesignal; 986 987 event_dispatch(); 988 989 skip_simplesignal: 990 if (evsignal_del(&ev_one) == -1) 991 test_ok = 0; 992 if (evsignal_del(&ev_two) == -1) 993 test_ok = 0; 994 995 cleanup_test(); 996 } 997 998 static void 999 test_immediatesignal(void) 1000 { 1001 struct event ev; 1002 1003 test_ok = 0; 1004 evsignal_set(&ev, SIGUSR1, signal_cb, &ev); 1005 evsignal_add(&ev, NULL); 1006 raise(SIGUSR1); 1007 event_loop(EVLOOP_NONBLOCK); 1008 evsignal_del(&ev); 1009 cleanup_test(); 1010 } 1011 1012 static void 1013 test_signal_dealloc(void) 1014 { 1015 /* make sure that evsignal_event is event_del'ed and pipe closed */ 1016 struct event ev; 1017 struct event_base *base = event_init(); 1018 evsignal_set(&ev, SIGUSR1, signal_cb, &ev); 1019 evsignal_add(&ev, NULL); 1020 evsignal_del(&ev); 1021 event_base_free(base); 1022 /* If we got here without asserting, we're fine. */ 1023 test_ok = 1; 1024 cleanup_test(); 1025 } 1026 1027 static void 1028 test_signal_pipeloss(void) 1029 { 1030 /* make sure that the base1 pipe is closed correctly. */ 1031 struct event_base *base1, *base2; 1032 int pipe1; 1033 test_ok = 0; 1034 base1 = event_init(); 1035 pipe1 = base1->sig.ev_signal_pair[0]; 1036 base2 = event_init(); 1037 event_base_free(base2); 1038 event_base_free(base1); 1039 if (close(pipe1) != -1 || errno!=EBADF) { 1040 /* fd must be closed, so second close gives -1, EBADF */ 1041 printf("signal pipe not closed. "); 1042 test_ok = 0; 1043 } else { 1044 test_ok = 1; 1045 } 1046 cleanup_test(); 1047 } 1048 1049 /* 1050 * make two bases to catch signals, use both of them. this only works 1051 * for event mechanisms that use our signal pipe trick. kqueue handles 1052 * signals internally, and all interested kqueues get all the signals. 1053 */ 1054 static void 1055 test_signal_switchbase(void) 1056 { 1057 struct event ev1, ev2; 1058 struct event_base *base1, *base2; 1059 int is_kqueue; 1060 test_ok = 0; 1061 base1 = event_init(); 1062 base2 = event_init(); 1063 is_kqueue = !strcmp(event_get_method(),"kqueue"); 1064 evsignal_set(&ev1, SIGUSR1, signal_cb, &ev1); 1065 evsignal_set(&ev2, SIGUSR1, signal_cb, &ev2); 1066 if (event_base_set(base1, &ev1) || 1067 event_base_set(base2, &ev2) || 1068 event_add(&ev1, NULL) || 1069 event_add(&ev2, NULL)) { 1070 fprintf(stderr, "%s: cannot set base, add\n", __func__); 1071 exit(1); 1072 } 1073 1074 tt_ptr_op(event_get_base(&ev1), ==, base1); 1075 tt_ptr_op(event_get_base(&ev2), ==, base2); 1076 1077 test_ok = 0; 1078 /* can handle signal before loop is called */ 1079 raise(SIGUSR1); 1080 event_base_loop(base2, EVLOOP_NONBLOCK); 1081 if (is_kqueue) { 1082 if (!test_ok) 1083 goto end; 1084 test_ok = 0; 1085 } 1086 event_base_loop(base1, EVLOOP_NONBLOCK); 1087 if (test_ok && !is_kqueue) { 1088 test_ok = 0; 1089 1090 /* set base1 to handle signals */ 1091 event_base_loop(base1, EVLOOP_NONBLOCK); 1092 raise(SIGUSR1); 1093 event_base_loop(base1, EVLOOP_NONBLOCK); 1094 event_base_loop(base2, EVLOOP_NONBLOCK); 1095 } 1096 end: 1097 event_base_free(base1); 1098 event_base_free(base2); 1099 cleanup_test(); 1100 } 1101 1102 /* 1103 * assert that a signal event removed from the event queue really is 1104 * removed - with no possibility of it's parent handler being fired. 1105 */ 1106 static void 1107 test_signal_assert(void) 1108 { 1109 struct event ev; 1110 struct event_base *base = event_init(); 1111 test_ok = 0; 1112 /* use SIGCONT so we don't kill ourselves when we signal to nowhere */ 1113 evsignal_set(&ev, SIGCONT, signal_cb, &ev); 1114 evsignal_add(&ev, NULL); 1115 /* 1116 * if evsignal_del() fails to reset the handler, it's current handler 1117 * will still point to evsig_handler(). 1118 */ 1119 evsignal_del(&ev); 1120 1121 raise(SIGCONT); 1122 #if 0 1123 /* only way to verify we were in evsig_handler() */ 1124 /* XXXX Now there's no longer a good way. */ 1125 if (base->sig.evsig_caught) 1126 test_ok = 0; 1127 else 1128 test_ok = 1; 1129 #else 1130 test_ok = 1; 1131 #endif 1132 1133 event_base_free(base); 1134 cleanup_test(); 1135 return; 1136 } 1137 1138 /* 1139 * assert that we restore our previous signal handler properly. 1140 */ 1141 static void 1142 test_signal_restore(void) 1143 { 1144 struct event ev; 1145 struct event_base *base = event_init(); 1146 #ifdef EVENT__HAVE_SIGACTION 1147 struct sigaction sa; 1148 #endif 1149 1150 test_ok = 0; 1151 #ifdef EVENT__HAVE_SIGACTION 1152 sa.sa_handler = signal_cb_sa; 1153 sa.sa_flags = 0x0; 1154 sigemptyset(&sa.sa_mask); 1155 if (sigaction(SIGUSR1, &sa, NULL) == -1) 1156 goto out; 1157 #else 1158 if (signal(SIGUSR1, signal_cb_sa) == SIG_ERR) 1159 goto out; 1160 #endif 1161 evsignal_set(&ev, SIGUSR1, signal_cb, &ev); 1162 evsignal_add(&ev, NULL); 1163 evsignal_del(&ev); 1164 1165 raise(SIGUSR1); 1166 /* 1 == signal_cb, 2 == signal_cb_sa, we want our previous handler */ 1167 if (test_ok != 2) 1168 test_ok = 0; 1169 out: 1170 event_base_free(base); 1171 cleanup_test(); 1172 return; 1173 } 1174 1175 static void 1176 signal_cb_swp(int sig, short event, void *arg) 1177 { 1178 called++; 1179 if (called < 5) 1180 raise(sig); 1181 else 1182 event_loopexit(NULL); 1183 } 1184 static void 1185 timeout_cb_swp(evutil_socket_t fd, short event, void *arg) 1186 { 1187 if (called == -1) { 1188 struct timeval tv = {5, 0}; 1189 1190 called = 0; 1191 evtimer_add((struct event *)arg, &tv); 1192 raise(SIGUSR1); 1193 return; 1194 } 1195 test_ok = 0; 1196 event_loopexit(NULL); 1197 } 1198 1199 static void 1200 test_signal_while_processing(void) 1201 { 1202 struct event_base *base = event_init(); 1203 struct event ev, ev_timer; 1204 struct timeval tv = {0, 0}; 1205 1206 setup_test("Receiving a signal while processing other signal: "); 1207 1208 called = -1; 1209 test_ok = 1; 1210 signal_set(&ev, SIGUSR1, signal_cb_swp, NULL); 1211 signal_add(&ev, NULL); 1212 evtimer_set(&ev_timer, timeout_cb_swp, &ev_timer); 1213 evtimer_add(&ev_timer, &tv); 1214 event_dispatch(); 1215 1216 event_base_free(base); 1217 cleanup_test(); 1218 return; 1219 } 1220 #endif 1221 1222 static void 1223 test_free_active_base(void *ptr) 1224 { 1225 struct basic_test_data *data = ptr; 1226 struct event_base *base1; 1227 struct event ev1; 1228 1229 base1 = event_init(); 1230 if (base1) { 1231 event_assign(&ev1, base1, data->pair[1], EV_READ, 1232 dummy_read_cb, NULL); 1233 event_add(&ev1, NULL); 1234 event_base_free(base1); /* should not crash */ 1235 } else { 1236 tt_fail_msg("failed to create event_base for test"); 1237 } 1238 1239 base1 = event_init(); 1240 tt_assert(base1); 1241 event_assign(&ev1, base1, 0, 0, dummy_read_cb, NULL); 1242 event_active(&ev1, EV_READ, 1); 1243 event_base_free(base1); 1244 end: 1245 ; 1246 } 1247 1248 static void 1249 test_manipulate_active_events(void *ptr) 1250 { 1251 struct basic_test_data *data = ptr; 1252 struct event_base *base = data->base; 1253 struct event ev1; 1254 1255 event_assign(&ev1, base, -1, EV_TIMEOUT, dummy_read_cb, NULL); 1256 1257 /* Make sure an active event is pending. */ 1258 event_active(&ev1, EV_READ, 1); 1259 tt_int_op(event_pending(&ev1, EV_READ|EV_TIMEOUT|EV_WRITE, NULL), 1260 ==, EV_READ); 1261 1262 /* Make sure that activating an event twice works. */ 1263 event_active(&ev1, EV_WRITE, 1); 1264 tt_int_op(event_pending(&ev1, EV_READ|EV_TIMEOUT|EV_WRITE, NULL), 1265 ==, EV_READ|EV_WRITE); 1266 1267 end: 1268 event_del(&ev1); 1269 } 1270 1271 static void 1272 event_selfarg_cb(evutil_socket_t fd, short event, void *arg) 1273 { 1274 struct event *ev = arg; 1275 struct event_base *base = event_get_base(ev); 1276 event_base_assert_ok_(base); 1277 event_base_loopexit(base, NULL); 1278 tt_want(ev == event_base_get_running_event(base)); 1279 } 1280 1281 static void 1282 test_event_new_selfarg(void *ptr) 1283 { 1284 struct basic_test_data *data = ptr; 1285 struct event_base *base = data->base; 1286 struct event *ev = event_new(base, -1, EV_READ, event_selfarg_cb, 1287 event_self_cbarg()); 1288 1289 event_active(ev, EV_READ, 1); 1290 event_base_dispatch(base); 1291 1292 event_free(ev); 1293 } 1294 1295 static void 1296 test_event_assign_selfarg(void *ptr) 1297 { 1298 struct basic_test_data *data = ptr; 1299 struct event_base *base = data->base; 1300 struct event ev; 1301 1302 event_assign(&ev, base, -1, EV_READ, event_selfarg_cb, 1303 event_self_cbarg()); 1304 event_active(&ev, EV_READ, 1); 1305 event_base_dispatch(base); 1306 } 1307 1308 static void 1309 test_bad_assign(void *ptr) 1310 { 1311 struct event ev; 1312 int r; 1313 /* READ|SIGNAL is not allowed */ 1314 r = event_assign(&ev, NULL, -1, EV_SIGNAL|EV_READ, dummy_read_cb, NULL); 1315 tt_int_op(r,==,-1); 1316 1317 end: 1318 ; 1319 } 1320 1321 static int reentrant_cb_run = 0; 1322 1323 static void 1324 bad_reentrant_run_loop_cb(evutil_socket_t fd, short what, void *ptr) 1325 { 1326 struct event_base *base = ptr; 1327 int r; 1328 reentrant_cb_run = 1; 1329 /* This reentrant call to event_base_loop should be detected and 1330 * should fail */ 1331 r = event_base_loop(base, 0); 1332 tt_int_op(r, ==, -1); 1333 end: 1334 ; 1335 } 1336 1337 static void 1338 test_bad_reentrant(void *ptr) 1339 { 1340 struct basic_test_data *data = ptr; 1341 struct event_base *base = data->base; 1342 struct event ev; 1343 int r; 1344 event_assign(&ev, base, -1, 1345 0, bad_reentrant_run_loop_cb, base); 1346 1347 event_active(&ev, EV_WRITE, 1); 1348 r = event_base_loop(base, 0); 1349 tt_int_op(r, ==, 1); 1350 tt_int_op(reentrant_cb_run, ==, 1); 1351 end: 1352 ; 1353 } 1354 1355 static int n_write_a_byte_cb=0; 1356 static int n_read_and_drain_cb=0; 1357 static int n_activate_other_event_cb=0; 1358 static void 1359 write_a_byte_cb(evutil_socket_t fd, short what, void *arg) 1360 { 1361 char buf[] = "x"; 1362 if (write(fd, buf, 1) == 1) 1363 ++n_write_a_byte_cb; 1364 } 1365 static void 1366 read_and_drain_cb(evutil_socket_t fd, short what, void *arg) 1367 { 1368 char buf[128]; 1369 int n; 1370 ++n_read_and_drain_cb; 1371 while ((n = read(fd, buf, sizeof(buf))) > 0) 1372 ; 1373 } 1374 1375 static void 1376 activate_other_event_cb(evutil_socket_t fd, short what, void *other_) 1377 { 1378 struct event *ev_activate = other_; 1379 ++n_activate_other_event_cb; 1380 event_active_later_(ev_activate, EV_READ); 1381 } 1382 1383 static void 1384 test_active_later(void *ptr) 1385 { 1386 struct basic_test_data *data = ptr; 1387 struct event *ev1, *ev2; 1388 struct event ev3, ev4; 1389 struct timeval qsec = {0, 100000}; 1390 ev1 = event_new(data->base, data->pair[0], EV_READ|EV_PERSIST, read_and_drain_cb, NULL); 1391 ev2 = event_new(data->base, data->pair[1], EV_WRITE|EV_PERSIST, write_a_byte_cb, NULL); 1392 event_assign(&ev3, data->base, -1, 0, activate_other_event_cb, &ev4); 1393 event_assign(&ev4, data->base, -1, 0, activate_other_event_cb, &ev3); 1394 event_add(ev1, NULL); 1395 event_add(ev2, NULL); 1396 event_active_later_(&ev3, EV_READ); 1397 1398 event_base_loopexit(data->base, &qsec); 1399 1400 event_base_loop(data->base, 0); 1401 1402 TT_BLATHER(("%d write calls, %d read calls, %d activate-other calls.", 1403 n_write_a_byte_cb, n_read_and_drain_cb, n_activate_other_event_cb)); 1404 event_del(&ev3); 1405 event_del(&ev4); 1406 1407 tt_int_op(n_write_a_byte_cb, ==, n_activate_other_event_cb); 1408 tt_int_op(n_write_a_byte_cb, >, 100); 1409 tt_int_op(n_read_and_drain_cb, >, 100); 1410 tt_int_op(n_activate_other_event_cb, >, 100); 1411 end: 1412 ; 1413 } 1414 1415 1416 static void incr_arg_cb(evutil_socket_t fd, short what, void *arg) 1417 { 1418 int *intptr = arg; 1419 (void) fd; (void) what; 1420 ++*intptr; 1421 } 1422 static void remove_timers_cb(evutil_socket_t fd, short what, void *arg) 1423 { 1424 struct event **ep = arg; 1425 (void) fd; (void) what; 1426 event_remove_timer(ep[0]); 1427 event_remove_timer(ep[1]); 1428 } 1429 static void send_a_byte_cb(evutil_socket_t fd, short what, void *arg) 1430 { 1431 evutil_socket_t *sockp = arg; 1432 (void) fd; (void) what; 1433 write(*sockp, "A", 1); 1434 } 1435 struct read_not_timeout_param 1436 { 1437 struct event **ev; 1438 int events; 1439 int count; 1440 }; 1441 static void read_not_timeout_cb(evutil_socket_t fd, short what, void *arg) 1442 { 1443 struct read_not_timeout_param *rntp = arg; 1444 char c; 1445 (void) fd; (void) what; 1446 read(fd, &c, 1); 1447 rntp->events |= what; 1448 ++rntp->count; 1449 if(2 == rntp->count) event_del(rntp->ev[0]); 1450 } 1451 1452 static void 1453 test_event_remove_timeout(void *ptr) 1454 { 1455 struct basic_test_data *data = ptr; 1456 struct event_base *base = data->base; 1457 struct event *ev[5]; 1458 int ev1_fired=0; 1459 struct timeval ms25 = { 0, 25*1000 }, 1460 ms40 = { 0, 40*1000 }, 1461 ms75 = { 0, 75*1000 }, 1462 ms125 = { 0, 125*1000 }; 1463 struct read_not_timeout_param rntp = { ev, 0, 0 }; 1464 1465 event_base_assert_ok_(base); 1466 1467 ev[0] = event_new(base, data->pair[0], EV_READ|EV_PERSIST, 1468 read_not_timeout_cb, &rntp); 1469 ev[1] = evtimer_new(base, incr_arg_cb, &ev1_fired); 1470 ev[2] = evtimer_new(base, remove_timers_cb, ev); 1471 ev[3] = evtimer_new(base, send_a_byte_cb, &data->pair[1]); 1472 ev[4] = evtimer_new(base, send_a_byte_cb, &data->pair[1]); 1473 tt_assert(base); 1474 event_add(ev[2], &ms25); /* remove timers */ 1475 event_add(ev[4], &ms40); /* write to test if timer re-activates */ 1476 event_add(ev[0], &ms75); /* read */ 1477 event_add(ev[1], &ms75); /* timer */ 1478 event_add(ev[3], &ms125); /* timeout. */ 1479 event_base_assert_ok_(base); 1480 1481 event_base_dispatch(base); 1482 1483 tt_int_op(ev1_fired, ==, 0); 1484 tt_int_op(rntp.events, ==, EV_READ); 1485 1486 event_base_assert_ok_(base); 1487 end: 1488 event_free(ev[0]); 1489 event_free(ev[1]); 1490 event_free(ev[2]); 1491 event_free(ev[3]); 1492 event_free(ev[4]); 1493 } 1494 1495 static void 1496 test_event_base_new(void *ptr) 1497 { 1498 struct basic_test_data *data = ptr; 1499 struct event_base *base = 0; 1500 struct event ev1; 1501 struct basic_cb_args args; 1502 1503 int towrite = (int)strlen(TEST1)+1; 1504 int len = write(data->pair[0], TEST1, towrite); 1505 1506 if (len < 0) 1507 tt_abort_perror("initial write"); 1508 else if (len != towrite) 1509 tt_abort_printf(("initial write fell short (%d of %d bytes)", 1510 len, towrite)); 1511 1512 if (shutdown(data->pair[0], SHUT_WR)) 1513 tt_abort_perror("initial write shutdown"); 1514 1515 base = event_base_new(); 1516 if (!base) 1517 tt_abort_msg("failed to create event base"); 1518 1519 args.eb = base; 1520 args.ev = &ev1; 1521 args.callcount = 0; 1522 event_assign(&ev1, base, data->pair[1], 1523 EV_READ|EV_PERSIST, basic_read_cb, &args); 1524 1525 if (event_add(&ev1, NULL)) 1526 tt_abort_perror("initial event_add"); 1527 1528 if (event_base_loop(base, 0)) 1529 tt_abort_msg("unsuccessful exit from event loop"); 1530 1531 end: 1532 if (base) 1533 event_base_free(base); 1534 } 1535 1536 static void 1537 test_loopexit(void) 1538 { 1539 struct timeval tv, tv_start, tv_end; 1540 struct event ev; 1541 1542 setup_test("Loop exit: "); 1543 1544 tv.tv_usec = 0; 1545 tv.tv_sec = 60*60*24; 1546 evtimer_set(&ev, timeout_cb, NULL); 1547 evtimer_add(&ev, &tv); 1548 1549 tv.tv_usec = 300*1000; 1550 tv.tv_sec = 0; 1551 event_loopexit(&tv); 1552 1553 evutil_gettimeofday(&tv_start, NULL); 1554 event_dispatch(); 1555 evutil_gettimeofday(&tv_end, NULL); 1556 1557 evtimer_del(&ev); 1558 1559 tt_assert(event_base_got_exit(global_base)); 1560 tt_assert(!event_base_got_break(global_base)); 1561 1562 test_timeval_diff_eq(&tv_start, &tv_end, 300); 1563 1564 test_ok = 1; 1565 end: 1566 cleanup_test(); 1567 } 1568 1569 static void 1570 test_loopexit_multiple(void) 1571 { 1572 struct timeval tv, tv_start, tv_end; 1573 struct event_base *base; 1574 1575 setup_test("Loop Multiple exit: "); 1576 1577 base = event_base_new(); 1578 1579 tv.tv_usec = 200*1000; 1580 tv.tv_sec = 0; 1581 event_base_loopexit(base, &tv); 1582 1583 tv.tv_usec = 0; 1584 tv.tv_sec = 3; 1585 event_base_loopexit(base, &tv); 1586 1587 evutil_gettimeofday(&tv_start, NULL); 1588 event_base_dispatch(base); 1589 evutil_gettimeofday(&tv_end, NULL); 1590 1591 tt_assert(event_base_got_exit(base)); 1592 tt_assert(!event_base_got_break(base)); 1593 1594 event_base_free(base); 1595 1596 test_timeval_diff_eq(&tv_start, &tv_end, 200); 1597 1598 test_ok = 1; 1599 1600 end: 1601 cleanup_test(); 1602 } 1603 1604 static void 1605 break_cb(evutil_socket_t fd, short events, void *arg) 1606 { 1607 test_ok = 1; 1608 event_loopbreak(); 1609 } 1610 1611 static void 1612 fail_cb(evutil_socket_t fd, short events, void *arg) 1613 { 1614 test_ok = 0; 1615 } 1616 1617 static void 1618 test_loopbreak(void) 1619 { 1620 struct event ev1, ev2; 1621 struct timeval tv; 1622 1623 setup_test("Loop break: "); 1624 1625 tv.tv_sec = 0; 1626 tv.tv_usec = 0; 1627 evtimer_set(&ev1, break_cb, NULL); 1628 evtimer_add(&ev1, &tv); 1629 evtimer_set(&ev2, fail_cb, NULL); 1630 evtimer_add(&ev2, &tv); 1631 1632 event_dispatch(); 1633 1634 tt_assert(!event_base_got_exit(global_base)); 1635 tt_assert(event_base_got_break(global_base)); 1636 1637 evtimer_del(&ev1); 1638 evtimer_del(&ev2); 1639 1640 end: 1641 cleanup_test(); 1642 } 1643 1644 static struct event *readd_test_event_last_added = NULL; 1645 static void 1646 re_add_read_cb(evutil_socket_t fd, short event, void *arg) 1647 { 1648 char buf[256]; 1649 struct event *ev_other = arg; 1650 readd_test_event_last_added = ev_other; 1651 1652 if (read(fd, buf, sizeof(buf)) < 0) { 1653 tt_fail_perror("read"); 1654 } 1655 1656 event_add(ev_other, NULL); 1657 ++test_ok; 1658 } 1659 1660 static void 1661 test_nonpersist_readd(void) 1662 { 1663 struct event ev1, ev2; 1664 1665 setup_test("Re-add nonpersistent events: "); 1666 event_set(&ev1, pair[0], EV_READ, re_add_read_cb, &ev2); 1667 event_set(&ev2, pair[1], EV_READ, re_add_read_cb, &ev1); 1668 1669 if (write(pair[0], "Hello", 5) < 0) { 1670 tt_fail_perror("write(pair[0])"); 1671 } 1672 1673 if (write(pair[1], "Hello", 5) < 0) { 1674 tt_fail_perror("write(pair[1])\n"); 1675 } 1676 1677 if (event_add(&ev1, NULL) == -1 || 1678 event_add(&ev2, NULL) == -1) { 1679 test_ok = 0; 1680 } 1681 if (test_ok != 0) 1682 exit(1); 1683 event_loop(EVLOOP_ONCE); 1684 if (test_ok != 2) 1685 exit(1); 1686 /* At this point, we executed both callbacks. Whichever one got 1687 * called first added the second, but the second then immediately got 1688 * deleted before its callback was called. At this point, though, it 1689 * re-added the first. 1690 */ 1691 if (!readd_test_event_last_added) { 1692 test_ok = 0; 1693 } else if (readd_test_event_last_added == &ev1) { 1694 if (!event_pending(&ev1, EV_READ, NULL) || 1695 event_pending(&ev2, EV_READ, NULL)) 1696 test_ok = 0; 1697 } else { 1698 if (event_pending(&ev1, EV_READ, NULL) || 1699 !event_pending(&ev2, EV_READ, NULL)) 1700 test_ok = 0; 1701 } 1702 1703 event_del(&ev1); 1704 event_del(&ev2); 1705 1706 cleanup_test(); 1707 } 1708 1709 struct test_pri_event { 1710 struct event ev; 1711 int count; 1712 }; 1713 1714 static void 1715 test_priorities_cb(evutil_socket_t fd, short what, void *arg) 1716 { 1717 struct test_pri_event *pri = arg; 1718 struct timeval tv; 1719 1720 if (pri->count == 3) { 1721 event_loopexit(NULL); 1722 return; 1723 } 1724 1725 pri->count++; 1726 1727 evutil_timerclear(&tv); 1728 event_add(&pri->ev, &tv); 1729 } 1730 1731 static void 1732 test_priorities_impl(int npriorities) 1733 { 1734 struct test_pri_event one, two; 1735 struct timeval tv; 1736 1737 TT_BLATHER(("Testing Priorities %d: ", npriorities)); 1738 1739 event_base_priority_init(global_base, npriorities); 1740 1741 memset(&one, 0, sizeof(one)); 1742 memset(&two, 0, sizeof(two)); 1743 1744 timeout_set(&one.ev, test_priorities_cb, &one); 1745 if (event_priority_set(&one.ev, 0) == -1) { 1746 fprintf(stderr, "%s: failed to set priority", __func__); 1747 exit(1); 1748 } 1749 1750 timeout_set(&two.ev, test_priorities_cb, &two); 1751 if (event_priority_set(&two.ev, npriorities - 1) == -1) { 1752 fprintf(stderr, "%s: failed to set priority", __func__); 1753 exit(1); 1754 } 1755 1756 evutil_timerclear(&tv); 1757 1758 if (event_add(&one.ev, &tv) == -1) 1759 exit(1); 1760 if (event_add(&two.ev, &tv) == -1) 1761 exit(1); 1762 1763 event_dispatch(); 1764 1765 event_del(&one.ev); 1766 event_del(&two.ev); 1767 1768 if (npriorities == 1) { 1769 if (one.count == 3 && two.count == 3) 1770 test_ok = 1; 1771 } else if (npriorities == 2) { 1772 /* Two is called once because event_loopexit is priority 1 */ 1773 if (one.count == 3 && two.count == 1) 1774 test_ok = 1; 1775 } else { 1776 if (one.count == 3 && two.count == 0) 1777 test_ok = 1; 1778 } 1779 } 1780 1781 static void 1782 test_priorities(void) 1783 { 1784 test_priorities_impl(1); 1785 if (test_ok) 1786 test_priorities_impl(2); 1787 if (test_ok) 1788 test_priorities_impl(3); 1789 } 1790 1791 /* priority-active-inversion: activate a higher-priority event, and make sure 1792 * it keeps us from running a lower-priority event first. */ 1793 static int n_pai_calls = 0; 1794 static struct event pai_events[3]; 1795 1796 static void 1797 prio_active_inversion_cb(evutil_socket_t fd, short what, void *arg) 1798 { 1799 int *call_order = arg; 1800 *call_order = n_pai_calls++; 1801 if (n_pai_calls == 1) { 1802 /* This should activate later, even though it shares a 1803 priority with us. */ 1804 event_active(&pai_events[1], EV_READ, 1); 1805 /* This should activate next, since its priority is higher, 1806 even though we activated it second. */ 1807 event_active(&pai_events[2], EV_TIMEOUT, 1); 1808 } 1809 } 1810 1811 static void 1812 test_priority_active_inversion(void *data_) 1813 { 1814 struct basic_test_data *data = data_; 1815 struct event_base *base = data->base; 1816 int call_order[3]; 1817 int i; 1818 tt_int_op(event_base_priority_init(base, 8), ==, 0); 1819 1820 n_pai_calls = 0; 1821 memset(call_order, 0, sizeof(call_order)); 1822 1823 for (i=0;i<3;++i) { 1824 event_assign(&pai_events[i], data->base, -1, 0, 1825 prio_active_inversion_cb, &call_order[i]); 1826 } 1827 1828 event_priority_set(&pai_events[0], 4); 1829 event_priority_set(&pai_events[1], 4); 1830 event_priority_set(&pai_events[2], 0); 1831 1832 event_active(&pai_events[0], EV_WRITE, 1); 1833 1834 event_base_dispatch(base); 1835 tt_int_op(n_pai_calls, ==, 3); 1836 tt_int_op(call_order[0], ==, 0); 1837 tt_int_op(call_order[1], ==, 2); 1838 tt_int_op(call_order[2], ==, 1); 1839 end: 1840 ; 1841 } 1842 1843 1844 static void 1845 test_multiple_cb(evutil_socket_t fd, short event, void *arg) 1846 { 1847 if (event & EV_READ) 1848 test_ok |= 1; 1849 else if (event & EV_WRITE) 1850 test_ok |= 2; 1851 } 1852 1853 static void 1854 test_multiple_events_for_same_fd(void) 1855 { 1856 struct event e1, e2; 1857 1858 setup_test("Multiple events for same fd: "); 1859 1860 event_set(&e1, pair[0], EV_READ, test_multiple_cb, NULL); 1861 event_add(&e1, NULL); 1862 event_set(&e2, pair[0], EV_WRITE, test_multiple_cb, NULL); 1863 event_add(&e2, NULL); 1864 event_loop(EVLOOP_ONCE); 1865 event_del(&e2); 1866 1867 if (write(pair[1], TEST1, strlen(TEST1)+1) < 0) { 1868 tt_fail_perror("write"); 1869 } 1870 1871 event_loop(EVLOOP_ONCE); 1872 event_del(&e1); 1873 1874 if (test_ok != 3) 1875 test_ok = 0; 1876 1877 cleanup_test(); 1878 } 1879 1880 int evtag_decode_int(ev_uint32_t *pnumber, struct evbuffer *evbuf); 1881 int evtag_decode_int64(ev_uint64_t *pnumber, struct evbuffer *evbuf); 1882 int evtag_encode_tag(struct evbuffer *evbuf, ev_uint32_t number); 1883 int evtag_decode_tag(ev_uint32_t *pnumber, struct evbuffer *evbuf); 1884 1885 static void 1886 read_once_cb(evutil_socket_t fd, short event, void *arg) 1887 { 1888 char buf[256]; 1889 int len; 1890 1891 len = read(fd, buf, sizeof(buf)); 1892 1893 if (called) { 1894 test_ok = 0; 1895 } else if (len) { 1896 /* Assumes global pair[0] can be used for writing */ 1897 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) { 1898 tt_fail_perror("write"); 1899 test_ok = 0; 1900 } else { 1901 test_ok = 1; 1902 } 1903 } 1904 1905 called++; 1906 } 1907 1908 static void 1909 test_want_only_once(void) 1910 { 1911 struct event ev; 1912 struct timeval tv; 1913 1914 /* Very simple read test */ 1915 setup_test("Want read only once: "); 1916 1917 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) { 1918 tt_fail_perror("write"); 1919 } 1920 1921 /* Setup the loop termination */ 1922 evutil_timerclear(&tv); 1923 tv.tv_usec = 300*1000; 1924 event_loopexit(&tv); 1925 1926 event_set(&ev, pair[1], EV_READ, read_once_cb, &ev); 1927 if (event_add(&ev, NULL) == -1) 1928 exit(1); 1929 event_dispatch(); 1930 1931 cleanup_test(); 1932 } 1933 1934 #define TEST_MAX_INT 6 1935 1936 static void 1937 evtag_int_test(void *ptr) 1938 { 1939 struct evbuffer *tmp = evbuffer_new(); 1940 ev_uint32_t integers[TEST_MAX_INT] = { 1941 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000 1942 }; 1943 ev_uint32_t integer; 1944 ev_uint64_t big_int; 1945 int i; 1946 1947 evtag_init(); 1948 1949 for (i = 0; i < TEST_MAX_INT; i++) { 1950 int oldlen, newlen; 1951 oldlen = (int)EVBUFFER_LENGTH(tmp); 1952 evtag_encode_int(tmp, integers[i]); 1953 newlen = (int)EVBUFFER_LENGTH(tmp); 1954 TT_BLATHER(("encoded 0x%08x with %d bytes", 1955 (unsigned)integers[i], newlen - oldlen)); 1956 big_int = integers[i]; 1957 big_int *= 1000000000; /* 1 billion */ 1958 evtag_encode_int64(tmp, big_int); 1959 } 1960 1961 for (i = 0; i < TEST_MAX_INT; i++) { 1962 tt_int_op(evtag_decode_int(&integer, tmp), !=, -1); 1963 tt_uint_op(integer, ==, integers[i]); 1964 tt_int_op(evtag_decode_int64(&big_int, tmp), !=, -1); 1965 tt_assert((big_int / 1000000000) == integers[i]); 1966 } 1967 1968 tt_uint_op(EVBUFFER_LENGTH(tmp), ==, 0); 1969 end: 1970 evbuffer_free(tmp); 1971 } 1972 1973 static void 1974 evtag_fuzz(void *ptr) 1975 { 1976 u_char buffer[4096]; 1977 struct evbuffer *tmp = evbuffer_new(); 1978 struct timeval tv; 1979 int i, j; 1980 1981 int not_failed = 0; 1982 1983 evtag_init(); 1984 1985 for (j = 0; j < 100; j++) { 1986 for (i = 0; i < (int)sizeof(buffer); i++) 1987 buffer[i] = rand(); 1988 evbuffer_drain(tmp, -1); 1989 evbuffer_add(tmp, buffer, sizeof(buffer)); 1990 1991 if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1) 1992 not_failed++; 1993 } 1994 1995 /* The majority of decodes should fail */ 1996 tt_int_op(not_failed, <, 10); 1997 1998 /* Now insert some corruption into the tag length field */ 1999 evbuffer_drain(tmp, -1); 2000 evutil_timerclear(&tv); 2001 tv.tv_sec = 1; 2002 evtag_marshal_timeval(tmp, 0, &tv); 2003 evbuffer_add(tmp, buffer, sizeof(buffer)); 2004 2005 ((char *)EVBUFFER_DATA(tmp))[1] = '\xff'; 2006 if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1) { 2007 tt_abort_msg("evtag_unmarshal_timeval should have failed"); 2008 } 2009 2010 end: 2011 evbuffer_free(tmp); 2012 } 2013 2014 static void 2015 evtag_tag_encoding(void *ptr) 2016 { 2017 struct evbuffer *tmp = evbuffer_new(); 2018 ev_uint32_t integers[TEST_MAX_INT] = { 2019 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000 2020 }; 2021 ev_uint32_t integer; 2022 int i; 2023 2024 evtag_init(); 2025 2026 for (i = 0; i < TEST_MAX_INT; i++) { 2027 int oldlen, newlen; 2028 oldlen = (int)EVBUFFER_LENGTH(tmp); 2029 evtag_encode_tag(tmp, integers[i]); 2030 newlen = (int)EVBUFFER_LENGTH(tmp); 2031 TT_BLATHER(("encoded 0x%08x with %d bytes", 2032 (unsigned)integers[i], newlen - oldlen)); 2033 } 2034 2035 for (i = 0; i < TEST_MAX_INT; i++) { 2036 tt_int_op(evtag_decode_tag(&integer, tmp), !=, -1); 2037 tt_uint_op(integer, ==, integers[i]); 2038 } 2039 2040 tt_uint_op(EVBUFFER_LENGTH(tmp), ==, 0); 2041 2042 end: 2043 evbuffer_free(tmp); 2044 } 2045 2046 static void 2047 evtag_test_peek(void *ptr) 2048 { 2049 struct evbuffer *tmp = evbuffer_new(); 2050 ev_uint32_t u32; 2051 2052 evtag_marshal_int(tmp, 30, 0); 2053 evtag_marshal_string(tmp, 40, "Hello world"); 2054 2055 tt_int_op(evtag_peek(tmp, &u32), ==, 1); 2056 tt_int_op(u32, ==, 30); 2057 tt_int_op(evtag_peek_length(tmp, &u32), ==, 0); 2058 tt_int_op(u32, ==, 1+1+1); 2059 tt_int_op(evtag_consume(tmp), ==, 0); 2060 2061 tt_int_op(evtag_peek(tmp, &u32), ==, 1); 2062 tt_int_op(u32, ==, 40); 2063 tt_int_op(evtag_peek_length(tmp, &u32), ==, 0); 2064 tt_int_op(u32, ==, 1+1+11); 2065 tt_int_op(evtag_payload_length(tmp, &u32), ==, 0); 2066 tt_int_op(u32, ==, 11); 2067 2068 end: 2069 evbuffer_free(tmp); 2070 } 2071 2072 2073 static void 2074 test_methods(void *ptr) 2075 { 2076 const char **methods = event_get_supported_methods(); 2077 struct event_config *cfg = NULL; 2078 struct event_base *base = NULL; 2079 const char *backend; 2080 int n_methods = 0; 2081 2082 tt_assert(methods); 2083 2084 backend = methods[0]; 2085 while (*methods != NULL) { 2086 TT_BLATHER(("Support method: %s", *methods)); 2087 ++methods; 2088 ++n_methods; 2089 } 2090 2091 cfg = event_config_new(); 2092 assert(cfg != NULL); 2093 2094 tt_int_op(event_config_avoid_method(cfg, backend), ==, 0); 2095 event_config_set_flag(cfg, EVENT_BASE_FLAG_IGNORE_ENV); 2096 2097 base = event_base_new_with_config(cfg); 2098 if (n_methods > 1) { 2099 tt_assert(base); 2100 tt_str_op(backend, !=, event_base_get_method(base)); 2101 } else { 2102 tt_assert(base == NULL); 2103 } 2104 2105 end: 2106 if (base) 2107 event_base_free(base); 2108 if (cfg) 2109 event_config_free(cfg); 2110 } 2111 2112 static void 2113 test_version(void *arg) 2114 { 2115 const char *vstr; 2116 ev_uint32_t vint; 2117 int major, minor, patch, n; 2118 2119 vstr = event_get_version(); 2120 vint = event_get_version_number(); 2121 2122 tt_assert(vstr); 2123 tt_assert(vint); 2124 2125 tt_str_op(vstr, ==, LIBEVENT_VERSION); 2126 tt_int_op(vint, ==, LIBEVENT_VERSION_NUMBER); 2127 2128 n = sscanf(vstr, "%d.%d.%d", &major, &minor, &patch); 2129 tt_assert(3 == n); 2130 tt_int_op((vint&0xffffff00), ==, ((major<<24)|(minor<<16)|(patch<<8))); 2131 end: 2132 ; 2133 } 2134 2135 static void 2136 test_base_features(void *arg) 2137 { 2138 struct event_base *base = NULL; 2139 struct event_config *cfg = NULL; 2140 2141 cfg = event_config_new(); 2142 2143 tt_assert(0 == event_config_require_features(cfg, EV_FEATURE_ET)); 2144 2145 base = event_base_new_with_config(cfg); 2146 if (base) { 2147 tt_int_op(EV_FEATURE_ET, ==, 2148 event_base_get_features(base) & EV_FEATURE_ET); 2149 } else { 2150 base = event_base_new(); 2151 tt_int_op(0, ==, event_base_get_features(base) & EV_FEATURE_ET); 2152 } 2153 2154 end: 2155 if (base) 2156 event_base_free(base); 2157 if (cfg) 2158 event_config_free(cfg); 2159 } 2160 2161 #ifdef EVENT__HAVE_SETENV 2162 #define SETENV_OK 2163 #elif !defined(EVENT__HAVE_SETENV) && defined(EVENT__HAVE_PUTENV) 2164 static void setenv(const char *k, const char *v, int o_) 2165 { 2166 char b[256]; 2167 evutil_snprintf(b, sizeof(b), "%s=%s",k,v); 2168 putenv(b); 2169 } 2170 #define SETENV_OK 2171 #endif 2172 2173 #ifdef EVENT__HAVE_UNSETENV 2174 #define UNSETENV_OK 2175 #elif !defined(EVENT__HAVE_UNSETENV) && defined(EVENT__HAVE_PUTENV) 2176 static void unsetenv(const char *k) 2177 { 2178 char b[256]; 2179 evutil_snprintf(b, sizeof(b), "%s=",k); 2180 putenv(b); 2181 } 2182 #define UNSETENV_OK 2183 #endif 2184 2185 #if defined(SETENV_OK) && defined(UNSETENV_OK) 2186 static void 2187 methodname_to_envvar(const char *mname, char *buf, size_t buflen) 2188 { 2189 char *cp; 2190 evutil_snprintf(buf, buflen, "EVENT_NO%s", mname); 2191 for (cp = buf; *cp; ++cp) { 2192 *cp = EVUTIL_TOUPPER_(*cp); 2193 } 2194 } 2195 #endif 2196 2197 static void 2198 test_base_environ(void *arg) 2199 { 2200 struct event_base *base = NULL; 2201 struct event_config *cfg = NULL; 2202 2203 #if defined(SETENV_OK) && defined(UNSETENV_OK) 2204 const char **basenames; 2205 int i, n_methods=0; 2206 char varbuf[128]; 2207 const char *defaultname, *ignoreenvname; 2208 2209 /* See if unsetenv works before we rely on it. */ 2210 setenv("EVENT_NOWAFFLES", "1", 1); 2211 unsetenv("EVENT_NOWAFFLES"); 2212 if (getenv("EVENT_NOWAFFLES") != NULL) { 2213 #ifndef EVENT__HAVE_UNSETENV 2214 TT_DECLARE("NOTE", ("Can't fake unsetenv; skipping test")); 2215 #else 2216 TT_DECLARE("NOTE", ("unsetenv doesn't work; skipping test")); 2217 #endif 2218 tt_skip(); 2219 } 2220 2221 basenames = event_get_supported_methods(); 2222 for (i = 0; basenames[i]; ++i) { 2223 methodname_to_envvar(basenames[i], varbuf, sizeof(varbuf)); 2224 unsetenv(varbuf); 2225 ++n_methods; 2226 } 2227 2228 base = event_base_new(); 2229 tt_assert(base); 2230 2231 defaultname = event_base_get_method(base); 2232 TT_BLATHER(("default is <%s>", defaultname)); 2233 event_base_free(base); 2234 base = NULL; 2235 2236 /* Can we disable the method with EVENT_NOfoo ? */ 2237 if (!strcmp(defaultname, "epoll (with changelist)")) { 2238 setenv("EVENT_NOEPOLL", "1", 1); 2239 ignoreenvname = "epoll"; 2240 } else { 2241 methodname_to_envvar(defaultname, varbuf, sizeof(varbuf)); 2242 setenv(varbuf, "1", 1); 2243 ignoreenvname = defaultname; 2244 } 2245 2246 /* Use an empty cfg rather than NULL so a failure doesn't exit() */ 2247 cfg = event_config_new(); 2248 base = event_base_new_with_config(cfg); 2249 event_config_free(cfg); 2250 cfg = NULL; 2251 if (n_methods == 1) { 2252 tt_assert(!base); 2253 } else { 2254 tt_assert(base); 2255 tt_str_op(defaultname, !=, event_base_get_method(base)); 2256 event_base_free(base); 2257 base = NULL; 2258 } 2259 2260 /* Can we disable looking at the environment with IGNORE_ENV ? */ 2261 cfg = event_config_new(); 2262 event_config_set_flag(cfg, EVENT_BASE_FLAG_IGNORE_ENV); 2263 base = event_base_new_with_config(cfg); 2264 tt_assert(base); 2265 tt_str_op(ignoreenvname, ==, event_base_get_method(base)); 2266 #else 2267 tt_skip(); 2268 #endif 2269 2270 end: 2271 if (base) 2272 event_base_free(base); 2273 if (cfg) 2274 event_config_free(cfg); 2275 } 2276 2277 static void 2278 read_called_once_cb(evutil_socket_t fd, short event, void *arg) 2279 { 2280 tt_int_op(event, ==, EV_READ); 2281 called += 1; 2282 end: 2283 ; 2284 } 2285 2286 static void 2287 timeout_called_once_cb(evutil_socket_t fd, short event, void *arg) 2288 { 2289 tt_int_op(event, ==, EV_TIMEOUT); 2290 called += 100; 2291 end: 2292 ; 2293 } 2294 2295 static void 2296 immediate_called_twice_cb(evutil_socket_t fd, short event, void *arg) 2297 { 2298 tt_int_op(event, ==, EV_TIMEOUT); 2299 called += 1000; 2300 end: 2301 ; 2302 } 2303 2304 static void 2305 test_event_once(void *ptr) 2306 { 2307 struct basic_test_data *data = ptr; 2308 struct timeval tv; 2309 int r; 2310 2311 tv.tv_sec = 0; 2312 tv.tv_usec = 50*1000; 2313 called = 0; 2314 r = event_base_once(data->base, data->pair[0], EV_READ, 2315 read_called_once_cb, NULL, NULL); 2316 tt_int_op(r, ==, 0); 2317 r = event_base_once(data->base, -1, EV_TIMEOUT, 2318 timeout_called_once_cb, NULL, &tv); 2319 tt_int_op(r, ==, 0); 2320 r = event_base_once(data->base, -1, 0, NULL, NULL, NULL); 2321 tt_int_op(r, <, 0); 2322 r = event_base_once(data->base, -1, EV_TIMEOUT, 2323 immediate_called_twice_cb, NULL, NULL); 2324 tt_int_op(r, ==, 0); 2325 tv.tv_sec = 0; 2326 tv.tv_usec = 0; 2327 r = event_base_once(data->base, -1, EV_TIMEOUT, 2328 immediate_called_twice_cb, NULL, &tv); 2329 tt_int_op(r, ==, 0); 2330 2331 if (write(data->pair[1], TEST1, strlen(TEST1)+1) < 0) { 2332 tt_fail_perror("write"); 2333 } 2334 2335 shutdown(data->pair[1], SHUT_WR); 2336 2337 event_base_dispatch(data->base); 2338 2339 tt_int_op(called, ==, 2101); 2340 end: 2341 ; 2342 } 2343 2344 static void 2345 test_event_once_never(void *ptr) 2346 { 2347 struct basic_test_data *data = ptr; 2348 struct timeval tv; 2349 2350 /* Have one trigger in 10 seconds (don't worry, because) */ 2351 tv.tv_sec = 10; 2352 tv.tv_usec = 0; 2353 called = 0; 2354 event_base_once(data->base, -1, EV_TIMEOUT, 2355 timeout_called_once_cb, NULL, &tv); 2356 2357 /* But shut down the base in 75 msec. */ 2358 tv.tv_sec = 0; 2359 tv.tv_usec = 75*1000; 2360 event_base_loopexit(data->base, &tv); 2361 2362 event_base_dispatch(data->base); 2363 2364 tt_int_op(called, ==, 0); 2365 end: 2366 ; 2367 } 2368 2369 static void 2370 test_event_pending(void *ptr) 2371 { 2372 struct basic_test_data *data = ptr; 2373 struct event *r=NULL, *w=NULL, *t=NULL; 2374 struct timeval tv, now, tv2; 2375 2376 tv.tv_sec = 0; 2377 tv.tv_usec = 500 * 1000; 2378 r = event_new(data->base, data->pair[0], EV_READ, simple_read_cb, 2379 NULL); 2380 w = event_new(data->base, data->pair[1], EV_WRITE, simple_write_cb, 2381 NULL); 2382 t = evtimer_new(data->base, timeout_cb, NULL); 2383 2384 tt_assert(r); 2385 tt_assert(w); 2386 tt_assert(t); 2387 2388 evutil_gettimeofday(&now, NULL); 2389 event_add(r, NULL); 2390 event_add(t, &tv); 2391 2392 tt_assert( event_pending(r, EV_READ, NULL)); 2393 tt_assert(!event_pending(w, EV_WRITE, NULL)); 2394 tt_assert(!event_pending(r, EV_WRITE, NULL)); 2395 tt_assert( event_pending(r, EV_READ|EV_WRITE, NULL)); 2396 tt_assert(!event_pending(r, EV_TIMEOUT, NULL)); 2397 tt_assert( event_pending(t, EV_TIMEOUT, NULL)); 2398 tt_assert( event_pending(t, EV_TIMEOUT, &tv2)); 2399 2400 tt_assert(evutil_timercmp(&tv2, &now, >)); 2401 2402 test_timeval_diff_eq(&now, &tv2, 500); 2403 2404 end: 2405 if (r) { 2406 event_del(r); 2407 event_free(r); 2408 } 2409 if (w) { 2410 event_del(w); 2411 event_free(w); 2412 } 2413 if (t) { 2414 event_del(t); 2415 event_free(t); 2416 } 2417 } 2418 2419 #ifndef _WIN32 2420 /* You can't do this test on windows, since dup2 doesn't work on sockets */ 2421 2422 static void 2423 dfd_cb(evutil_socket_t fd, short e, void *data) 2424 { 2425 *(int*)data = (int)e; 2426 } 2427 2428 /* Regression test for our workaround for a fun epoll/linux related bug 2429 * where fd2 = dup(fd1); add(fd2); close(fd2); dup2(fd1,fd2); add(fd2) 2430 * will get you an EEXIST */ 2431 static void 2432 test_dup_fd(void *arg) 2433 { 2434 struct basic_test_data *data = arg; 2435 struct event_base *base = data->base; 2436 struct event *ev1=NULL, *ev2=NULL; 2437 int fd, dfd=-1; 2438 int ev1_got, ev2_got; 2439 2440 tt_int_op(write(data->pair[0], "Hello world", 2441 strlen("Hello world")), >, 0); 2442 fd = data->pair[1]; 2443 2444 dfd = dup(fd); 2445 tt_int_op(dfd, >=, 0); 2446 2447 ev1 = event_new(base, fd, EV_READ|EV_PERSIST, dfd_cb, &ev1_got); 2448 ev2 = event_new(base, dfd, EV_READ|EV_PERSIST, dfd_cb, &ev2_got); 2449 ev1_got = ev2_got = 0; 2450 event_add(ev1, NULL); 2451 event_add(ev2, NULL); 2452 event_base_loop(base, EVLOOP_ONCE); 2453 tt_int_op(ev1_got, ==, EV_READ); 2454 tt_int_op(ev2_got, ==, EV_READ); 2455 2456 /* Now close and delete dfd then dispatch. We need to do the 2457 * dispatch here so that when we add it later, we think there 2458 * was an intermediate delete. */ 2459 close(dfd); 2460 event_del(ev2); 2461 ev1_got = ev2_got = 0; 2462 event_base_loop(base, EVLOOP_ONCE); 2463 tt_want_int_op(ev1_got, ==, EV_READ); 2464 tt_int_op(ev2_got, ==, 0); 2465 2466 /* Re-duplicate the fd. We need to get the same duplicated 2467 * value that we closed to provoke the epoll quirk. Also, we 2468 * need to change the events to write, or else the old lingering 2469 * read event will make the test pass whether the change was 2470 * successful or not. */ 2471 tt_int_op(dup2(fd, dfd), ==, dfd); 2472 event_free(ev2); 2473 ev2 = event_new(base, dfd, EV_WRITE|EV_PERSIST, dfd_cb, &ev2_got); 2474 event_add(ev2, NULL); 2475 ev1_got = ev2_got = 0; 2476 event_base_loop(base, EVLOOP_ONCE); 2477 tt_want_int_op(ev1_got, ==, EV_READ); 2478 tt_int_op(ev2_got, ==, EV_WRITE); 2479 2480 end: 2481 if (ev1) 2482 event_free(ev1); 2483 if (ev2) 2484 event_free(ev2); 2485 if (dfd >= 0) 2486 close(dfd); 2487 } 2488 #endif 2489 2490 #ifdef EVENT__DISABLE_MM_REPLACEMENT 2491 static void 2492 test_mm_functions(void *arg) 2493 { 2494 tinytest_set_test_skipped_(); 2495 } 2496 #else 2497 static int 2498 check_dummy_mem_ok(void *mem_) 2499 { 2500 char *mem = mem_; 2501 mem -= 16; 2502 return !memcmp(mem, "{[<guardedram>]}", 16); 2503 } 2504 2505 static void * 2506 dummy_malloc(size_t len) 2507 { 2508 char *mem = malloc(len+16); 2509 memcpy(mem, "{[<guardedram>]}", 16); 2510 return mem+16; 2511 } 2512 2513 static void * 2514 dummy_realloc(void *mem_, size_t len) 2515 { 2516 char *mem = mem_; 2517 if (!mem) 2518 return dummy_malloc(len); 2519 tt_want(check_dummy_mem_ok(mem_)); 2520 mem -= 16; 2521 mem = realloc(mem, len+16); 2522 return mem+16; 2523 } 2524 2525 static void 2526 dummy_free(void *mem_) 2527 { 2528 char *mem = mem_; 2529 tt_want(check_dummy_mem_ok(mem_)); 2530 mem -= 16; 2531 free(mem); 2532 } 2533 2534 static void 2535 test_mm_functions(void *arg) 2536 { 2537 struct event_base *b = NULL; 2538 struct event_config *cfg = NULL; 2539 event_set_mem_functions(dummy_malloc, dummy_realloc, dummy_free); 2540 cfg = event_config_new(); 2541 event_config_avoid_method(cfg, "Nonesuch"); 2542 b = event_base_new_with_config(cfg); 2543 tt_assert(b); 2544 tt_assert(check_dummy_mem_ok(b)); 2545 end: 2546 if (cfg) 2547 event_config_free(cfg); 2548 if (b) 2549 event_base_free(b); 2550 } 2551 #endif 2552 2553 static void 2554 many_event_cb(evutil_socket_t fd, short event, void *arg) 2555 { 2556 int *calledp = arg; 2557 *calledp += 1; 2558 } 2559 2560 static void 2561 test_many_events(void *arg) 2562 { 2563 /* Try 70 events that should all be ready at once. This will 2564 * exercise the "resize" code on most of the backends, and will make 2565 * sure that we can get past the 64-handle limit of some windows 2566 * functions. */ 2567 #define MANY 70 2568 2569 struct basic_test_data *data = arg; 2570 struct event_base *base = data->base; 2571 int one_at_a_time = data->setup_data != NULL; 2572 evutil_socket_t sock[MANY]; 2573 struct event *ev[MANY]; 2574 int called[MANY]; 2575 int i; 2576 int loopflags = EVLOOP_NONBLOCK, evflags=0; 2577 if (one_at_a_time) { 2578 loopflags |= EVLOOP_ONCE; 2579 evflags = EV_PERSIST; 2580 } 2581 2582 memset(sock, 0xff, sizeof(sock)); 2583 memset(ev, 0, sizeof(ev)); 2584 memset(called, 0, sizeof(called)); 2585 2586 for (i = 0; i < MANY; ++i) { 2587 /* We need an event that will hit the backend, and that will 2588 * be ready immediately. "Send a datagram" is an easy 2589 * instance of that. */ 2590 sock[i] = socket(AF_INET, SOCK_DGRAM, 0); 2591 tt_assert(sock[i] >= 0); 2592 called[i] = 0; 2593 ev[i] = event_new(base, sock[i], EV_WRITE|evflags, 2594 many_event_cb, &called[i]); 2595 event_add(ev[i], NULL); 2596 if (one_at_a_time) 2597 event_base_loop(base, EVLOOP_NONBLOCK|EVLOOP_ONCE); 2598 } 2599 2600 event_base_loop(base, loopflags); 2601 2602 for (i = 0; i < MANY; ++i) { 2603 if (one_at_a_time) 2604 tt_int_op(called[i], ==, MANY - i + 1); 2605 else 2606 tt_int_op(called[i], ==, 1); 2607 } 2608 2609 end: 2610 for (i = 0; i < MANY; ++i) { 2611 if (ev[i]) 2612 event_free(ev[i]); 2613 if (sock[i] >= 0) 2614 evutil_closesocket(sock[i]); 2615 } 2616 #undef MANY 2617 } 2618 2619 static void 2620 test_struct_event_size(void *arg) 2621 { 2622 tt_int_op(event_get_struct_event_size(), <=, sizeof(struct event)); 2623 end: 2624 ; 2625 } 2626 2627 struct testcase_t main_testcases[] = { 2628 /* Some converted-over tests */ 2629 { "methods", test_methods, TT_FORK, NULL, NULL }, 2630 { "version", test_version, 0, NULL, NULL }, 2631 BASIC(base_features, TT_FORK|TT_NO_LOGS), 2632 { "base_environ", test_base_environ, TT_FORK, NULL, NULL }, 2633 2634 BASIC(event_base_new, TT_FORK|TT_NEED_SOCKETPAIR), 2635 BASIC(free_active_base, TT_FORK|TT_NEED_SOCKETPAIR), 2636 2637 BASIC(manipulate_active_events, TT_FORK|TT_NEED_BASE), 2638 BASIC(event_new_selfarg, TT_FORK|TT_NEED_BASE), 2639 BASIC(event_assign_selfarg, TT_FORK|TT_NEED_BASE), 2640 2641 BASIC(bad_assign, TT_FORK|TT_NEED_BASE|TT_NO_LOGS), 2642 BASIC(bad_reentrant, TT_FORK|TT_NEED_BASE|TT_NO_LOGS), 2643 BASIC(active_later, TT_FORK|TT_NEED_BASE|TT_NEED_SOCKETPAIR), 2644 BASIC(event_remove_timeout, TT_FORK|TT_NEED_BASE|TT_NEED_SOCKETPAIR), 2645 2646 /* These are still using the old API */ 2647 LEGACY(persistent_timeout, TT_FORK|TT_NEED_BASE), 2648 { "persistent_timeout_jump", test_persistent_timeout_jump, TT_FORK|TT_NEED_BASE, &basic_setup, NULL }, 2649 { "persistent_active_timeout", test_persistent_active_timeout, 2650 TT_FORK|TT_NEED_BASE, &basic_setup, NULL }, 2651 LEGACY(priorities, TT_FORK|TT_NEED_BASE), 2652 BASIC(priority_active_inversion, TT_FORK|TT_NEED_BASE), 2653 { "common_timeout", test_common_timeout, TT_FORK|TT_NEED_BASE, 2654 &basic_setup, NULL }, 2655 2656 /* These legacy tests may not all need all of these flags. */ 2657 LEGACY(simpleread, TT_ISOLATED), 2658 LEGACY(simpleread_multiple, TT_ISOLATED), 2659 LEGACY(simplewrite, TT_ISOLATED), 2660 { "simpleclose", test_simpleclose, TT_FORK, &basic_setup, 2661 NULL }, 2662 LEGACY(multiple, TT_ISOLATED), 2663 LEGACY(persistent, TT_ISOLATED), 2664 LEGACY(combined, TT_ISOLATED), 2665 LEGACY(simpletimeout, TT_ISOLATED), 2666 LEGACY(loopbreak, TT_ISOLATED), 2667 LEGACY(loopexit, TT_ISOLATED), 2668 LEGACY(loopexit_multiple, TT_ISOLATED), 2669 LEGACY(nonpersist_readd, TT_ISOLATED), 2670 LEGACY(multiple_events_for_same_fd, TT_ISOLATED), 2671 LEGACY(want_only_once, TT_ISOLATED), 2672 { "event_once", test_event_once, TT_ISOLATED, &basic_setup, NULL }, 2673 { "event_once_never", test_event_once_never, TT_ISOLATED, &basic_setup, NULL }, 2674 { "event_pending", test_event_pending, TT_ISOLATED, &basic_setup, 2675 NULL }, 2676 #ifndef _WIN32 2677 { "dup_fd", test_dup_fd, TT_ISOLATED, &basic_setup, NULL }, 2678 #endif 2679 { "mm_functions", test_mm_functions, TT_FORK, NULL, NULL }, 2680 { "many_events", test_many_events, TT_ISOLATED, &basic_setup, NULL }, 2681 { "many_events_slow_add", test_many_events, TT_ISOLATED, &basic_setup, (void*)1 }, 2682 2683 { "struct_event_size", test_struct_event_size, 0, NULL, NULL }, 2684 2685 #ifndef _WIN32 2686 LEGACY(fork, TT_ISOLATED), 2687 #endif 2688 END_OF_TESTCASES 2689 }; 2690 2691 struct testcase_t evtag_testcases[] = { 2692 { "int", evtag_int_test, TT_FORK, NULL, NULL }, 2693 { "fuzz", evtag_fuzz, TT_FORK, NULL, NULL }, 2694 { "encoding", evtag_tag_encoding, TT_FORK, NULL, NULL }, 2695 { "peek", evtag_test_peek, 0, NULL, NULL }, 2696 2697 END_OF_TESTCASES 2698 }; 2699 2700 struct testcase_t signal_testcases[] = { 2701 #ifndef _WIN32 2702 LEGACY(simplesignal, TT_ISOLATED), 2703 LEGACY(multiplesignal, TT_ISOLATED), 2704 LEGACY(immediatesignal, TT_ISOLATED), 2705 LEGACY(signal_dealloc, TT_ISOLATED), 2706 LEGACY(signal_pipeloss, TT_ISOLATED), 2707 LEGACY(signal_switchbase, TT_ISOLATED|TT_NO_LOGS), 2708 LEGACY(signal_restore, TT_ISOLATED), 2709 LEGACY(signal_assert, TT_ISOLATED), 2710 LEGACY(signal_while_processing, TT_ISOLATED), 2711 #endif 2712 END_OF_TESTCASES 2713 }; 2714 2715