1 /* $NetBSD: regress_util.c,v 1.3 2017/01/31 23:17:40 christos Exp $ */ 2 /* 3 * Copyright (c) 2009-2012 Nick Mathewson and Niels Provos 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 #include <ws2tcpip.h> 33 #endif 34 35 #include "event2/event-config.h" 36 #include <sys/cdefs.h> 37 __RCSID("$NetBSD: regress_util.c,v 1.3 2017/01/31 23:17:40 christos Exp $"); 38 39 #include <sys/types.h> 40 41 #ifndef _WIN32 42 #include <sys/socket.h> 43 #include <netinet/in.h> 44 #include <arpa/inet.h> 45 #include <unistd.h> 46 #endif 47 #ifdef EVENT__HAVE_NETINET_IN6_H 48 #include <netinet/in6.h> 49 #endif 50 #ifdef EVENT__HAVE_SYS_WAIT_H 51 #include <sys/wait.h> 52 #endif 53 #include <signal.h> 54 #include <stdio.h> 55 #include <stdlib.h> 56 #include <string.h> 57 #include <limits.h> 58 59 #include "event2/event.h" 60 #include "event2/util.h" 61 #include "../ipv6-internal.h" 62 #include "../log-internal.h" 63 #include "../strlcpy-internal.h" 64 #include "../mm-internal.h" 65 #include "../time-internal.h" 66 67 #include "regress.h" 68 69 enum entry_status { NORMAL, CANONICAL, BAD }; 70 71 /* This is a big table of results we expect from generating and parsing */ 72 static struct ipv4_entry { 73 const char *addr; 74 ev_uint32_t res; 75 enum entry_status status; 76 } ipv4_entries[] = { 77 { "1.2.3.4", 0x01020304u, CANONICAL }, 78 { "255.255.255.255", 0xffffffffu, CANONICAL }, 79 { "256.0.0.0", 0, BAD }, 80 { "ABC", 0, BAD }, 81 { "1.2.3.4.5", 0, BAD }, 82 { "176.192.208.244", 0xb0c0d0f4, CANONICAL }, 83 { NULL, 0, BAD }, 84 }; 85 86 static struct ipv6_entry { 87 const char *addr; 88 ev_uint32_t res[4]; 89 enum entry_status status; 90 } ipv6_entries[] = { 91 { "::", { 0, 0, 0, 0, }, CANONICAL }, 92 { "0:0:0:0:0:0:0:0", { 0, 0, 0, 0, }, NORMAL }, 93 { "::1", { 0, 0, 0, 1, }, CANONICAL }, 94 { "::1.2.3.4", { 0, 0, 0, 0x01020304, }, CANONICAL }, 95 { "ffff:1::", { 0xffff0001u, 0, 0, 0, }, CANONICAL }, 96 { "ffff:0000::", { 0xffff0000u, 0, 0, 0, }, NORMAL }, 97 { "ffff::1234", { 0xffff0000u, 0, 0, 0x1234, }, CANONICAL }, 98 { "0102::1.2.3.4", {0x01020000u, 0, 0, 0x01020304u }, NORMAL }, 99 { "::9:c0a8:1:1", { 0, 0, 0x0009c0a8u, 0x00010001u }, CANONICAL }, 100 { "::ffff:1.2.3.4", { 0, 0, 0x000ffffu, 0x01020304u }, CANONICAL }, 101 { "FFFF::", { 0xffff0000u, 0, 0, 0 }, NORMAL }, 102 { "foobar.", { 0, 0, 0, 0 }, BAD }, 103 { "foobar", { 0, 0, 0, 0 }, BAD }, 104 { "fo:obar", { 0, 0, 0, 0 }, BAD }, 105 { "ffff", { 0, 0, 0, 0 }, BAD }, 106 { "fffff::", { 0, 0, 0, 0 }, BAD }, 107 { "fffff::", { 0, 0, 0, 0 }, BAD }, 108 { "::1.0.1.1000", { 0, 0, 0, 0 }, BAD }, 109 { "1:2:33333:4::", { 0, 0, 0, 0 }, BAD }, 110 { "1:2:3:4:5:6:7:8:9", { 0, 0, 0, 0 }, BAD }, 111 { "1::2::3", { 0, 0, 0, 0 }, BAD }, 112 { ":::1", { 0, 0, 0, 0 }, BAD }, 113 { NULL, { 0, 0, 0, 0, }, BAD }, 114 }; 115 116 static void 117 regress_ipv4_parse(void *ptr) 118 { 119 int i; 120 for (i = 0; ipv4_entries[i].addr; ++i) { 121 char written[128]; 122 struct ipv4_entry *ent = &ipv4_entries[i]; 123 struct in_addr in; 124 int r; 125 r = evutil_inet_pton(AF_INET, ent->addr, &in); 126 if (r == 0) { 127 if (ent->status != BAD) { 128 TT_FAIL(("%s did not parse, but it's a good address!", 129 ent->addr)); 130 } 131 continue; 132 } 133 if (ent->status == BAD) { 134 TT_FAIL(("%s parsed, but we expected an error", ent->addr)); 135 continue; 136 } 137 if (ntohl(in.s_addr) != ent->res) { 138 TT_FAIL(("%s parsed to %lx, but we expected %lx", ent->addr, 139 (unsigned long)ntohl(in.s_addr), 140 (unsigned long)ent->res)); 141 continue; 142 } 143 if (ent->status == CANONICAL) { 144 const char *w = evutil_inet_ntop(AF_INET, &in, written, 145 sizeof(written)); 146 if (!w) { 147 TT_FAIL(("Tried to write out %s; got NULL.", ent->addr)); 148 continue; 149 } 150 if (strcmp(written, ent->addr)) { 151 TT_FAIL(("Tried to write out %s; got %s", 152 ent->addr, written)); 153 continue; 154 } 155 } 156 157 } 158 159 } 160 161 static void 162 regress_ipv6_parse(void *ptr) 163 { 164 #ifdef AF_INET6 165 int i, j; 166 167 for (i = 0; ipv6_entries[i].addr; ++i) { 168 char written[128]; 169 struct ipv6_entry *ent = &ipv6_entries[i]; 170 struct in6_addr in6; 171 int r; 172 r = evutil_inet_pton(AF_INET6, ent->addr, &in6); 173 if (r == 0) { 174 if (ent->status != BAD) 175 TT_FAIL(("%s did not parse, but it's a good address!", 176 ent->addr)); 177 continue; 178 } 179 if (ent->status == BAD) { 180 TT_FAIL(("%s parsed, but we expected an error", ent->addr)); 181 continue; 182 } 183 for (j = 0; j < 4; ++j) { 184 /* Can't use s6_addr32 here; some don't have it. */ 185 ev_uint32_t u = 186 ((ev_uint32_t)in6.s6_addr[j*4 ] << 24) | 187 ((ev_uint32_t)in6.s6_addr[j*4+1] << 16) | 188 ((ev_uint32_t)in6.s6_addr[j*4+2] << 8) | 189 ((ev_uint32_t)in6.s6_addr[j*4+3]); 190 if (u != ent->res[j]) { 191 TT_FAIL(("%s did not parse as expected.", ent->addr)); 192 continue; 193 } 194 } 195 if (ent->status == CANONICAL) { 196 const char *w = evutil_inet_ntop(AF_INET6, &in6, written, 197 sizeof(written)); 198 if (!w) { 199 TT_FAIL(("Tried to write out %s; got NULL.", ent->addr)); 200 continue; 201 } 202 if (strcmp(written, ent->addr)) { 203 TT_FAIL(("Tried to write out %s; got %s", ent->addr, written)); 204 continue; 205 } 206 } 207 208 } 209 #else 210 TT_BLATHER(("Skipping IPv6 address parsing.")); 211 #endif 212 } 213 214 static struct sa_port_ent { 215 const char *parse; 216 int safamily; 217 const char *addr; 218 int port; 219 } sa_port_ents[] = { 220 { "[ffff::1]:1000", AF_INET6, "ffff::1", 1000 }, 221 { "[ffff::1]", AF_INET6, "ffff::1", 0 }, 222 { "[ffff::1", 0, NULL, 0 }, 223 { "[ffff::1]:65599", 0, NULL, 0 }, 224 { "[ffff::1]:0", 0, NULL, 0 }, 225 { "[ffff::1]:-1", 0, NULL, 0 }, 226 { "::1", AF_INET6, "::1", 0 }, 227 { "1:2::1", AF_INET6, "1:2::1", 0 }, 228 { "192.168.0.1:50", AF_INET, "192.168.0.1", 50 }, 229 { "1.2.3.4", AF_INET, "1.2.3.4", 0 }, 230 { NULL, 0, NULL, 0 }, 231 }; 232 233 static void 234 regress_sockaddr_port_parse(void *ptr) 235 { 236 struct sockaddr_storage ss; 237 int i, r; 238 239 for (i = 0; sa_port_ents[i].parse; ++i) { 240 struct sa_port_ent *ent = &sa_port_ents[i]; 241 int len = sizeof(ss); 242 memset(&ss, 0, sizeof(ss)); 243 r = evutil_parse_sockaddr_port(ent->parse, (struct sockaddr*)&ss, &len); 244 if (r < 0) { 245 if (ent->safamily) 246 TT_FAIL(("Couldn't parse %s!", ent->parse)); 247 continue; 248 } else if (! ent->safamily) { 249 TT_FAIL(("Shouldn't have been able to parse %s!", ent->parse)); 250 continue; 251 } 252 if (ent->safamily == AF_INET) { 253 struct sockaddr_in sin; 254 memset(&sin, 0, sizeof(sin)); 255 #ifdef EVENT__HAVE_STRUCT_SOCKADDR_IN_SIN_LEN 256 sin.sin_len = sizeof(sin); 257 #endif 258 sin.sin_family = AF_INET; 259 sin.sin_port = htons(ent->port); 260 r = evutil_inet_pton(AF_INET, ent->addr, &sin.sin_addr); 261 if (1 != r) { 262 TT_FAIL(("Couldn't parse ipv4 target %s.", ent->addr)); 263 } else if (memcmp(&sin, &ss, sizeof(sin))) { 264 TT_FAIL(("Parse for %s was not as expected.", ent->parse)); 265 } else if (len != sizeof(sin)) { 266 TT_FAIL(("Length for %s not as expected.",ent->parse)); 267 } 268 } else { 269 struct sockaddr_in6 sin6; 270 memset(&sin6, 0, sizeof(sin6)); 271 #ifdef EVENT__HAVE_STRUCT_SOCKADDR_IN6_SIN6_LEN 272 sin6.sin6_len = sizeof(sin6); 273 #endif 274 sin6.sin6_family = AF_INET6; 275 sin6.sin6_port = htons(ent->port); 276 r = evutil_inet_pton(AF_INET6, ent->addr, &sin6.sin6_addr); 277 if (1 != r) { 278 TT_FAIL(("Couldn't parse ipv6 target %s.", ent->addr)); 279 } else if (memcmp(&sin6, &ss, sizeof(sin6))) { 280 TT_FAIL(("Parse for %s was not as expected.", ent->parse)); 281 } else if (len != sizeof(sin6)) { 282 TT_FAIL(("Length for %s not as expected.",ent->parse)); 283 } 284 } 285 } 286 } 287 288 289 static void 290 regress_sockaddr_port_format(void *ptr) 291 { 292 struct sockaddr_storage ss; 293 int len; 294 const char *cp; 295 char cbuf[128]; 296 int r; 297 298 len = sizeof(ss); 299 r = evutil_parse_sockaddr_port("192.168.1.1:80", 300 (struct sockaddr*)&ss, &len); 301 tt_int_op(r,==,0); 302 cp = evutil_format_sockaddr_port_( 303 (struct sockaddr*)&ss, cbuf, sizeof(cbuf)); 304 tt_ptr_op(cp,==,cbuf); 305 tt_str_op(cp,==,"192.168.1.1:80"); 306 307 len = sizeof(ss); 308 r = evutil_parse_sockaddr_port("[ff00::8010]:999", 309 (struct sockaddr*)&ss, &len); 310 tt_int_op(r,==,0); 311 cp = evutil_format_sockaddr_port_( 312 (struct sockaddr*)&ss, cbuf, sizeof(cbuf)); 313 tt_ptr_op(cp,==,cbuf); 314 tt_str_op(cp,==,"[ff00::8010]:999"); 315 316 ss.ss_family=99; 317 cp = evutil_format_sockaddr_port_( 318 (struct sockaddr*)&ss, cbuf, sizeof(cbuf)); 319 tt_ptr_op(cp,==,cbuf); 320 tt_str_op(cp,==,"<addr with socktype 99>"); 321 end: 322 ; 323 } 324 325 static struct sa_pred_ent { 326 const char *parse; 327 328 int is_loopback; 329 } sa_pred_entries[] = { 330 { "127.0.0.1", 1 }, 331 { "127.0.3.2", 1 }, 332 { "128.1.2.3", 0 }, 333 { "18.0.0.1", 0 }, 334 { "129.168.1.1", 0 }, 335 336 { "::1", 1 }, 337 { "::0", 0 }, 338 { "f::1", 0 }, 339 { "::501", 0 }, 340 { NULL, 0 }, 341 342 }; 343 344 static void 345 test_evutil_sockaddr_predicates(void *ptr) 346 { 347 struct sockaddr_storage ss; 348 int r, i; 349 350 for (i=0; sa_pred_entries[i].parse; ++i) { 351 struct sa_pred_ent *ent = &sa_pred_entries[i]; 352 int len = sizeof(ss); 353 354 r = evutil_parse_sockaddr_port(ent->parse, (struct sockaddr*)&ss, &len); 355 356 if (r<0) { 357 TT_FAIL(("Couldn't parse %s!", ent->parse)); 358 continue; 359 } 360 361 /* sockaddr_is_loopback */ 362 if (ent->is_loopback != evutil_sockaddr_is_loopback_((struct sockaddr*)&ss)) { 363 TT_FAIL(("evutil_sockaddr_loopback(%s) not as expected", 364 ent->parse)); 365 } 366 } 367 } 368 369 static void 370 test_evutil_strtoll(void *ptr) 371 { 372 const char *s; 373 char *endptr; 374 375 tt_want(evutil_strtoll("5000000000", NULL, 10) == 376 ((ev_int64_t)5000000)*1000); 377 tt_want(evutil_strtoll("-5000000000", NULL, 10) == 378 ((ev_int64_t)5000000)*-1000); 379 s = " 99999stuff"; 380 tt_want(evutil_strtoll(s, &endptr, 10) == (ev_int64_t)99999); 381 tt_want(endptr == s+6); 382 tt_want(evutil_strtoll("foo", NULL, 10) == 0); 383 } 384 385 static void 386 test_evutil_snprintf(void *ptr) 387 { 388 char buf[16]; 389 int r; 390 ev_uint64_t u64 = ((ev_uint64_t)1000000000)*200; 391 ev_int64_t i64 = -1 * (ev_int64_t) u64; 392 size_t size = 8000; 393 ev_ssize_t ssize = -9000; 394 395 r = evutil_snprintf(buf, sizeof(buf), "%d %d", 50, 100); 396 tt_str_op(buf, ==, "50 100"); 397 tt_int_op(r, ==, 6); 398 399 r = evutil_snprintf(buf, sizeof(buf), "longish %d", 1234567890); 400 tt_str_op(buf, ==, "longish 1234567"); 401 tt_int_op(r, ==, 18); 402 403 r = evutil_snprintf(buf, sizeof(buf), EV_U64_FMT, EV_U64_ARG(u64)); 404 tt_str_op(buf, ==, "200000000000"); 405 tt_int_op(r, ==, 12); 406 407 r = evutil_snprintf(buf, sizeof(buf), EV_I64_FMT, EV_I64_ARG(i64)); 408 tt_str_op(buf, ==, "-200000000000"); 409 tt_int_op(r, ==, 13); 410 411 r = evutil_snprintf(buf, sizeof(buf), EV_SIZE_FMT" "EV_SSIZE_FMT, 412 EV_SIZE_ARG(size), EV_SSIZE_ARG(ssize)); 413 tt_str_op(buf, ==, "8000 -9000"); 414 tt_int_op(r, ==, 10); 415 416 end: 417 ; 418 } 419 420 static void 421 test_evutil_casecmp(void *ptr) 422 { 423 tt_int_op(evutil_ascii_strcasecmp("ABC", "ABC"), ==, 0); 424 tt_int_op(evutil_ascii_strcasecmp("ABC", "abc"), ==, 0); 425 tt_int_op(evutil_ascii_strcasecmp("ABC", "abcd"), <, 0); 426 tt_int_op(evutil_ascii_strcasecmp("ABC", "abb"), >, 0); 427 tt_int_op(evutil_ascii_strcasecmp("ABCd", "abc"), >, 0); 428 429 tt_int_op(evutil_ascii_strncasecmp("Libevent", "LibEvEnT", 100), ==, 0); 430 tt_int_op(evutil_ascii_strncasecmp("Libevent", "LibEvEnT", 4), ==, 0); 431 tt_int_op(evutil_ascii_strncasecmp("Libevent", "LibEXXXX", 4), ==, 0); 432 tt_int_op(evutil_ascii_strncasecmp("Libevent", "LibE", 4), ==, 0); 433 tt_int_op(evutil_ascii_strncasecmp("Libe", "LibEvEnT", 4), ==, 0); 434 tt_int_op(evutil_ascii_strncasecmp("Lib", "LibEvEnT", 4), <, 0); 435 tt_int_op(evutil_ascii_strncasecmp("abc", "def", 99), <, 0); 436 tt_int_op(evutil_ascii_strncasecmp("Z", "qrst", 1), >, 0); 437 end: 438 ; 439 } 440 441 static void 442 test_evutil_rtrim(void *ptr) 443 { 444 #define TEST_TRIM(s, result) \ 445 do { \ 446 if (cp) mm_free(cp); \ 447 cp = mm_strdup(s); \ 448 tt_assert(cp); \ 449 evutil_rtrim_lws_(cp); \ 450 tt_str_op(cp, ==, result); \ 451 } while(0) 452 453 char *cp = NULL; 454 (void) ptr; 455 456 TEST_TRIM("", ""); 457 TEST_TRIM("a", "a"); 458 TEST_TRIM("abcdef ghi", "abcdef ghi"); 459 460 TEST_TRIM(" ", ""); 461 TEST_TRIM(" ", ""); 462 TEST_TRIM("a ", "a"); 463 TEST_TRIM("abcdef gH ", "abcdef gH"); 464 465 TEST_TRIM("\t\t", ""); 466 TEST_TRIM(" \t", ""); 467 TEST_TRIM("\t", ""); 468 TEST_TRIM("a \t", "a"); 469 TEST_TRIM("a\t ", "a"); 470 TEST_TRIM("a\t", "a"); 471 TEST_TRIM("abcdef gH \t ", "abcdef gH"); 472 473 end: 474 if (cp) 475 mm_free(cp); 476 } 477 478 static int logsev = 0; 479 static char *logmsg = NULL; 480 481 static void 482 logfn(int severity, const char *msg) 483 { 484 logsev = severity; 485 tt_want(msg); 486 if (msg) { 487 if (logmsg) 488 free(logmsg); 489 logmsg = strdup(msg); 490 } 491 } 492 493 static int fatal_want_severity = 0; 494 static const char *fatal_want_message = NULL; 495 static void 496 fatalfn(int exitcode) 497 { 498 if (logsev != fatal_want_severity || 499 !logmsg || 500 strcmp(logmsg, fatal_want_message)) 501 exit(0); 502 else 503 exit(exitcode); 504 } 505 506 #ifndef _WIN32 507 #define CAN_CHECK_ERR 508 static void 509 check_error_logging(void (*fn)(void), int wantexitcode, 510 int wantseverity, const char *wantmsg) 511 { 512 pid_t pid; 513 int status = 0, exitcode; 514 fatal_want_severity = wantseverity; 515 fatal_want_message = wantmsg; 516 if ((pid = regress_fork()) == 0) { 517 /* child process */ 518 fn(); 519 exit(0); /* should be unreachable. */ 520 } else { 521 wait(&status); 522 exitcode = WEXITSTATUS(status); 523 tt_int_op(wantexitcode, ==, exitcode); 524 } 525 end: 526 ; 527 } 528 529 static void 530 errx_fn(void) 531 { 532 event_errx(2, "Fatal error; too many kumquats (%d)", 5); 533 } 534 535 static void 536 err_fn(void) 537 { 538 errno = ENOENT; 539 event_err(5,"Couldn't open %s", "/very/bad/file"); 540 } 541 542 static void 543 sock_err_fn(void) 544 { 545 evutil_socket_t fd = socket(AF_INET, SOCK_STREAM, 0); 546 #ifdef _WIN32 547 EVUTIL_SET_SOCKET_ERROR(WSAEWOULDBLOCK); 548 #else 549 errno = EAGAIN; 550 #endif 551 event_sock_err(20, fd, "Unhappy socket"); 552 } 553 #endif 554 555 static void 556 test_evutil_log(void *ptr) 557 { 558 evutil_socket_t fd = -1; 559 char buf[128]; 560 561 event_set_log_callback(logfn); 562 event_set_fatal_callback(fatalfn); 563 #define RESET() do { \ 564 logsev = 0; \ 565 if (logmsg) free(logmsg); \ 566 logmsg = NULL; \ 567 } while (/*CONSTCOND*/0) 568 #define LOGEQ(sev,msg) do { \ 569 tt_int_op(logsev,==,sev); \ 570 tt_assert(logmsg != NULL); \ 571 tt_str_op(logmsg,==,msg); \ 572 } while (/*CONSTCOND*/0) 573 574 #ifdef CAN_CHECK_ERR 575 /* We need to disable these tests for now. Previously, the logging 576 * module didn't enforce the requirement that a fatal callback 577 * actually exit. Now, it exits no matter what, so if we wan to 578 * reinstate these tests, we'll need to fork for each one. */ 579 check_error_logging(errx_fn, 2, EVENT_LOG_ERR, 580 "Fatal error; too many kumquats (5)"); 581 RESET(); 582 #endif 583 584 event_warnx("Far too many %s (%d)", "wombats", 99); 585 LOGEQ(EVENT_LOG_WARN, "Far too many wombats (99)"); 586 RESET(); 587 588 event_msgx("Connecting lime to coconut"); 589 LOGEQ(EVENT_LOG_MSG, "Connecting lime to coconut"); 590 RESET(); 591 592 event_debug(("A millisecond passed! We should log that!")); 593 #ifdef USE_DEBUG 594 LOGEQ(EVENT_LOG_DEBUG, "A millisecond passed! We should log that!"); 595 #else 596 tt_int_op(logsev,==,0); 597 tt_ptr_op(logmsg,==,NULL); 598 #endif 599 RESET(); 600 601 /* Try with an errno. */ 602 errno = ENOENT; 603 event_warn("Couldn't open %s", "/bad/file"); 604 evutil_snprintf(buf, sizeof(buf), 605 "Couldn't open /bad/file: %s",strerror(ENOENT)); 606 LOGEQ(EVENT_LOG_WARN,buf); 607 RESET(); 608 609 #ifdef CAN_CHECK_ERR 610 evutil_snprintf(buf, sizeof(buf), 611 "Couldn't open /very/bad/file: %s",strerror(ENOENT)); 612 check_error_logging(err_fn, 5, EVENT_LOG_ERR, buf); 613 RESET(); 614 #endif 615 616 /* Try with a socket errno. */ 617 fd = socket(AF_INET, SOCK_STREAM, 0); 618 #ifdef _WIN32 619 evutil_snprintf(buf, sizeof(buf), 620 "Unhappy socket: %s", 621 evutil_socket_error_to_string(WSAEWOULDBLOCK)); 622 EVUTIL_SET_SOCKET_ERROR(WSAEWOULDBLOCK); 623 #else 624 evutil_snprintf(buf, sizeof(buf), 625 "Unhappy socket: %s", strerror(EAGAIN)); 626 errno = EAGAIN; 627 #endif 628 event_sock_warn(fd, "Unhappy socket"); 629 LOGEQ(EVENT_LOG_WARN, buf); 630 RESET(); 631 632 #ifdef CAN_CHECK_ERR 633 check_error_logging(sock_err_fn, 20, EVENT_LOG_ERR, buf); 634 RESET(); 635 #endif 636 637 #undef RESET 638 #undef LOGEQ 639 end: 640 if (logmsg) 641 free(logmsg); 642 if (fd >= 0) 643 evutil_closesocket(fd); 644 } 645 646 static void 647 test_evutil_strlcpy(void *arg) 648 { 649 char buf[8]; 650 651 /* Successful case. */ 652 tt_int_op(5, ==, strlcpy(buf, "Hello", sizeof(buf))); 653 tt_str_op(buf, ==, "Hello"); 654 655 /* Overflow by a lot. */ 656 tt_int_op(13, ==, strlcpy(buf, "pentasyllabic", sizeof(buf))); 657 tt_str_op(buf, ==, "pentasy"); 658 659 /* Overflow by exactly one. */ 660 tt_int_op(8, ==, strlcpy(buf, "overlong", sizeof(buf))); 661 tt_str_op(buf, ==, "overlon"); 662 end: 663 ; 664 } 665 666 struct example_struct { 667 const char *a; 668 const char *b; 669 long c; 670 }; 671 672 static void 673 test_evutil_upcast(void *arg) 674 { 675 struct example_struct es1; 676 const char **cp; 677 es1.a = "World"; 678 es1.b = "Hello"; 679 es1.c = -99; 680 681 tt_int_op(evutil_offsetof(struct example_struct, b), ==, sizeof(char*)); 682 683 cp = &es1.b; 684 tt_ptr_op(EVUTIL_UPCAST(cp, struct example_struct, b), ==, &es1); 685 686 end: 687 ; 688 } 689 690 static void 691 test_evutil_integers(void *arg) 692 { 693 ev_int64_t i64; 694 ev_uint64_t u64; 695 ev_int32_t i32; 696 ev_uint32_t u32; 697 ev_int16_t i16; 698 ev_uint16_t u16; 699 ev_int8_t i8; 700 ev_uint8_t u8; 701 702 void *ptr; 703 ev_intptr_t iptr; 704 ev_uintptr_t uptr; 705 706 ev_ssize_t ssize; 707 708 tt_int_op(sizeof(u64), ==, 8); 709 tt_int_op(sizeof(i64), ==, 8); 710 tt_int_op(sizeof(u32), ==, 4); 711 tt_int_op(sizeof(i32), ==, 4); 712 tt_int_op(sizeof(u16), ==, 2); 713 tt_int_op(sizeof(i16), ==, 2); 714 tt_int_op(sizeof(u8), ==, 1); 715 tt_int_op(sizeof(i8), ==, 1); 716 717 tt_int_op(sizeof(ev_ssize_t), ==, sizeof(size_t)); 718 tt_int_op(sizeof(ev_intptr_t), >=, sizeof(void *)); 719 tt_int_op(sizeof(ev_uintptr_t), ==, sizeof(intptr_t)); 720 721 u64 = 1000000000; 722 u64 *= 1000000000; 723 tt_assert(u64 / 1000000000 == 1000000000); 724 i64 = -1000000000; 725 i64 *= 1000000000; 726 tt_assert(i64 / 1000000000 == -1000000000); 727 728 u64 = EV_UINT64_MAX; 729 i64 = EV_INT64_MAX; 730 tt_assert(u64 > 0); 731 tt_assert(i64 > 0); 732 u64++; 733 /* i64++; */ 734 tt_assert(u64 == 0); 735 /* tt_assert(i64 == EV_INT64_MIN); */ 736 /* tt_assert(i64 < 0); */ 737 738 u32 = EV_UINT32_MAX; 739 i32 = EV_INT32_MAX; 740 tt_assert(u32 > 0); 741 tt_assert(i32 > 0); 742 u32++; 743 /* i32++; */ 744 tt_assert(u32 == 0); 745 /* tt_assert(i32 == EV_INT32_MIN); */ 746 /* tt_assert(i32 < 0); */ 747 748 u16 = EV_UINT16_MAX; 749 i16 = EV_INT16_MAX; 750 tt_assert(u16 > 0); 751 tt_assert(i16 > 0); 752 u16++; 753 /* i16++; */ 754 tt_assert(u16 == 0); 755 /* tt_assert(i16 == EV_INT16_MIN); */ 756 /* tt_assert(i16 < 0); */ 757 758 u8 = EV_UINT8_MAX; 759 i8 = EV_INT8_MAX; 760 tt_assert(u8 > 0); 761 tt_assert(i8 > 0); 762 u8++; 763 /* i8++;*/ 764 tt_assert(u8 == 0); 765 /* tt_assert(i8 == EV_INT8_MIN); */ 766 /* tt_assert(i8 < 0); */ 767 768 /* 769 ssize = EV_SSIZE_MAX; 770 tt_assert(ssize > 0); 771 ssize++; 772 tt_assert(ssize < 0); 773 tt_assert(ssize == EV_SSIZE_MIN); 774 */ 775 776 ptr = &ssize; 777 iptr = (ev_intptr_t)ptr; 778 uptr = (ev_uintptr_t)ptr; 779 ptr = (void *)iptr; 780 tt_assert(ptr == &ssize); 781 ptr = (void *)uptr; 782 tt_assert(ptr == &ssize); 783 784 iptr = -1; 785 tt_assert(iptr < 0); 786 end: 787 ; 788 } 789 790 struct evutil_addrinfo * 791 ai_find_by_family(struct evutil_addrinfo *ai, int family) 792 { 793 while (ai) { 794 if (ai->ai_family == family) 795 return ai; 796 ai = ai->ai_next; 797 } 798 return NULL; 799 } 800 801 struct evutil_addrinfo * 802 ai_find_by_protocol(struct evutil_addrinfo *ai, int protocol) 803 { 804 while (ai) { 805 if (ai->ai_protocol == protocol) 806 return ai; 807 ai = ai->ai_next; 808 } 809 return NULL; 810 } 811 812 813 int 814 test_ai_eq_(const struct evutil_addrinfo *ai, const char *sockaddr_port, 815 int socktype, int protocol, int line) 816 { 817 struct sockaddr_storage ss; 818 int slen = sizeof(ss); 819 int gotport; 820 char buf[128]; 821 memset(&ss, 0, sizeof(ss)); 822 if (socktype > 0) 823 tt_int_op(ai->ai_socktype, ==, socktype); 824 if (protocol > 0) 825 tt_int_op(ai->ai_protocol, ==, protocol); 826 827 if (evutil_parse_sockaddr_port( 828 sockaddr_port, (struct sockaddr*)&ss, &slen)<0) { 829 TT_FAIL(("Couldn't parse expected address %s on line %d", 830 sockaddr_port, line)); 831 return -1; 832 } 833 if (ai->ai_family != ss.ss_family) { 834 TT_FAIL(("Address family %d did not match %d on line %d", 835 ai->ai_family, ss.ss_family, line)); 836 return -1; 837 } 838 if (ai->ai_addr->sa_family == AF_INET) { 839 struct sockaddr_in *sin = (struct sockaddr_in*)ai->ai_addr; 840 evutil_inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof(buf)); 841 gotport = ntohs(sin->sin_port); 842 if (ai->ai_addrlen != sizeof(struct sockaddr_in)) { 843 TT_FAIL(("Addr size mismatch on line %d", line)); 844 return -1; 845 } 846 } else { 847 struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)ai->ai_addr; 848 evutil_inet_ntop(AF_INET6, &sin6->sin6_addr, buf, sizeof(buf)); 849 gotport = ntohs(sin6->sin6_port); 850 if (ai->ai_addrlen != sizeof(struct sockaddr_in6)) { 851 TT_FAIL(("Addr size mismatch on line %d", line)); 852 return -1; 853 } 854 } 855 if (evutil_sockaddr_cmp(ai->ai_addr, (struct sockaddr*)&ss, 1)) { 856 TT_FAIL(("Wanted %s, got %s:%d on line %d", sockaddr_port, 857 buf, gotport, line)); 858 return -1; 859 } else { 860 TT_BLATHER(("Wanted %s, got %s:%d on line %d", sockaddr_port, 861 buf, gotport, line)); 862 } 863 return 0; 864 end: 865 TT_FAIL(("Test failed on line %d", line)); 866 return -1; 867 } 868 869 static void 870 test_evutil_rand(void *arg) 871 { 872 char buf1[32]; 873 char buf2[32]; 874 int counts[256]; 875 int i, j, k, n=0; 876 struct evutil_weakrand_state seed = { 12346789U }; 877 878 memset(buf2, 0, sizeof(buf2)); 879 memset(counts, 0, sizeof(counts)); 880 881 for (k=0;k<32;++k) { 882 /* Try a few different start and end points; try to catch 883 * the various misaligned cases of arc4random_buf */ 884 int startpoint = evutil_weakrand_(&seed) % 4; 885 int endpoint = 32 - (evutil_weakrand_(&seed) % 4); 886 887 memset(buf2, 0, sizeof(buf2)); 888 889 /* Do 6 runs over buf1, or-ing the result into buf2 each 890 * time, to make sure we're setting each byte that we mean 891 * to set. */ 892 for (i=0;i<8;++i) { 893 memset(buf1, 0, sizeof(buf1)); 894 evutil_secure_rng_get_bytes(buf1 + startpoint, 895 endpoint-startpoint); 896 n += endpoint - startpoint; 897 for (j=0; j<32; ++j) { 898 if (j >= startpoint && j < endpoint) { 899 buf2[j] |= buf1[j]; 900 ++counts[(unsigned char)buf1[j]]; 901 } else { 902 tt_assert(buf1[j] == 0); 903 tt_int_op(buf1[j], ==, 0); 904 905 } 906 } 907 } 908 909 /* This will give a false positive with P=(256**8)==(2**64) 910 * for each character. */ 911 for (j=startpoint;j<endpoint;++j) { 912 tt_int_op(buf2[j], !=, 0); 913 } 914 } 915 916 evutil_weakrand_seed_(&seed, 0); 917 for (i = 0; i < 10000; ++i) { 918 ev_int32_t r = evutil_weakrand_range_(&seed, 9999); 919 tt_int_op(0, <=, r); 920 tt_int_op(r, <, 9999); 921 } 922 923 /* for (i=0;i<256;++i) { printf("%3d %2d\n", i, counts[i]); } */ 924 end: 925 ; 926 } 927 928 static void 929 test_evutil_getaddrinfo(void *arg) 930 { 931 struct evutil_addrinfo *ai = NULL, *a; 932 struct evutil_addrinfo hints; 933 int r; 934 935 /* Try using it as a pton. */ 936 memset(&hints, 0, sizeof(hints)); 937 hints.ai_family = PF_UNSPEC; 938 hints.ai_socktype = SOCK_STREAM; 939 r = evutil_getaddrinfo("1.2.3.4", "8080", &hints, &ai); 940 tt_int_op(r, ==, 0); 941 tt_assert(ai); 942 tt_ptr_op(ai->ai_next, ==, NULL); /* no ambiguity */ 943 test_ai_eq(ai, "1.2.3.4:8080", SOCK_STREAM, IPPROTO_TCP); 944 evutil_freeaddrinfo(ai); 945 ai = NULL; 946 947 memset(&hints, 0, sizeof(hints)); 948 hints.ai_family = PF_UNSPEC; 949 hints.ai_protocol = IPPROTO_UDP; 950 r = evutil_getaddrinfo("1001:b0b::f00f", "4321", &hints, &ai); 951 tt_int_op(r, ==, 0); 952 tt_assert(ai); 953 tt_ptr_op(ai->ai_next, ==, NULL); /* no ambiguity */ 954 test_ai_eq(ai, "[1001:b0b::f00f]:4321", SOCK_DGRAM, IPPROTO_UDP); 955 evutil_freeaddrinfo(ai); 956 ai = NULL; 957 958 /* Try out the behavior of nodename=NULL */ 959 memset(&hints, 0, sizeof(hints)); 960 hints.ai_family = PF_INET; 961 hints.ai_protocol = IPPROTO_TCP; 962 hints.ai_flags = EVUTIL_AI_PASSIVE; /* as if for bind */ 963 r = evutil_getaddrinfo(NULL, "9999", &hints, &ai); 964 tt_int_op(r,==,0); 965 tt_assert(ai); 966 tt_ptr_op(ai->ai_next, ==, NULL); 967 test_ai_eq(ai, "0.0.0.0:9999", SOCK_STREAM, IPPROTO_TCP); 968 evutil_freeaddrinfo(ai); 969 ai = NULL; 970 hints.ai_flags = 0; /* as if for connect */ 971 r = evutil_getaddrinfo(NULL, "9998", &hints, &ai); 972 tt_assert(ai); 973 tt_int_op(r,==,0); 974 test_ai_eq(ai, "127.0.0.1:9998", SOCK_STREAM, IPPROTO_TCP); 975 tt_ptr_op(ai->ai_next, ==, NULL); 976 evutil_freeaddrinfo(ai); 977 ai = NULL; 978 979 hints.ai_flags = 0; /* as if for connect */ 980 hints.ai_family = PF_INET6; 981 r = evutil_getaddrinfo(NULL, "9997", &hints, &ai); 982 tt_assert(ai); 983 tt_int_op(r,==,0); 984 tt_ptr_op(ai->ai_next, ==, NULL); 985 test_ai_eq(ai, "[::1]:9997", SOCK_STREAM, IPPROTO_TCP); 986 evutil_freeaddrinfo(ai); 987 ai = NULL; 988 989 hints.ai_flags = EVUTIL_AI_PASSIVE; /* as if for bind. */ 990 hints.ai_family = PF_INET6; 991 r = evutil_getaddrinfo(NULL, "9996", &hints, &ai); 992 tt_assert(ai); 993 tt_int_op(r,==,0); 994 tt_ptr_op(ai->ai_next, ==, NULL); 995 test_ai_eq(ai, "[::]:9996", SOCK_STREAM, IPPROTO_TCP); 996 evutil_freeaddrinfo(ai); 997 ai = NULL; 998 999 /* Now try an unspec one. We should get a v6 and a v4. */ 1000 hints.ai_family = PF_UNSPEC; 1001 r = evutil_getaddrinfo(NULL, "9996", &hints, &ai); 1002 tt_assert(ai); 1003 tt_int_op(r,==,0); 1004 a = ai_find_by_family(ai, PF_INET6); 1005 tt_assert(a); 1006 test_ai_eq(a, "[::]:9996", SOCK_STREAM, IPPROTO_TCP); 1007 a = ai_find_by_family(ai, PF_INET); 1008 tt_assert(a); 1009 test_ai_eq(a, "0.0.0.0:9996", SOCK_STREAM, IPPROTO_TCP); 1010 evutil_freeaddrinfo(ai); 1011 ai = NULL; 1012 1013 /* Try out AI_NUMERICHOST: successful case. Also try 1014 * multiprotocol. */ 1015 memset(&hints, 0, sizeof(hints)); 1016 hints.ai_family = PF_UNSPEC; 1017 hints.ai_flags = EVUTIL_AI_NUMERICHOST; 1018 r = evutil_getaddrinfo("1.2.3.4", NULL, &hints, &ai); 1019 tt_int_op(r, ==, 0); 1020 a = ai_find_by_protocol(ai, IPPROTO_TCP); 1021 tt_assert(a); 1022 test_ai_eq(a, "1.2.3.4", SOCK_STREAM, IPPROTO_TCP); 1023 a = ai_find_by_protocol(ai, IPPROTO_UDP); 1024 tt_assert(a); 1025 test_ai_eq(a, "1.2.3.4", SOCK_DGRAM, IPPROTO_UDP); 1026 evutil_freeaddrinfo(ai); 1027 ai = NULL; 1028 1029 /* Try the failing case of AI_NUMERICHOST */ 1030 memset(&hints, 0, sizeof(hints)); 1031 hints.ai_family = PF_UNSPEC; 1032 hints.ai_flags = EVUTIL_AI_NUMERICHOST; 1033 r = evutil_getaddrinfo("www.google.com", "80", &hints, &ai); 1034 tt_int_op(r, ==, EVUTIL_EAI_NONAME); 1035 tt_ptr_op(ai, ==, NULL); 1036 1037 /* Try symbolic service names wit AI_NUMERICSERV */ 1038 memset(&hints, 0, sizeof(hints)); 1039 hints.ai_family = PF_UNSPEC; 1040 hints.ai_socktype = SOCK_STREAM; 1041 hints.ai_flags = EVUTIL_AI_NUMERICSERV; 1042 r = evutil_getaddrinfo("1.2.3.4", "http", &hints, &ai); 1043 tt_int_op(r,==,EVUTIL_EAI_NONAME); 1044 1045 /* Try symbolic service names */ 1046 memset(&hints, 0, sizeof(hints)); 1047 hints.ai_family = PF_UNSPEC; 1048 hints.ai_socktype = SOCK_STREAM; 1049 r = evutil_getaddrinfo("1.2.3.4", "http", &hints, &ai); 1050 if (r!=0) { 1051 TT_DECLARE("SKIP", ("Symbolic service names seem broken.")); 1052 } else { 1053 tt_assert(ai); 1054 test_ai_eq(ai, "1.2.3.4:80", SOCK_STREAM, IPPROTO_TCP); 1055 evutil_freeaddrinfo(ai); 1056 ai = NULL; 1057 } 1058 1059 end: 1060 if (ai) 1061 evutil_freeaddrinfo(ai); 1062 } 1063 1064 static void 1065 test_evutil_getaddrinfo_live(void *arg) 1066 { 1067 struct evutil_addrinfo *ai = NULL; 1068 struct evutil_addrinfo hints; 1069 1070 struct sockaddr_in6 *sin6; 1071 struct sockaddr_in *sin; 1072 char buf[128]; 1073 const char *cp; 1074 int r; 1075 1076 /* Now do some actual lookups. */ 1077 memset(&hints, 0, sizeof(hints)); 1078 hints.ai_family = PF_INET; 1079 hints.ai_protocol = IPPROTO_TCP; 1080 hints.ai_socktype = SOCK_STREAM; 1081 r = evutil_getaddrinfo("www.google.com", "80", &hints, &ai); 1082 if (r != 0) { 1083 TT_DECLARE("SKIP", ("Couldn't resolve www.google.com")); 1084 } else { 1085 tt_assert(ai); 1086 tt_int_op(ai->ai_family, ==, PF_INET); 1087 tt_int_op(ai->ai_protocol, ==, IPPROTO_TCP); 1088 tt_int_op(ai->ai_socktype, ==, SOCK_STREAM); 1089 tt_int_op(ai->ai_addrlen, ==, sizeof(struct sockaddr_in)); 1090 sin = (struct sockaddr_in*)ai->ai_addr; 1091 tt_int_op(sin->sin_family, ==, AF_INET); 1092 tt_int_op(sin->sin_port, ==, htons(80)); 1093 tt_int_op(sin->sin_addr.s_addr, !=, 0xffffffff); 1094 1095 cp = evutil_inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof(buf)); 1096 TT_BLATHER(("www.google.com resolved to %s", 1097 cp?cp:"<unwriteable>")); 1098 evutil_freeaddrinfo(ai); 1099 ai = NULL; 1100 } 1101 1102 hints.ai_family = PF_INET6; 1103 r = evutil_getaddrinfo("ipv6.google.com", "80", &hints, &ai); 1104 if (r != 0) { 1105 TT_BLATHER(("Couldn't do an ipv6 lookup for ipv6.google.com")); 1106 } else { 1107 tt_assert(ai); 1108 tt_int_op(ai->ai_family, ==, PF_INET6); 1109 tt_int_op(ai->ai_addrlen, ==, sizeof(struct sockaddr_in6)); 1110 sin6 = (struct sockaddr_in6*)ai->ai_addr; 1111 tt_int_op(sin6->sin6_port, ==, htons(80)); 1112 1113 cp = evutil_inet_ntop(AF_INET6, &sin6->sin6_addr, buf, 1114 sizeof(buf)); 1115 TT_BLATHER(("ipv6.google.com resolved to %s", 1116 cp?cp:"<unwriteable>")); 1117 } 1118 1119 end: 1120 if (ai) 1121 evutil_freeaddrinfo(ai); 1122 } 1123 1124 #ifdef _WIN32 1125 static void 1126 test_evutil_loadsyslib(void *arg) 1127 { 1128 HMODULE h=NULL; 1129 1130 h = evutil_load_windows_system_library_(TEXT("kernel32.dll")); 1131 tt_assert(h); 1132 1133 end: 1134 if (h) 1135 CloseHandle(h); 1136 1137 } 1138 #endif 1139 1140 /** Test mm_malloc(). */ 1141 static void 1142 test_event_malloc(void *arg) 1143 { 1144 void *p = NULL; 1145 (void)arg; 1146 1147 /* mm_malloc(0) should simply return NULL. */ 1148 #ifndef EVENT__DISABLE_MM_REPLACEMENT 1149 errno = 0; 1150 p = mm_malloc(0); 1151 tt_assert(p == NULL); 1152 tt_int_op(errno, ==, 0); 1153 #endif 1154 1155 /* Trivial case. */ 1156 errno = 0; 1157 p = mm_malloc(8); 1158 tt_assert(p != NULL); 1159 tt_int_op(errno, ==, 0); 1160 mm_free(p); 1161 1162 end: 1163 errno = 0; 1164 return; 1165 } 1166 1167 static void 1168 test_event_calloc(void *arg) 1169 { 1170 void *p = NULL; 1171 (void)arg; 1172 1173 #ifndef EVENT__DISABLE_MM_REPLACEMENT 1174 /* mm_calloc() should simply return NULL 1175 * if either argument is zero. */ 1176 errno = 0; 1177 p = mm_calloc(0, 0); 1178 tt_assert(p == NULL); 1179 tt_int_op(errno, ==, 0); 1180 errno = 0; 1181 p = mm_calloc(0, 1); 1182 tt_assert(p == NULL); 1183 tt_int_op(errno, ==, 0); 1184 errno = 0; 1185 p = mm_calloc(1, 0); 1186 tt_assert(p == NULL); 1187 tt_int_op(errno, ==, 0); 1188 #endif 1189 1190 /* Trivial case. */ 1191 errno = 0; 1192 p = mm_calloc(8, 8); 1193 tt_assert(p != NULL); 1194 tt_int_op(errno, ==, 0); 1195 mm_free(p); 1196 p = NULL; 1197 1198 /* mm_calloc() should set errno = ENOMEM and return NULL 1199 * in case of potential overflow. */ 1200 errno = 0; 1201 p = mm_calloc(EV_SIZE_MAX/2, EV_SIZE_MAX/2 + 8); 1202 tt_assert(p == NULL); 1203 tt_int_op(errno, ==, ENOMEM); 1204 1205 end: 1206 errno = 0; 1207 if (p) 1208 mm_free(p); 1209 1210 return; 1211 } 1212 1213 static void 1214 test_event_strdup(void *arg) 1215 { 1216 void *p = NULL; 1217 (void)arg; 1218 1219 #ifndef EVENT__DISABLE_MM_REPLACEMENT 1220 /* mm_strdup(NULL) should set errno = EINVAL and return NULL. */ 1221 errno = 0; 1222 p = mm_strdup(NULL); 1223 tt_assert(p == NULL); 1224 tt_int_op(errno, ==, EINVAL); 1225 #endif 1226 1227 /* Trivial cases. */ 1228 1229 errno = 0; 1230 p = mm_strdup(""); 1231 tt_assert(p != NULL); 1232 tt_int_op(errno, ==, 0); 1233 tt_str_op(p, ==, ""); 1234 mm_free(p); 1235 1236 errno = 0; 1237 p = mm_strdup("foo"); 1238 tt_assert(p != NULL); 1239 tt_int_op(errno, ==, 0); 1240 tt_str_op(p, ==, "foo"); 1241 mm_free(p); 1242 1243 /* XXX 1244 * mm_strdup(str) where str is a string of length EV_SIZE_MAX 1245 * should set errno = ENOMEM and return NULL. */ 1246 1247 end: 1248 errno = 0; 1249 return; 1250 } 1251 1252 static void 1253 test_evutil_usleep(void *arg) 1254 { 1255 struct timeval tv1, tv2, tv3, diff1, diff2; 1256 const struct timeval quarter_sec = {0, 250*1000}; 1257 const struct timeval tenth_sec = {0, 100*1000}; 1258 long usec1, usec2; 1259 1260 evutil_gettimeofday(&tv1, NULL); 1261 evutil_usleep_(&quarter_sec); 1262 evutil_gettimeofday(&tv2, NULL); 1263 evutil_usleep_(&tenth_sec); 1264 evutil_gettimeofday(&tv3, NULL); 1265 1266 evutil_timersub(&tv2, &tv1, &diff1); 1267 evutil_timersub(&tv3, &tv2, &diff2); 1268 usec1 = diff1.tv_sec * 1000000 + diff1.tv_usec; 1269 usec2 = diff2.tv_sec * 1000000 + diff2.tv_usec; 1270 1271 tt_int_op(usec1, >, 200000); 1272 tt_int_op(usec1, <, 300000); 1273 tt_int_op(usec2, >, 80000); 1274 tt_int_op(usec2, <, 120000); 1275 1276 end: 1277 ; 1278 } 1279 1280 static void 1281 test_evutil_monotonic_res(void *data_) 1282 { 1283 /* Basic santity-test for monotonic timers. What we'd really like 1284 * to do is make sure that they can't go backwards even when the 1285 * system clock goes backwards. But we haven't got a good way to 1286 * move the system clock backwards. 1287 */ 1288 struct basic_test_data *data = data_; 1289 struct evutil_monotonic_timer timer; 1290 const int precise = strstr(data->setup_data, "precise") != NULL; 1291 const int fallback = strstr(data->setup_data, "fallback") != NULL; 1292 struct timeval tv[10], delay; 1293 int total_diff = 0; 1294 1295 int flags = 0, wantres, acceptdiff, i; 1296 if (precise) 1297 flags |= EV_MONOT_PRECISE; 1298 if (fallback) 1299 flags |= EV_MONOT_FALLBACK; 1300 if (precise || fallback) { 1301 #ifdef _WIN32 1302 wantres = 10*1000; 1303 acceptdiff = 1000; 1304 #else 1305 wantres = 1000; 1306 acceptdiff = 300; 1307 #endif 1308 } else { 1309 wantres = 40*1000; 1310 acceptdiff = 20*1000; 1311 } 1312 1313 TT_BLATHER(("Precise = %d", precise)); 1314 TT_BLATHER(("Fallback = %d", fallback)); 1315 1316 /* First, make sure we match up with usleep. */ 1317 1318 delay.tv_sec = 0; 1319 delay.tv_usec = wantres; 1320 1321 tt_int_op(evutil_configure_monotonic_time_(&timer, flags), ==, 0); 1322 1323 for (i = 0; i < 10; ++i) { 1324 evutil_gettime_monotonic_(&timer, &tv[i]); 1325 evutil_usleep_(&delay); 1326 } 1327 1328 for (i = 0; i < 9; ++i) { 1329 struct timeval diff; 1330 tt_assert(evutil_timercmp(&tv[i], &tv[i+1], <)); 1331 evutil_timersub(&tv[i+1], &tv[i], &diff); 1332 tt_int_op(diff.tv_sec, ==, 0); 1333 total_diff += diff.tv_usec; 1334 TT_BLATHER(("Difference = %d", (int)diff.tv_usec)); 1335 } 1336 tt_int_op(abs(total_diff/9 - wantres), <, acceptdiff); 1337 1338 end: 1339 ; 1340 } 1341 1342 static void 1343 test_evutil_monotonic_prc(void *data_) 1344 { 1345 struct basic_test_data *data = data_; 1346 struct evutil_monotonic_timer timer; 1347 const int precise = strstr(data->setup_data, "precise") != NULL; 1348 const int fallback = strstr(data->setup_data, "fallback") != NULL; 1349 struct timeval tv[10]; 1350 int total_diff = 0; 1351 int i, maxstep = 25*1000,flags=0; 1352 if (precise) 1353 maxstep = 500; 1354 if (precise) 1355 flags |= EV_MONOT_PRECISE; 1356 if (fallback) 1357 flags |= EV_MONOT_FALLBACK; 1358 tt_int_op(evutil_configure_monotonic_time_(&timer, flags), ==, 0); 1359 1360 /* find out what precision we actually see. */ 1361 1362 evutil_gettime_monotonic_(&timer, &tv[0]); 1363 for (i = 1; i < 10; ++i) { 1364 do { 1365 evutil_gettime_monotonic_(&timer, &tv[i]); 1366 } while (evutil_timercmp(&tv[i-1], &tv[i], ==)); 1367 } 1368 1369 total_diff = 0; 1370 for (i = 0; i < 9; ++i) { 1371 struct timeval diff; 1372 tt_assert(evutil_timercmp(&tv[i], &tv[i+1], <)); 1373 evutil_timersub(&tv[i+1], &tv[i], &diff); 1374 tt_int_op(diff.tv_sec, ==, 0); 1375 total_diff += diff.tv_usec; 1376 TT_BLATHER(("Step difference = %d", (int)diff.tv_usec)); 1377 } 1378 TT_BLATHER(("Average step difference = %d", total_diff / 9)); 1379 tt_int_op(total_diff/9, <, maxstep); 1380 1381 end: 1382 ; 1383 } 1384 1385 static void 1386 create_tm_from_unix_epoch(struct tm *cur_p, const time_t t) 1387 { 1388 #ifdef _WIN32 1389 struct tm *tmp = gmtime(&t); 1390 if (!tmp) { 1391 fprintf(stderr, "gmtime: %s (%i)", strerror(errno), (int)t); 1392 exit(1); 1393 } 1394 *cur_p = *tmp; 1395 #else 1396 gmtime_r(&t, cur_p); 1397 #endif 1398 } 1399 1400 static struct date_rfc1123_case { 1401 time_t t; 1402 char date[30]; 1403 } date_rfc1123_cases[] = { 1404 { 0, "Thu, 01 Jan 1970 00:00:00 GMT"} /* UNIX time of zero */, 1405 { 946684799, "Fri, 31 Dec 1999 23:59:59 GMT"} /* the last moment of the 20th century */, 1406 { 946684800, "Sat, 01 Jan 2000 00:00:00 GMT"} /* the first moment of the 21st century */, 1407 { 981072000, "Fri, 02 Feb 2001 00:00:00 GMT"}, 1408 { 1015113600, "Sun, 03 Mar 2002 00:00:00 GMT"}, 1409 { 1049414400, "Fri, 04 Apr 2003 00:00:00 GMT"}, 1410 { 1083715200, "Wed, 05 May 2004 00:00:00 GMT"}, 1411 { 1118016000, "Mon, 06 Jun 2005 00:00:00 GMT"}, 1412 { 1152230400, "Fri, 07 Jul 2006 00:00:00 GMT"}, 1413 { 1186531200, "Wed, 08 Aug 2007 00:00:00 GMT"}, 1414 { 1220918400, "Tue, 09 Sep 2008 00:00:00 GMT"}, 1415 { 1255132800, "Sat, 10 Oct 2009 00:00:00 GMT"}, 1416 { 1289433600, "Thu, 11 Nov 2010 00:00:00 GMT"}, 1417 { 1323648000, "Mon, 12 Dec 2011 00:00:00 GMT"}, 1418 #ifndef _WIN32 1419 /** In win32 case we have max "23:59:59 January 18, 2038, UTC" for time32 */ 1420 { 4294967296, "Sun, 07 Feb 2106 06:28:16 GMT"} /* 2^32 */, 1421 /** In win32 case we have max "23:59:59, December 31, 3000, UTC" for time64 */ 1422 {253402300799, "Fri, 31 Dec 9999 23:59:59 GMT"} /* long long future no one can imagine */, 1423 { 1456704000, "Mon, 29 Feb 2016 00:00:00 GMT"} /* leap year */, 1424 #endif 1425 { 1435708800, "Wed, 01 Jul 2015 00:00:00 GMT"} /* leap second */, 1426 { 1481866376, "Fri, 16 Dec 2016 05:32:56 GMT"} /* the time this test case is generated */, 1427 {0, ""} /* end of test cases. */ 1428 }; 1429 1430 static void 1431 test_evutil_date_rfc1123(void *arg) 1432 { 1433 struct tm query; 1434 char result[30]; 1435 size_t i = 0; 1436 1437 /* Checks if too small buffers are safely accepted. */ 1438 { 1439 create_tm_from_unix_epoch(&query, 0); 1440 evutil_date_rfc1123(result, 8, &query); 1441 tt_str_op(result, ==, "Thu, 01"); 1442 } 1443 1444 /* Checks for testcases. */ 1445 for (i = 0; ; i++) { 1446 struct date_rfc1123_case c = date_rfc1123_cases[i]; 1447 1448 if (strlen(c.date) == 0) 1449 break; 1450 1451 create_tm_from_unix_epoch(&query, c.t); 1452 evutil_date_rfc1123(result, sizeof(result), &query); 1453 tt_str_op(result, ==, c.date); 1454 } 1455 1456 end: 1457 ; 1458 } 1459 1460 struct testcase_t util_testcases[] = { 1461 { "ipv4_parse", regress_ipv4_parse, 0, NULL, NULL }, 1462 { "ipv6_parse", regress_ipv6_parse, 0, NULL, NULL }, 1463 { "sockaddr_port_parse", regress_sockaddr_port_parse, 0, NULL, NULL }, 1464 { "sockaddr_port_format", regress_sockaddr_port_format, 0, NULL, NULL }, 1465 { "sockaddr_predicates", test_evutil_sockaddr_predicates, 0,NULL,NULL }, 1466 { "evutil_snprintf", test_evutil_snprintf, 0, NULL, NULL }, 1467 { "evutil_strtoll", test_evutil_strtoll, 0, NULL, NULL }, 1468 { "evutil_casecmp", test_evutil_casecmp, 0, NULL, NULL }, 1469 { "evutil_rtrim", test_evutil_rtrim, 0, NULL, NULL }, 1470 { "strlcpy", test_evutil_strlcpy, 0, NULL, NULL }, 1471 { "log", test_evutil_log, TT_FORK, NULL, NULL }, 1472 { "upcast", test_evutil_upcast, 0, NULL, NULL }, 1473 { "integers", test_evutil_integers, 0, NULL, NULL }, 1474 { "rand", test_evutil_rand, TT_FORK, NULL, NULL }, 1475 { "getaddrinfo", test_evutil_getaddrinfo, TT_FORK, NULL, NULL }, 1476 { "getaddrinfo_live", test_evutil_getaddrinfo_live, TT_FORK|TT_OFF_BY_DEFAULT, NULL, NULL }, 1477 #ifdef _WIN32 1478 { "loadsyslib", test_evutil_loadsyslib, TT_FORK, NULL, NULL }, 1479 #endif 1480 { "mm_malloc", test_event_malloc, 0, NULL, NULL }, 1481 { "mm_calloc", test_event_calloc, 0, NULL, NULL }, 1482 { "mm_strdup", test_event_strdup, 0, NULL, NULL }, 1483 { "usleep", test_evutil_usleep, 0, NULL, NULL }, 1484 { "monotonic_res", test_evutil_monotonic_res, 0, &basic_setup, __UNCONST("") }, 1485 { "monotonic_res_precise", test_evutil_monotonic_res, TT_OFF_BY_DEFAULT, &basic_setup, __UNCONST("precise") }, 1486 { "monotonic_res_fallback", test_evutil_monotonic_res, TT_OFF_BY_DEFAULT, &basic_setup, __UNCONST("fallback") }, 1487 { "monotonic_prc", test_evutil_monotonic_prc, 0, &basic_setup, __UNCONST("") }, 1488 { "monotonic_prc_precise", test_evutil_monotonic_prc, 0, &basic_setup, __UNCONST("precise") }, 1489 { "monotonic_prc_fallback", test_evutil_monotonic_prc, 0, &basic_setup, __UNCONST("fallback") }, 1490 { "date_rfc1123", test_evutil_date_rfc1123, 0, NULL, NULL }, 1491 END_OF_TESTCASES, 1492 }; 1493 1494