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