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