1 /* 2 * Copyright (c) 2003-2007 Niels Provos <provos@citi.umich.edu> 3 * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 #include "../util-internal.h" 28 29 #ifdef _WIN32 30 #include <winsock2.h> 31 #include <windows.h> 32 #include <ws2tcpip.h> 33 #endif 34 35 #include "event2/event-config.h" 36 37 #include <sys/types.h> 38 #include <sys/stat.h> 39 #ifdef EVENT__HAVE_SYS_TIME_H 40 #include <sys/time.h> 41 #endif 42 #include <sys/queue.h> 43 #ifndef _WIN32 44 #include <sys/socket.h> 45 #include <signal.h> 46 #include <netinet/in.h> 47 #include <arpa/inet.h> 48 #include <unistd.h> 49 #endif 50 #ifdef EVENT__HAVE_NETINET_IN6_H 51 #include <netinet/in6.h> 52 #endif 53 #ifdef HAVE_NETDB_H 54 #include <netdb.h> 55 #endif 56 #include <fcntl.h> 57 #include <stdlib.h> 58 #include <stdio.h> 59 #include <string.h> 60 #include <errno.h> 61 62 #include "event2/dns.h" 63 #include "event2/dns_compat.h" 64 #include "event2/dns_struct.h" 65 #include "event2/event.h" 66 #include "event2/event_compat.h" 67 #include "event2/event_struct.h" 68 #include "event2/util.h" 69 #include "event2/listener.h" 70 #include "event2/bufferevent.h" 71 #include "log-internal.h" 72 #include "regress.h" 73 #include "regress_testutils.h" 74 75 static int dns_ok = 0; 76 static int dns_got_cancel = 0; 77 static int dns_err = 0; 78 79 80 static void 81 dns_gethostbyname_cb(int result, char type, int count, int ttl, 82 void *addresses, void *arg) 83 { 84 dns_ok = dns_err = 0; 85 86 if (result == DNS_ERR_TIMEOUT) { 87 printf("[Timed out] "); 88 dns_err = result; 89 goto out; 90 } 91 92 if (result != DNS_ERR_NONE) { 93 printf("[Error code %d] ", result); 94 goto out; 95 } 96 97 TT_BLATHER(("type: %d, count: %d, ttl: %d: ", type, count, ttl)); 98 99 switch (type) { 100 case DNS_IPv6_AAAA: { 101 #if defined(EVENT__HAVE_STRUCT_IN6_ADDR) && defined(EVENT__HAVE_INET_NTOP) && defined(INET6_ADDRSTRLEN) 102 struct in6_addr *in6_addrs = addresses; 103 char buf[INET6_ADDRSTRLEN+1]; 104 int i; 105 /* a resolution that's not valid does not help */ 106 if (ttl < 0) 107 goto out; 108 for (i = 0; i < count; ++i) { 109 const char *b = evutil_inet_ntop(AF_INET6, &in6_addrs[i], buf,sizeof(buf)); 110 if (b) 111 TT_BLATHER(("%s ", b)); 112 else 113 TT_BLATHER(("%s ", strerror(errno))); 114 } 115 #endif 116 break; 117 } 118 case DNS_IPv4_A: { 119 struct in_addr *in_addrs = addresses; 120 int i; 121 /* a resolution that's not valid does not help */ 122 if (ttl < 0) 123 goto out; 124 for (i = 0; i < count; ++i) 125 TT_BLATHER(("%s ", inet_ntoa(in_addrs[i]))); 126 break; 127 } 128 case DNS_PTR: 129 /* may get at most one PTR */ 130 if (count != 1) 131 goto out; 132 133 TT_BLATHER(("%s ", *(char **)addresses)); 134 break; 135 default: 136 goto out; 137 } 138 139 dns_ok = type; 140 141 out: 142 if (arg == NULL) 143 event_loopexit(NULL); 144 else 145 event_base_loopexit((struct event_base *)arg, NULL); 146 } 147 148 static void 149 dns_gethostbyname(void) 150 { 151 dns_ok = 0; 152 evdns_resolve_ipv4("www.monkey.org", 0, dns_gethostbyname_cb, NULL); 153 event_dispatch(); 154 155 tt_int_op(dns_ok, ==, DNS_IPv4_A); 156 test_ok = dns_ok; 157 end: 158 ; 159 } 160 161 static void 162 dns_gethostbyname6(void) 163 { 164 dns_ok = 0; 165 evdns_resolve_ipv6("www.ietf.org", 0, dns_gethostbyname_cb, NULL); 166 event_dispatch(); 167 168 if (!dns_ok && dns_err == DNS_ERR_TIMEOUT) { 169 tt_skip(); 170 } 171 172 tt_int_op(dns_ok, ==, DNS_IPv6_AAAA); 173 test_ok = 1; 174 end: 175 ; 176 } 177 178 static void 179 dns_gethostbyaddr(void) 180 { 181 struct in_addr in; 182 in.s_addr = htonl(0x7f000001ul); /* 127.0.0.1 */ 183 dns_ok = 0; 184 evdns_resolve_reverse(&in, 0, dns_gethostbyname_cb, NULL); 185 event_dispatch(); 186 187 tt_int_op(dns_ok, ==, DNS_PTR); 188 test_ok = dns_ok; 189 end: 190 ; 191 } 192 193 static void 194 dns_resolve_reverse(void *ptr) 195 { 196 struct in_addr in; 197 struct event_base *base = event_base_new(); 198 struct evdns_base *dns = evdns_base_new(base, 1/* init name servers */); 199 struct evdns_request *req = NULL; 200 201 tt_assert(base); 202 tt_assert(dns); 203 in.s_addr = htonl(0x7f000001ul); /* 127.0.0.1 */ 204 dns_ok = 0; 205 206 req = evdns_base_resolve_reverse( 207 dns, &in, 0, dns_gethostbyname_cb, base); 208 tt_assert(req); 209 210 event_base_dispatch(base); 211 212 tt_int_op(dns_ok, ==, DNS_PTR); 213 214 end: 215 if (dns) 216 evdns_base_free(dns, 0); 217 if (base) 218 event_base_free(base); 219 } 220 221 static int n_server_responses = 0; 222 223 static void 224 dns_server_request_cb(struct evdns_server_request *req, void *data) 225 { 226 int i, r; 227 const char TEST_ARPA[] = "11.11.168.192.in-addr.arpa"; 228 const char TEST_IN6[] = 229 "f.e.f.e." "0.0.0.0." "0.0.0.0." "1.1.1.1." 230 "a.a.a.a." "0.0.0.0." "0.0.0.0." "0.f.f.f.ip6.arpa"; 231 232 for (i = 0; i < req->nquestions; ++i) { 233 const int qtype = req->questions[i]->type; 234 const int qclass = req->questions[i]->dns_question_class; 235 const char *qname = req->questions[i]->name; 236 237 struct in_addr ans; 238 ans.s_addr = htonl(0xc0a80b0bUL); /* 192.168.11.11 */ 239 if (qtype == EVDNS_TYPE_A && 240 qclass == EVDNS_CLASS_INET && 241 !evutil_ascii_strcasecmp(qname, "zz.example.com")) { 242 r = evdns_server_request_add_a_reply(req, qname, 243 1, &ans.s_addr, 12345); 244 if (r<0) 245 dns_ok = 0; 246 } else if (qtype == EVDNS_TYPE_AAAA && 247 qclass == EVDNS_CLASS_INET && 248 !evutil_ascii_strcasecmp(qname, "zz.example.com")) { 249 char addr6[17] = "abcdefghijklmnop"; 250 r = evdns_server_request_add_aaaa_reply(req, 251 qname, 1, addr6, 123); 252 if (r<0) 253 dns_ok = 0; 254 } else if (qtype == EVDNS_TYPE_PTR && 255 qclass == EVDNS_CLASS_INET && 256 !evutil_ascii_strcasecmp(qname, TEST_ARPA)) { 257 r = evdns_server_request_add_ptr_reply(req, NULL, 258 qname, "ZZ.EXAMPLE.COM", 54321); 259 if (r<0) 260 dns_ok = 0; 261 } else if (qtype == EVDNS_TYPE_PTR && 262 qclass == EVDNS_CLASS_INET && 263 !evutil_ascii_strcasecmp(qname, TEST_IN6)){ 264 r = evdns_server_request_add_ptr_reply(req, NULL, 265 qname, 266 "ZZ-INET6.EXAMPLE.COM", 54322); 267 if (r<0) 268 dns_ok = 0; 269 } else if (qtype == EVDNS_TYPE_A && 270 qclass == EVDNS_CLASS_INET && 271 !evutil_ascii_strcasecmp(qname, "drop.example.com")) { 272 if (evdns_server_request_drop(req)<0) 273 dns_ok = 0; 274 return; 275 } else { 276 printf("Unexpected question %d %d \"%s\" ", 277 qtype, qclass, qname); 278 dns_ok = 0; 279 } 280 } 281 r = evdns_server_request_respond(req, 0); 282 if (r<0) { 283 printf("Couldn't send reply. "); 284 dns_ok = 0; 285 } 286 } 287 288 static void 289 dns_server_gethostbyname_cb(int result, char type, int count, int ttl, 290 void *addresses, void *arg) 291 { 292 if (result == DNS_ERR_CANCEL) { 293 if (arg != (void*)(char*)90909) { 294 printf("Unexpected cancelation"); 295 dns_ok = 0; 296 } 297 dns_got_cancel = 1; 298 goto out; 299 } 300 if (result != DNS_ERR_NONE) { 301 printf("Unexpected result %d. ", result); 302 dns_ok = 0; 303 goto out; 304 } 305 if (count != 1) { 306 printf("Unexpected answer count %d. ", count); 307 dns_ok = 0; 308 goto out; 309 } 310 switch (type) { 311 case DNS_IPv4_A: { 312 struct in_addr *in_addrs = addresses; 313 if (in_addrs[0].s_addr != htonl(0xc0a80b0bUL) || ttl != 12345) { 314 printf("Bad IPv4 response \"%s\" %d. ", 315 inet_ntoa(in_addrs[0]), ttl); 316 dns_ok = 0; 317 goto out; 318 } 319 break; 320 } 321 case DNS_IPv6_AAAA: { 322 #if defined (EVENT__HAVE_STRUCT_IN6_ADDR) && defined(EVENT__HAVE_INET_NTOP) && defined(INET6_ADDRSTRLEN) 323 struct in6_addr *in6_addrs = addresses; 324 char buf[INET6_ADDRSTRLEN+1]; 325 if (memcmp(&in6_addrs[0].s6_addr, "abcdefghijklmnop", 16) 326 || ttl != 123) { 327 const char *b = evutil_inet_ntop(AF_INET6, &in6_addrs[0],buf,sizeof(buf)); 328 printf("Bad IPv6 response \"%s\" %d. ", b, ttl); 329 dns_ok = 0; 330 goto out; 331 } 332 #endif 333 break; 334 } 335 case DNS_PTR: { 336 char **addrs = addresses; 337 if (arg != (void*)6) { 338 if (strcmp(addrs[0], "ZZ.EXAMPLE.COM") || 339 ttl != 54321) { 340 printf("Bad PTR response \"%s\" %d. ", 341 addrs[0], ttl); 342 dns_ok = 0; 343 goto out; 344 } 345 } else { 346 if (strcmp(addrs[0], "ZZ-INET6.EXAMPLE.COM") || 347 ttl != 54322) { 348 printf("Bad ipv6 PTR response \"%s\" %d. ", 349 addrs[0], ttl); 350 dns_ok = 0; 351 goto out; 352 } 353 } 354 break; 355 } 356 default: 357 printf("Bad response type %d. ", type); 358 dns_ok = 0; 359 } 360 out: 361 if (++n_server_responses == 3) { 362 event_loopexit(NULL); 363 } 364 } 365 366 static void 367 dns_server(void) 368 { 369 evutil_socket_t sock=-1; 370 struct sockaddr_in my_addr; 371 struct sockaddr_storage ss; 372 ev_socklen_t slen; 373 struct evdns_server_port *port=NULL; 374 struct in_addr resolve_addr; 375 struct in6_addr resolve_addr6; 376 struct evdns_base *base=NULL; 377 struct evdns_request *req=NULL; 378 379 dns_ok = 1; 380 381 base = evdns_base_new(NULL, 0); 382 383 /* Now configure a nameserver port. */ 384 sock = socket(AF_INET, SOCK_DGRAM, 0); 385 if (sock<0) { 386 tt_abort_perror("socket"); 387 } 388 389 evutil_make_socket_nonblocking(sock); 390 391 memset(&my_addr, 0, sizeof(my_addr)); 392 my_addr.sin_family = AF_INET; 393 my_addr.sin_port = 0; /* kernel picks */ 394 my_addr.sin_addr.s_addr = htonl(0x7f000001UL); 395 if (bind(sock, (struct sockaddr*)&my_addr, sizeof(my_addr)) < 0) { 396 tt_abort_perror("bind"); 397 } 398 slen = sizeof(ss); 399 if (getsockname(sock, (struct sockaddr*)&ss, &slen) < 0) { 400 tt_abort_perror("getsockname"); 401 } 402 403 port = evdns_add_server_port(sock, 0, dns_server_request_cb, NULL); 404 405 /* Add ourself as the only nameserver, and make sure we really are 406 * the only nameserver. */ 407 evdns_base_nameserver_sockaddr_add(base, (struct sockaddr*)&ss, slen, 0); 408 tt_int_op(evdns_base_count_nameservers(base), ==, 1); 409 { 410 struct sockaddr_storage ss2; 411 int slen2; 412 413 memset(&ss2, 0, sizeof(ss2)); 414 415 slen2 = evdns_base_get_nameserver_addr(base, 0, (struct sockaddr *)&ss2, 3); 416 tt_int_op(slen2, ==, slen); 417 tt_int_op(ss2.ss_family, ==, 0); 418 slen2 = evdns_base_get_nameserver_addr(base, 0, (struct sockaddr *)&ss2, sizeof(ss2)); 419 tt_int_op(slen2, ==, slen); 420 tt_mem_op(&ss2, ==, &ss, slen); 421 422 slen2 = evdns_base_get_nameserver_addr(base, 1, (struct sockaddr *)&ss2, sizeof(ss2)); 423 tt_int_op(-1, ==, slen2); 424 } 425 426 /* Send some queries. */ 427 evdns_base_resolve_ipv4(base, "zz.example.com", DNS_QUERY_NO_SEARCH, 428 dns_server_gethostbyname_cb, NULL); 429 evdns_base_resolve_ipv6(base, "zz.example.com", DNS_QUERY_NO_SEARCH, 430 dns_server_gethostbyname_cb, NULL); 431 resolve_addr.s_addr = htonl(0xc0a80b0bUL); /* 192.168.11.11 */ 432 evdns_base_resolve_reverse(base, &resolve_addr, 0, 433 dns_server_gethostbyname_cb, NULL); 434 memcpy(resolve_addr6.s6_addr, 435 "\xff\xf0\x00\x00\x00\x00\xaa\xaa" 436 "\x11\x11\x00\x00\x00\x00\xef\xef", 16); 437 evdns_base_resolve_reverse_ipv6(base, &resolve_addr6, 0, 438 dns_server_gethostbyname_cb, (void*)6); 439 440 req = evdns_base_resolve_ipv4(base, 441 "drop.example.com", DNS_QUERY_NO_SEARCH, 442 dns_server_gethostbyname_cb, (void*)(char*)90909); 443 444 evdns_cancel_request(base, req); 445 446 event_dispatch(); 447 448 tt_assert(dns_got_cancel); 449 test_ok = dns_ok; 450 451 end: 452 if (port) 453 evdns_close_server_port(port); 454 if (sock >= 0) 455 evutil_closesocket(sock); 456 if (base) 457 evdns_base_free(base, 0); 458 } 459 460 static int n_replies_left; 461 static struct event_base *exit_base; 462 static struct evdns_server_port *exit_port; 463 464 struct generic_dns_callback_result { 465 int result; 466 char type; 467 int count; 468 int ttl; 469 size_t addrs_len; 470 void *addrs; 471 char addrs_buf[256]; 472 }; 473 474 static void 475 generic_dns_callback(int result, char type, int count, int ttl, void *addresses, 476 void *arg) 477 { 478 size_t len; 479 struct generic_dns_callback_result *res = arg; 480 res->result = result; 481 res->type = type; 482 res->count = count; 483 res->ttl = ttl; 484 485 if (type == DNS_IPv4_A) 486 len = count * 4; 487 else if (type == DNS_IPv6_AAAA) 488 len = count * 16; 489 else if (type == DNS_PTR) 490 len = strlen(addresses)+1; 491 else { 492 res->addrs_len = len = 0; 493 res->addrs = NULL; 494 } 495 if (len) { 496 res->addrs_len = len; 497 if (len > 256) 498 len = 256; 499 memcpy(res->addrs_buf, addresses, len); 500 res->addrs = res->addrs_buf; 501 } 502 503 --n_replies_left; 504 if (n_replies_left == 0) { 505 if (exit_port) { 506 evdns_close_server_port(exit_port); 507 exit_port = NULL; 508 } else 509 event_base_loopexit(exit_base, NULL); 510 } 511 } 512 513 static struct regress_dns_server_table search_table[] = { 514 { "host.a.example.com", "err", "3", 0 }, 515 { "host.b.example.com", "err", "3", 0 }, 516 { "host.c.example.com", "A", "11.22.33.44", 0 }, 517 { "host2.a.example.com", "err", "3", 0 }, 518 { "host2.b.example.com", "A", "200.100.0.100", 0 }, 519 { "host2.c.example.com", "err", "3", 0 }, 520 { "hostn.a.example.com", "errsoa", "0", 0 }, 521 { "hostn.b.example.com", "errsoa", "3", 0 }, 522 { "hostn.c.example.com", "err", "0", 0 }, 523 524 { "host", "err", "3", 0 }, 525 { "host2", "err", "3", 0 }, 526 { "*", "err", "3", 0 }, 527 { NULL, NULL, NULL, 0 } 528 }; 529 530 static void 531 dns_search_test(void *arg) 532 { 533 struct basic_test_data *data = arg; 534 struct event_base *base = data->base; 535 struct evdns_base *dns = NULL; 536 ev_uint16_t portnum = 0; 537 char buf[64]; 538 539 struct generic_dns_callback_result r[8]; 540 541 tt_assert(regress_dnsserver(base, &portnum, search_table)); 542 evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)portnum); 543 544 dns = evdns_base_new(base, 0); 545 tt_assert(!evdns_base_nameserver_ip_add(dns, buf)); 546 547 evdns_base_search_add(dns, "a.example.com"); 548 evdns_base_search_add(dns, "b.example.com"); 549 evdns_base_search_add(dns, "c.example.com"); 550 551 n_replies_left = sizeof(r)/sizeof(r[0]); 552 exit_base = base; 553 554 evdns_base_resolve_ipv4(dns, "host", 0, generic_dns_callback, &r[0]); 555 evdns_base_resolve_ipv4(dns, "host2", 0, generic_dns_callback, &r[1]); 556 evdns_base_resolve_ipv4(dns, "host", DNS_NO_SEARCH, generic_dns_callback, &r[2]); 557 evdns_base_resolve_ipv4(dns, "host2", DNS_NO_SEARCH, generic_dns_callback, &r[3]); 558 evdns_base_resolve_ipv4(dns, "host3", 0, generic_dns_callback, &r[4]); 559 evdns_base_resolve_ipv4(dns, "hostn.a.example.com", DNS_NO_SEARCH, generic_dns_callback, &r[5]); 560 evdns_base_resolve_ipv4(dns, "hostn.b.example.com", DNS_NO_SEARCH, generic_dns_callback, &r[6]); 561 evdns_base_resolve_ipv4(dns, "hostn.c.example.com", DNS_NO_SEARCH, generic_dns_callback, &r[7]); 562 563 event_base_dispatch(base); 564 565 tt_int_op(r[0].type, ==, DNS_IPv4_A); 566 tt_int_op(r[0].count, ==, 1); 567 tt_int_op(((ev_uint32_t*)r[0].addrs)[0], ==, htonl(0x0b16212c)); 568 tt_int_op(r[1].type, ==, DNS_IPv4_A); 569 tt_int_op(r[1].count, ==, 1); 570 tt_int_op(((ev_uint32_t*)r[1].addrs)[0], ==, htonl(0xc8640064)); 571 tt_int_op(r[2].result, ==, DNS_ERR_NOTEXIST); 572 tt_int_op(r[3].result, ==, DNS_ERR_NOTEXIST); 573 tt_int_op(r[4].result, ==, DNS_ERR_NOTEXIST); 574 tt_int_op(r[5].result, ==, DNS_ERR_NODATA); 575 tt_int_op(r[5].ttl, ==, 42); 576 tt_int_op(r[6].result, ==, DNS_ERR_NOTEXIST); 577 tt_int_op(r[6].ttl, ==, 42); 578 tt_int_op(r[7].result, ==, DNS_ERR_NODATA); 579 tt_int_op(r[7].ttl, ==, 0); 580 581 end: 582 if (dns) 583 evdns_base_free(dns, 0); 584 585 regress_clean_dnsserver(); 586 } 587 588 static int request_count = 0; 589 static struct evdns_request *current_req = NULL; 590 591 static void 592 search_cancel_server_cb(struct evdns_server_request *req, void *data) 593 { 594 const char *question; 595 596 if (req->nquestions != 1) 597 TT_DIE(("Only handling one question at a time; got %d", 598 req->nquestions)); 599 600 question = req->questions[0]->name; 601 602 TT_BLATHER(("got question, %s", question)); 603 604 tt_assert(request_count > 0); 605 tt_assert(!evdns_server_request_respond(req, 3)); 606 607 if (!--request_count) 608 evdns_cancel_request(NULL, current_req); 609 610 end: 611 ; 612 } 613 614 static void 615 dns_search_cancel_test(void *arg) 616 { 617 struct basic_test_data *data = arg; 618 struct event_base *base = data->base; 619 struct evdns_base *dns = NULL; 620 struct evdns_server_port *port = NULL; 621 ev_uint16_t portnum = 0; 622 struct generic_dns_callback_result r1; 623 char buf[64]; 624 625 port = regress_get_dnsserver(base, &portnum, NULL, 626 search_cancel_server_cb, NULL); 627 tt_assert(port); 628 evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)portnum); 629 630 dns = evdns_base_new(base, 0); 631 tt_assert(!evdns_base_nameserver_ip_add(dns, buf)); 632 633 evdns_base_search_add(dns, "a.example.com"); 634 evdns_base_search_add(dns, "b.example.com"); 635 evdns_base_search_add(dns, "c.example.com"); 636 evdns_base_search_add(dns, "d.example.com"); 637 638 exit_base = base; 639 request_count = 3; 640 n_replies_left = 1; 641 642 current_req = evdns_base_resolve_ipv4(dns, "host", 0, 643 generic_dns_callback, &r1); 644 event_base_dispatch(base); 645 646 tt_int_op(r1.result, ==, DNS_ERR_CANCEL); 647 648 end: 649 if (port) 650 evdns_close_server_port(port); 651 if (dns) 652 evdns_base_free(dns, 0); 653 } 654 655 static void 656 fail_server_cb(struct evdns_server_request *req, void *data) 657 { 658 const char *question; 659 int *count = data; 660 struct in_addr in; 661 662 /* Drop the first N requests that we get. */ 663 if (*count > 0) { 664 --*count; 665 tt_want(! evdns_server_request_drop(req)); 666 return; 667 } 668 669 if (req->nquestions != 1) 670 TT_DIE(("Only handling one question at a time; got %d", 671 req->nquestions)); 672 673 question = req->questions[0]->name; 674 675 if (!evutil_ascii_strcasecmp(question, "google.com")) { 676 /* Detect a probe, and get out of the loop. */ 677 event_base_loopexit(exit_base, NULL); 678 } 679 680 tt_assert(evutil_inet_pton(AF_INET, "16.32.64.128", &in)); 681 evdns_server_request_add_a_reply(req, question, 1, &in.s_addr, 682 100); 683 tt_assert(! evdns_server_request_respond(req, 0)) 684 return; 685 end: 686 tt_want(! evdns_server_request_drop(req)); 687 } 688 689 static void 690 dns_retry_test_impl(void *arg, int flags) 691 { 692 struct basic_test_data *data = arg; 693 struct event_base *base = data->base; 694 struct evdns_server_port *port = NULL; 695 struct evdns_base *dns = NULL; 696 int drop_count = 2; 697 ev_uint16_t portnum = 0; 698 char buf[64]; 699 700 struct generic_dns_callback_result r1; 701 702 port = regress_get_dnsserver(base, &portnum, NULL, 703 fail_server_cb, &drop_count); 704 tt_assert(port); 705 evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)portnum); 706 707 dns = evdns_base_new(base, flags); 708 tt_assert(!evdns_base_nameserver_ip_add(dns, buf)); 709 tt_assert(! evdns_base_set_option(dns, "timeout", "0.2")); 710 tt_assert(! evdns_base_set_option(dns, "max-timeouts:", "10")); 711 tt_assert(! evdns_base_set_option(dns, "initial-probe-timeout", "0.1")); 712 713 evdns_base_resolve_ipv4(dns, "host.example.com", 0, 714 generic_dns_callback, &r1); 715 716 n_replies_left = 1; 717 exit_base = base; 718 719 event_base_dispatch(base); 720 721 tt_int_op(drop_count, ==, 0); 722 723 tt_int_op(r1.type, ==, DNS_IPv4_A); 724 tt_int_op(r1.count, ==, 1); 725 tt_int_op(((ev_uint32_t*)r1.addrs)[0], ==, htonl(0x10204080)); 726 727 /* Now try again, but this time have the server get treated as 728 * failed, so we can send it a test probe. */ 729 drop_count = 4; 730 tt_assert(! evdns_base_set_option(dns, "max-timeouts:", "2")); 731 tt_assert(! evdns_base_set_option(dns, "attempts:", "3")); 732 memset(&r1, 0, sizeof(r1)); 733 734 evdns_base_resolve_ipv4(dns, "host.example.com", 0, 735 generic_dns_callback, &r1); 736 737 n_replies_left = 2; 738 739 /* This will run until it answers the "google.com" probe request. */ 740 event_base_dispatch(base); 741 742 /* We'll treat the server as failed here. */ 743 tt_int_op(r1.result, ==, DNS_ERR_TIMEOUT); 744 745 /* It should work this time. */ 746 tt_int_op(drop_count, ==, 0); 747 evdns_base_resolve_ipv4(dns, "host.example.com", 0, 748 generic_dns_callback, &r1); 749 750 event_base_dispatch(base); 751 tt_int_op(r1.result, ==, DNS_ERR_NONE); 752 tt_int_op(r1.type, ==, DNS_IPv4_A); 753 tt_int_op(r1.count, ==, 1); 754 tt_int_op(((ev_uint32_t*)r1.addrs)[0], ==, htonl(0x10204080)); 755 756 end: 757 if (dns) 758 evdns_base_free(dns, 0); 759 if (port) 760 evdns_close_server_port(port); 761 } 762 static void 763 dns_retry_test(void *arg) 764 { 765 dns_retry_test_impl(arg, 0); 766 } 767 static void 768 dns_retry_disable_when_inactive_test(void *arg) 769 { 770 dns_retry_test_impl(arg, EVDNS_BASE_DISABLE_WHEN_INACTIVE); 771 } 772 773 static struct regress_dns_server_table internal_error_table[] = { 774 /* Error 4 (NOTIMPL) makes us reissue the request to another server 775 if we can. 776 777 XXXX we should reissue under a much wider set of circumstances! 778 */ 779 { "foof.example.com", "err", "4", 0 }, 780 { NULL, NULL, NULL, 0 } 781 }; 782 783 static struct regress_dns_server_table reissue_table[] = { 784 { "foof.example.com", "A", "240.15.240.15", 0 }, 785 { NULL, NULL, NULL, 0 } 786 }; 787 788 static void 789 dns_reissue_test_impl(void *arg, int flags) 790 { 791 struct basic_test_data *data = arg; 792 struct event_base *base = data->base; 793 struct evdns_server_port *port1 = NULL, *port2 = NULL; 794 struct evdns_base *dns = NULL; 795 struct generic_dns_callback_result r1; 796 ev_uint16_t portnum1 = 0, portnum2=0; 797 char buf1[64], buf2[64]; 798 799 port1 = regress_get_dnsserver(base, &portnum1, NULL, 800 regress_dns_server_cb, internal_error_table); 801 tt_assert(port1); 802 port2 = regress_get_dnsserver(base, &portnum2, NULL, 803 regress_dns_server_cb, reissue_table); 804 tt_assert(port2); 805 evutil_snprintf(buf1, sizeof(buf1), "127.0.0.1:%d", (int)portnum1); 806 evutil_snprintf(buf2, sizeof(buf2), "127.0.0.1:%d", (int)portnum2); 807 808 dns = evdns_base_new(base, flags); 809 tt_assert(!evdns_base_nameserver_ip_add(dns, buf1)); 810 tt_assert(! evdns_base_set_option(dns, "timeout:", "0.3")); 811 tt_assert(! evdns_base_set_option(dns, "max-timeouts:", "2")); 812 tt_assert(! evdns_base_set_option(dns, "attempts:", "5")); 813 814 memset(&r1, 0, sizeof(r1)); 815 evdns_base_resolve_ipv4(dns, "foof.example.com", 0, 816 generic_dns_callback, &r1); 817 818 /* Add this after, so that we are sure to get a reissue. */ 819 tt_assert(!evdns_base_nameserver_ip_add(dns, buf2)); 820 821 n_replies_left = 1; 822 exit_base = base; 823 824 event_base_dispatch(base); 825 tt_int_op(r1.result, ==, DNS_ERR_NONE); 826 tt_int_op(r1.type, ==, DNS_IPv4_A); 827 tt_int_op(r1.count, ==, 1); 828 tt_int_op(((ev_uint32_t*)r1.addrs)[0], ==, htonl(0xf00ff00f)); 829 830 /* Make sure we dropped at least once. */ 831 tt_int_op(internal_error_table[0].seen, >, 0); 832 833 end: 834 if (dns) 835 evdns_base_free(dns, 0); 836 if (port1) 837 evdns_close_server_port(port1); 838 if (port2) 839 evdns_close_server_port(port2); 840 } 841 static void 842 dns_reissue_test(void *arg) 843 { 844 dns_reissue_test_impl(arg, 0); 845 } 846 static void 847 dns_reissue_disable_when_inactive_test(void *arg) 848 { 849 dns_reissue_test_impl(arg, EVDNS_BASE_DISABLE_WHEN_INACTIVE); 850 } 851 852 #if 0 853 static void 854 dumb_bytes_fn(char *p, size_t n) 855 { 856 unsigned i; 857 /* This gets us 6 bits of entropy per transaction ID, which means we 858 * will have probably have collisions and need to pick again. */ 859 for (i=0;i<n;++i) 860 p[i] = (char)(rand() & 7); 861 } 862 #endif 863 864 static void 865 dns_inflight_test_impl(void *arg, int flags) 866 { 867 struct basic_test_data *data = arg; 868 struct event_base *base = data->base; 869 struct evdns_base *dns = NULL; 870 struct evdns_server_port *dns_port = NULL; 871 ev_uint16_t portnum = 0; 872 char buf[64]; 873 int disable_when_inactive = flags & EVDNS_BASE_DISABLE_WHEN_INACTIVE; 874 875 struct generic_dns_callback_result r[20]; 876 int i; 877 878 dns_port = regress_get_dnsserver(base, &portnum, NULL, 879 regress_dns_server_cb, reissue_table); 880 tt_assert(dns_port); 881 if (disable_when_inactive) { 882 exit_port = dns_port; 883 } 884 885 evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)portnum); 886 887 dns = evdns_base_new(base, flags); 888 tt_assert(!evdns_base_nameserver_ip_add(dns, buf)); 889 tt_assert(! evdns_base_set_option(dns, "max-inflight:", "3")); 890 tt_assert(! evdns_base_set_option(dns, "randomize-case:", "0")); 891 892 for (i=0;i<20;++i) 893 evdns_base_resolve_ipv4(dns, "foof.example.com", 0, generic_dns_callback, &r[i]); 894 895 n_replies_left = 20; 896 exit_base = base; 897 898 event_base_dispatch(base); 899 900 for (i=0;i<20;++i) { 901 tt_int_op(r[i].type, ==, DNS_IPv4_A); 902 tt_int_op(r[i].count, ==, 1); 903 tt_int_op(((ev_uint32_t*)r[i].addrs)[0], ==, htonl(0xf00ff00f)); 904 } 905 906 end: 907 if (dns) 908 evdns_base_free(dns, 0); 909 if (exit_port) { 910 evdns_close_server_port(exit_port); 911 exit_port = NULL; 912 } else if (! disable_when_inactive) { 913 evdns_close_server_port(dns_port); 914 } 915 } 916 917 static void 918 dns_inflight_test(void *arg) 919 { 920 dns_inflight_test_impl(arg, 0); 921 } 922 923 static void 924 dns_disable_when_inactive_test(void *arg) 925 { 926 dns_inflight_test_impl(arg, EVDNS_BASE_DISABLE_WHEN_INACTIVE); 927 } 928 929 static void 930 dns_disable_when_inactive_no_ns_test(void *arg) 931 { 932 struct basic_test_data *data = arg; 933 struct event_base *base = data->base, *inactive_base; 934 struct evdns_base *dns = NULL; 935 ev_uint16_t portnum = 0; 936 char buf[64]; 937 struct generic_dns_callback_result r; 938 939 inactive_base = event_base_new(); 940 tt_assert(inactive_base); 941 942 /** Create dns server with inactive base, to avoid replying to clients */ 943 tt_assert(regress_dnsserver(inactive_base, &portnum, search_table)); 944 evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)portnum); 945 946 dns = evdns_base_new(base, EVDNS_BASE_DISABLE_WHEN_INACTIVE); 947 tt_assert(!evdns_base_nameserver_ip_add(dns, buf)); 948 tt_assert(! evdns_base_set_option(dns, "timeout:", "0.1")); 949 950 evdns_base_resolve_ipv4(dns, "foof.example.com", 0, generic_dns_callback, &r); 951 n_replies_left = 1; 952 exit_base = base; 953 954 event_base_dispatch(base); 955 956 tt_int_op(n_replies_left, ==, 0); 957 958 tt_int_op(r.result, ==, DNS_ERR_TIMEOUT); 959 tt_int_op(r.count, ==, 0); 960 tt_ptr_op(r.addrs, ==, NULL); 961 962 end: 963 if (dns) 964 evdns_base_free(dns, 0); 965 regress_clean_dnsserver(); 966 if (inactive_base) 967 event_base_free(inactive_base); 968 } 969 970 /* === Test for bufferevent_socket_connect_hostname */ 971 972 static int total_connected_or_failed = 0; 973 static int total_n_accepted = 0; 974 static struct event_base *be_connect_hostname_base = NULL; 975 976 /* Implements a DNS server for the connect_hostname test and the 977 * getaddrinfo_async test */ 978 static void 979 be_getaddrinfo_server_cb(struct evdns_server_request *req, void *data) 980 { 981 int i; 982 int *n_got_p=data; 983 int added_any=0; 984 ++*n_got_p; 985 986 for (i=0;i<req->nquestions;++i) { 987 const int qtype = req->questions[i]->type; 988 const int qclass = req->questions[i]->dns_question_class; 989 const char *qname = req->questions[i]->name; 990 struct in_addr ans; 991 struct in6_addr ans6; 992 memset(&ans6, 0, sizeof(ans6)); 993 994 TT_BLATHER(("Got question about %s, type=%d", qname, qtype)); 995 996 if (qtype == EVDNS_TYPE_A && 997 qclass == EVDNS_CLASS_INET && 998 !evutil_ascii_strcasecmp(qname, "nobodaddy.example.com")) { 999 ans.s_addr = htonl(0x7f000001); 1000 evdns_server_request_add_a_reply(req, qname, 1001 1, &ans.s_addr, 2000); 1002 added_any = 1; 1003 } else if (!evutil_ascii_strcasecmp(qname, 1004 "nosuchplace.example.com")) { 1005 /* ok, just say notfound. */ 1006 } else if (!evutil_ascii_strcasecmp(qname, 1007 "both.example.com")) { 1008 if (qtype == EVDNS_TYPE_A) { 1009 ans.s_addr = htonl(0x50502020); 1010 evdns_server_request_add_a_reply(req, qname, 1011 1, &ans.s_addr, 2000); 1012 added_any = 1; 1013 } else if (qtype == EVDNS_TYPE_AAAA) { 1014 ans6.s6_addr[0] = 0x80; 1015 ans6.s6_addr[1] = 0xff; 1016 ans6.s6_addr[14] = 0xbb; 1017 ans6.s6_addr[15] = 0xbb; 1018 evdns_server_request_add_aaaa_reply(req, qname, 1019 1, &ans6.s6_addr, 2000); 1020 added_any = 1; 1021 } 1022 evdns_server_request_add_cname_reply(req, qname, 1023 "both-canonical.example.com", 1000); 1024 } else if (!evutil_ascii_strcasecmp(qname, 1025 "v4only.example.com") || 1026 !evutil_ascii_strcasecmp(qname, "v4assert.example.com")) { 1027 if (qtype == EVDNS_TYPE_A) { 1028 ans.s_addr = htonl(0x12345678); 1029 evdns_server_request_add_a_reply(req, qname, 1030 1, &ans.s_addr, 2000); 1031 added_any = 1; 1032 } else if (!evutil_ascii_strcasecmp(qname, 1033 "v4assert.example.com")) { 1034 TT_FAIL(("Got an AAAA request for v4assert")); 1035 } 1036 } else if (!evutil_ascii_strcasecmp(qname, 1037 "v6only.example.com") || 1038 !evutil_ascii_strcasecmp(qname, "v6assert.example.com")) { 1039 if (qtype == EVDNS_TYPE_AAAA) { 1040 ans6.s6_addr[0] = 0x0b; 1041 ans6.s6_addr[1] = 0x0b; 1042 ans6.s6_addr[14] = 0xf0; 1043 ans6.s6_addr[15] = 0x0d; 1044 evdns_server_request_add_aaaa_reply(req, qname, 1045 1, &ans6.s6_addr, 2000); 1046 added_any = 1; 1047 } else if (!evutil_ascii_strcasecmp(qname, 1048 "v6assert.example.com")) { 1049 TT_FAIL(("Got a A request for v6assert")); 1050 } 1051 } else if (!evutil_ascii_strcasecmp(qname, 1052 "v6timeout.example.com")) { 1053 if (qtype == EVDNS_TYPE_A) { 1054 ans.s_addr = htonl(0xabcdef01); 1055 evdns_server_request_add_a_reply(req, qname, 1056 1, &ans.s_addr, 2000); 1057 added_any = 1; 1058 } else if (qtype == EVDNS_TYPE_AAAA) { 1059 /* Let the v6 request time out.*/ 1060 evdns_server_request_drop(req); 1061 return; 1062 } 1063 } else if (!evutil_ascii_strcasecmp(qname, 1064 "v4timeout.example.com")) { 1065 if (qtype == EVDNS_TYPE_AAAA) { 1066 ans6.s6_addr[0] = 0x0a; 1067 ans6.s6_addr[1] = 0x0a; 1068 ans6.s6_addr[14] = 0xff; 1069 ans6.s6_addr[15] = 0x01; 1070 evdns_server_request_add_aaaa_reply(req, qname, 1071 1, &ans6.s6_addr, 2000); 1072 added_any = 1; 1073 } else if (qtype == EVDNS_TYPE_A) { 1074 /* Let the v4 request time out.*/ 1075 evdns_server_request_drop(req); 1076 return; 1077 } 1078 } else if (!evutil_ascii_strcasecmp(qname, 1079 "v6timeout-nonexist.example.com")) { 1080 if (qtype == EVDNS_TYPE_A) { 1081 /* Fall through, give an nexist. */ 1082 } else if (qtype == EVDNS_TYPE_AAAA) { 1083 /* Let the v6 request time out.*/ 1084 evdns_server_request_drop(req); 1085 return; 1086 } 1087 } else if (!evutil_ascii_strcasecmp(qname, 1088 "all-timeout.example.com")) { 1089 /* drop all requests */ 1090 evdns_server_request_drop(req); 1091 return; 1092 } else { 1093 TT_GRIPE(("Got weird request for %s",qname)); 1094 } 1095 } 1096 if (added_any) { 1097 TT_BLATHER(("answering")); 1098 evdns_server_request_respond(req, 0); 1099 } else { 1100 TT_BLATHER(("saying nexist.")); 1101 evdns_server_request_respond(req, 3); 1102 } 1103 } 1104 1105 /* Implements a listener for connect_hostname test. */ 1106 static void 1107 nil_accept_cb(struct evconnlistener *l, evutil_socket_t fd, struct sockaddr *s, 1108 int socklen, void *arg) 1109 { 1110 int *p = arg; 1111 (*p)++; 1112 ++total_n_accepted; 1113 /* don't do anything with the socket; let it close when we exit() */ 1114 if (total_n_accepted >= 3 && total_connected_or_failed >= 5) 1115 event_base_loopexit(be_connect_hostname_base, 1116 NULL); 1117 } 1118 1119 struct be_conn_hostname_result { 1120 int dnserr; 1121 int what; 1122 }; 1123 1124 /* Bufferevent event callback for the connect_hostname test: remembers what 1125 * event we got. */ 1126 static void 1127 be_connect_hostname_event_cb(struct bufferevent *bev, short what, void *ctx) 1128 { 1129 struct be_conn_hostname_result *got = ctx; 1130 if (!got->what) { 1131 TT_BLATHER(("Got a bufferevent event %d", what)); 1132 got->what = what; 1133 1134 if ((what & BEV_EVENT_CONNECTED) || (what & BEV_EVENT_ERROR)) { 1135 int r; 1136 if ((r = bufferevent_socket_get_dns_error(bev))) { 1137 got->dnserr = r; 1138 TT_BLATHER(("DNS error %d: %s", r, 1139 evutil_gai_strerror(r))); 1140 } ++total_connected_or_failed; 1141 TT_BLATHER(("Got %d connections or errors.", total_connected_or_failed)); 1142 1143 if (total_n_accepted >= 3 && total_connected_or_failed >= 5) 1144 event_base_loopexit(be_connect_hostname_base, 1145 NULL); 1146 } 1147 } else { 1148 TT_FAIL(("Two events on one bufferevent. %d,%d", 1149 got->what, (int)what)); 1150 } 1151 } 1152 1153 static void 1154 test_bufferevent_connect_hostname(void *arg) 1155 { 1156 struct basic_test_data *data = arg; 1157 struct evconnlistener *listener = NULL; 1158 struct bufferevent *be1=NULL, *be2=NULL, *be3=NULL, *be4=NULL, *be5=NULL; 1159 struct be_conn_hostname_result be1_outcome={0,0}, be2_outcome={0,0}, 1160 be3_outcome={0,0}, be4_outcome={0,0}, be5_outcome={0,0}; 1161 int expect_err5; 1162 struct evdns_base *dns=NULL; 1163 struct evdns_server_port *port=NULL; 1164 struct sockaddr_in sin; 1165 int listener_port=-1; 1166 ev_uint16_t dns_port=0; 1167 int n_accept=0, n_dns=0; 1168 char buf[128]; 1169 1170 be_connect_hostname_base = data->base; 1171 1172 /* Bind an address and figure out what port it's on. */ 1173 memset(&sin, 0, sizeof(sin)); 1174 sin.sin_family = AF_INET; 1175 sin.sin_addr.s_addr = htonl(0x7f000001); /* 127.0.0.1 */ 1176 sin.sin_port = 0; 1177 listener = evconnlistener_new_bind(data->base, nil_accept_cb, 1178 &n_accept, 1179 LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_EXEC, 1180 -1, (struct sockaddr *)&sin, sizeof(sin)); 1181 tt_assert(listener); 1182 listener_port = regress_get_socket_port( 1183 evconnlistener_get_fd(listener)); 1184 1185 port = regress_get_dnsserver(data->base, &dns_port, NULL, 1186 be_getaddrinfo_server_cb, &n_dns); 1187 tt_assert(port); 1188 tt_int_op(dns_port, >=, 0); 1189 1190 /* Start an evdns_base that uses the server as its resolver. */ 1191 dns = evdns_base_new(data->base, 0); 1192 evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)dns_port); 1193 evdns_base_nameserver_ip_add(dns, buf); 1194 1195 /* Now, finally, at long last, launch the bufferevents. One should do 1196 * a failing lookup IP, one should do a successful lookup by IP, 1197 * and one should do a successful lookup by hostname. */ 1198 be1 = bufferevent_socket_new(data->base, -1, BEV_OPT_CLOSE_ON_FREE); 1199 be2 = bufferevent_socket_new(data->base, -1, BEV_OPT_CLOSE_ON_FREE); 1200 be3 = bufferevent_socket_new(data->base, -1, BEV_OPT_CLOSE_ON_FREE); 1201 be4 = bufferevent_socket_new(data->base, -1, BEV_OPT_CLOSE_ON_FREE); 1202 be5 = bufferevent_socket_new(data->base, -1, BEV_OPT_CLOSE_ON_FREE); 1203 1204 bufferevent_setcb(be1, NULL, NULL, be_connect_hostname_event_cb, 1205 &be1_outcome); 1206 bufferevent_setcb(be2, NULL, NULL, be_connect_hostname_event_cb, 1207 &be2_outcome); 1208 bufferevent_setcb(be3, NULL, NULL, be_connect_hostname_event_cb, 1209 &be3_outcome); 1210 bufferevent_setcb(be4, NULL, NULL, be_connect_hostname_event_cb, 1211 &be4_outcome); 1212 bufferevent_setcb(be5, NULL, NULL, be_connect_hostname_event_cb, 1213 &be5_outcome); 1214 1215 /* Launch an async resolve that will fail. */ 1216 tt_assert(!bufferevent_socket_connect_hostname(be1, dns, AF_INET, 1217 "nosuchplace.example.com", listener_port)); 1218 /* Connect to the IP without resolving. */ 1219 tt_assert(!bufferevent_socket_connect_hostname(be2, dns, AF_INET, 1220 "127.0.0.1", listener_port)); 1221 /* Launch an async resolve that will succeed. */ 1222 tt_assert(!bufferevent_socket_connect_hostname(be3, dns, AF_INET, 1223 "nobodaddy.example.com", listener_port)); 1224 /* Use the blocking resolver. This one will fail if your resolver 1225 * can't resolve localhost to 127.0.0.1 */ 1226 tt_assert(!bufferevent_socket_connect_hostname(be4, NULL, AF_INET, 1227 "localhost", listener_port)); 1228 /* Use the blocking resolver with a nonexistent hostname. */ 1229 tt_assert(!bufferevent_socket_connect_hostname(be5, NULL, AF_INET, 1230 "nonesuch.nowhere.example.com", 80)); 1231 { 1232 /* The blocking resolver will use the system nameserver, which 1233 * might tell us anything. (Yes, some twits even pretend that 1234 * example.com is real.) Let's see what answer to expect. */ 1235 struct evutil_addrinfo hints, *ai = NULL; 1236 memset(&hints, 0, sizeof(hints)); 1237 hints.ai_family = AF_INET; 1238 hints.ai_socktype = SOCK_STREAM; 1239 hints.ai_protocol = IPPROTO_TCP; 1240 expect_err5 = evutil_getaddrinfo( 1241 "nonesuch.nowhere.example.com", "80", &hints, &ai); 1242 } 1243 1244 event_base_dispatch(data->base); 1245 1246 tt_int_op(be1_outcome.what, ==, BEV_EVENT_ERROR); 1247 tt_int_op(be1_outcome.dnserr, ==, EVUTIL_EAI_NONAME); 1248 tt_int_op(be2_outcome.what, ==, BEV_EVENT_CONNECTED); 1249 tt_int_op(be2_outcome.dnserr, ==, 0); 1250 tt_int_op(be3_outcome.what, ==, BEV_EVENT_CONNECTED); 1251 tt_int_op(be3_outcome.dnserr, ==, 0); 1252 tt_int_op(be4_outcome.what, ==, BEV_EVENT_CONNECTED); 1253 tt_int_op(be4_outcome.dnserr, ==, 0); 1254 if (expect_err5) { 1255 tt_int_op(be5_outcome.what, ==, BEV_EVENT_ERROR); 1256 tt_int_op(be5_outcome.dnserr, ==, expect_err5); 1257 } 1258 1259 tt_int_op(n_accept, ==, 3); 1260 tt_int_op(n_dns, ==, 2); 1261 1262 end: 1263 if (listener) 1264 evconnlistener_free(listener); 1265 if (port) 1266 evdns_close_server_port(port); 1267 if (dns) 1268 evdns_base_free(dns, 0); 1269 if (be1) 1270 bufferevent_free(be1); 1271 if (be2) 1272 bufferevent_free(be2); 1273 if (be3) 1274 bufferevent_free(be3); 1275 if (be4) 1276 bufferevent_free(be4); 1277 if (be5) 1278 bufferevent_free(be5); 1279 } 1280 1281 1282 struct gai_outcome { 1283 int err; 1284 struct evutil_addrinfo *ai; 1285 }; 1286 1287 static int n_gai_results_pending = 0; 1288 static struct event_base *exit_base_on_no_pending_results = NULL; 1289 1290 static void 1291 gai_cb(int err, struct evutil_addrinfo *res, void *ptr) 1292 { 1293 struct gai_outcome *go = ptr; 1294 go->err = err; 1295 go->ai = res; 1296 if (--n_gai_results_pending <= 0 && exit_base_on_no_pending_results) 1297 event_base_loopexit(exit_base_on_no_pending_results, NULL); 1298 if (n_gai_results_pending < 900) 1299 TT_BLATHER(("Got an answer; expecting %d more.", 1300 n_gai_results_pending)); 1301 } 1302 1303 static void 1304 cancel_gai_cb(evutil_socket_t fd, short what, void *ptr) 1305 { 1306 struct evdns_getaddrinfo_request *r = ptr; 1307 evdns_getaddrinfo_cancel(r); 1308 } 1309 1310 static void 1311 test_getaddrinfo_async(void *arg) 1312 { 1313 struct basic_test_data *data = arg; 1314 struct evutil_addrinfo hints, *a; 1315 struct gai_outcome local_outcome; 1316 struct gai_outcome a_out[12]; 1317 int i; 1318 struct evdns_getaddrinfo_request *r; 1319 char buf[128]; 1320 struct evdns_server_port *port = NULL; 1321 ev_uint16_t dns_port = 0; 1322 int n_dns_questions = 0; 1323 struct evdns_base *dns_base; 1324 1325 memset(&a_out, 0, sizeof(a_out)); 1326 memset(&local_outcome, 0, sizeof(local_outcome)); 1327 1328 dns_base = evdns_base_new(data->base, 0); 1329 tt_assert(dns_base); 1330 1331 /* for localhost */ 1332 evdns_base_load_hosts(dns_base, NULL); 1333 1334 tt_assert(! evdns_base_set_option(dns_base, "timeout", "0.3")); 1335 tt_assert(! evdns_base_set_option(dns_base, "getaddrinfo-allow-skew", "0.2")); 1336 1337 n_gai_results_pending = 10000; /* don't think about exiting yet. */ 1338 1339 /* 1. Try some cases that will never hit the asynchronous resolver. */ 1340 /* 1a. Simple case with a symbolic service name */ 1341 memset(&hints, 0, sizeof(hints)); 1342 hints.ai_family = PF_UNSPEC; 1343 hints.ai_socktype = SOCK_STREAM; 1344 memset(&local_outcome, 0, sizeof(local_outcome)); 1345 r = evdns_getaddrinfo(dns_base, "1.2.3.4", "http", 1346 &hints, gai_cb, &local_outcome); 1347 tt_assert(! r); 1348 if (!local_outcome.err) { 1349 tt_ptr_op(local_outcome.ai,!=,NULL); 1350 test_ai_eq(local_outcome.ai, "1.2.3.4:80", SOCK_STREAM, IPPROTO_TCP); 1351 evutil_freeaddrinfo(local_outcome.ai); 1352 local_outcome.ai = NULL; 1353 } else { 1354 TT_BLATHER(("Apparently we have no getservbyname.")); 1355 } 1356 1357 /* 1b. EVUTIL_AI_NUMERICHOST is set */ 1358 memset(&hints, 0, sizeof(hints)); 1359 hints.ai_family = PF_UNSPEC; 1360 hints.ai_flags = EVUTIL_AI_NUMERICHOST; 1361 memset(&local_outcome, 0, sizeof(local_outcome)); 1362 r = evdns_getaddrinfo(dns_base, "www.google.com", "80", 1363 &hints, gai_cb, &local_outcome); 1364 tt_ptr_op(r,==,NULL); 1365 tt_int_op(local_outcome.err,==,EVUTIL_EAI_NONAME); 1366 tt_ptr_op(local_outcome.ai,==,NULL); 1367 1368 /* 1c. We give a numeric address (ipv6) */ 1369 memset(&hints, 0, sizeof(hints)); 1370 memset(&local_outcome, 0, sizeof(local_outcome)); 1371 hints.ai_family = PF_UNSPEC; 1372 hints.ai_protocol = IPPROTO_TCP; 1373 r = evdns_getaddrinfo(dns_base, "f::f", "8008", 1374 &hints, gai_cb, &local_outcome); 1375 tt_assert(!r); 1376 tt_int_op(local_outcome.err,==,0); 1377 tt_assert(local_outcome.ai); 1378 tt_ptr_op(local_outcome.ai->ai_next,==,NULL); 1379 test_ai_eq(local_outcome.ai, "[f::f]:8008", SOCK_STREAM, IPPROTO_TCP); 1380 evutil_freeaddrinfo(local_outcome.ai); 1381 local_outcome.ai = NULL; 1382 1383 /* 1d. We give a numeric address (ipv4) */ 1384 memset(&hints, 0, sizeof(hints)); 1385 memset(&local_outcome, 0, sizeof(local_outcome)); 1386 hints.ai_family = PF_UNSPEC; 1387 r = evdns_getaddrinfo(dns_base, "5.6.7.8", NULL, 1388 &hints, gai_cb, &local_outcome); 1389 tt_assert(!r); 1390 tt_int_op(local_outcome.err,==,0); 1391 tt_assert(local_outcome.ai); 1392 a = ai_find_by_protocol(local_outcome.ai, IPPROTO_TCP); 1393 tt_assert(a); 1394 test_ai_eq(a, "5.6.7.8", SOCK_STREAM, IPPROTO_TCP); 1395 a = ai_find_by_protocol(local_outcome.ai, IPPROTO_UDP); 1396 tt_assert(a); 1397 test_ai_eq(a, "5.6.7.8", SOCK_DGRAM, IPPROTO_UDP); 1398 evutil_freeaddrinfo(local_outcome.ai); 1399 local_outcome.ai = NULL; 1400 1401 /* 1e. nodename is NULL (bind) */ 1402 memset(&hints, 0, sizeof(hints)); 1403 memset(&local_outcome, 0, sizeof(local_outcome)); 1404 hints.ai_family = PF_UNSPEC; 1405 hints.ai_socktype = SOCK_DGRAM; 1406 hints.ai_flags = EVUTIL_AI_PASSIVE; 1407 r = evdns_getaddrinfo(dns_base, NULL, "9090", 1408 &hints, gai_cb, &local_outcome); 1409 tt_assert(!r); 1410 tt_int_op(local_outcome.err,==,0); 1411 tt_assert(local_outcome.ai); 1412 /* we should get a v4 address of 0.0.0.0... */ 1413 a = ai_find_by_family(local_outcome.ai, PF_INET); 1414 tt_assert(a); 1415 test_ai_eq(a, "0.0.0.0:9090", SOCK_DGRAM, IPPROTO_UDP); 1416 /* ... and a v6 address of ::0 */ 1417 a = ai_find_by_family(local_outcome.ai, PF_INET6); 1418 tt_assert(a); 1419 test_ai_eq(a, "[::]:9090", SOCK_DGRAM, IPPROTO_UDP); 1420 evutil_freeaddrinfo(local_outcome.ai); 1421 local_outcome.ai = NULL; 1422 1423 /* 1f. nodename is NULL (connect) */ 1424 memset(&hints, 0, sizeof(hints)); 1425 memset(&local_outcome, 0, sizeof(local_outcome)); 1426 hints.ai_family = PF_UNSPEC; 1427 hints.ai_socktype = SOCK_STREAM; 1428 r = evdns_getaddrinfo(dns_base, NULL, "2", 1429 &hints, gai_cb, &local_outcome); 1430 tt_assert(!r); 1431 tt_int_op(local_outcome.err,==,0); 1432 tt_assert(local_outcome.ai); 1433 /* we should get a v4 address of 127.0.0.1 .... */ 1434 a = ai_find_by_family(local_outcome.ai, PF_INET); 1435 tt_assert(a); 1436 test_ai_eq(a, "127.0.0.1:2", SOCK_STREAM, IPPROTO_TCP); 1437 /* ... and a v6 address of ::1 */ 1438 a = ai_find_by_family(local_outcome.ai, PF_INET6); 1439 tt_assert(a); 1440 test_ai_eq(a, "[::1]:2", SOCK_STREAM, IPPROTO_TCP); 1441 evutil_freeaddrinfo(local_outcome.ai); 1442 local_outcome.ai = NULL; 1443 1444 /* 1g. We find localhost immediately. (pf_unspec) */ 1445 memset(&hints, 0, sizeof(hints)); 1446 memset(&local_outcome, 0, sizeof(local_outcome)); 1447 hints.ai_family = PF_UNSPEC; 1448 hints.ai_socktype = SOCK_STREAM; 1449 r = evdns_getaddrinfo(dns_base, "LOCALHOST", "80", 1450 &hints, gai_cb, &local_outcome); 1451 tt_assert(!r); 1452 tt_int_op(local_outcome.err,==,0); 1453 tt_assert(local_outcome.ai); 1454 /* we should get a v4 address of 127.0.0.1 .... */ 1455 a = ai_find_by_family(local_outcome.ai, PF_INET); 1456 tt_assert(a); 1457 test_ai_eq(a, "127.0.0.1:80", SOCK_STREAM, IPPROTO_TCP); 1458 /* ... and a v6 address of ::1 */ 1459 a = ai_find_by_family(local_outcome.ai, PF_INET6); 1460 tt_assert(a); 1461 test_ai_eq(a, "[::1]:80", SOCK_STREAM, IPPROTO_TCP); 1462 evutil_freeaddrinfo(local_outcome.ai); 1463 local_outcome.ai = NULL; 1464 1465 /* 1g. We find localhost immediately. (pf_inet6) */ 1466 memset(&hints, 0, sizeof(hints)); 1467 memset(&local_outcome, 0, sizeof(local_outcome)); 1468 hints.ai_family = PF_INET6; 1469 hints.ai_socktype = SOCK_STREAM; 1470 r = evdns_getaddrinfo(dns_base, "LOCALHOST", "9999", 1471 &hints, gai_cb, &local_outcome); 1472 tt_assert(! r); 1473 tt_int_op(local_outcome.err,==,0); 1474 tt_assert(local_outcome.ai); 1475 a = local_outcome.ai; 1476 test_ai_eq(a, "[::1]:9999", SOCK_STREAM, IPPROTO_TCP); 1477 tt_ptr_op(a->ai_next, ==, NULL); 1478 evutil_freeaddrinfo(local_outcome.ai); 1479 local_outcome.ai = NULL; 1480 1481 /* 2. Okay, now we can actually test the asynchronous resolver. */ 1482 /* Start a dummy local dns server... */ 1483 port = regress_get_dnsserver(data->base, &dns_port, NULL, 1484 be_getaddrinfo_server_cb, &n_dns_questions); 1485 tt_assert(port); 1486 tt_int_op(dns_port, >=, 0); 1487 /* ... and tell the evdns_base about it. */ 1488 evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", dns_port); 1489 evdns_base_nameserver_ip_add(dns_base, buf); 1490 1491 memset(&hints, 0, sizeof(hints)); 1492 hints.ai_family = PF_UNSPEC; 1493 hints.ai_socktype = SOCK_STREAM; 1494 hints.ai_flags = EVUTIL_AI_CANONNAME; 1495 /* 0: Request for both.example.com should return both addresses. */ 1496 r = evdns_getaddrinfo(dns_base, "both.example.com", "8000", 1497 &hints, gai_cb, &a_out[0]); 1498 tt_assert(r); 1499 1500 /* 1: Request for v4only.example.com should return one address. */ 1501 r = evdns_getaddrinfo(dns_base, "v4only.example.com", "8001", 1502 &hints, gai_cb, &a_out[1]); 1503 tt_assert(r); 1504 1505 /* 2: Request for v6only.example.com should return one address. */ 1506 hints.ai_flags = 0; 1507 r = evdns_getaddrinfo(dns_base, "v6only.example.com", "8002", 1508 &hints, gai_cb, &a_out[2]); 1509 tt_assert(r); 1510 1511 /* 3: PF_INET request for v4assert.example.com should not generate a 1512 * v6 request. The server will fail the test if it does. */ 1513 hints.ai_family = PF_INET; 1514 r = evdns_getaddrinfo(dns_base, "v4assert.example.com", "8003", 1515 &hints, gai_cb, &a_out[3]); 1516 tt_assert(r); 1517 1518 /* 4: PF_INET6 request for v6assert.example.com should not generate a 1519 * v4 request. The server will fail the test if it does. */ 1520 hints.ai_family = PF_INET6; 1521 r = evdns_getaddrinfo(dns_base, "v6assert.example.com", "8004", 1522 &hints, gai_cb, &a_out[4]); 1523 tt_assert(r); 1524 1525 /* 5: PF_INET request for nosuchplace.example.com should give NEXIST. */ 1526 hints.ai_family = PF_INET; 1527 r = evdns_getaddrinfo(dns_base, "nosuchplace.example.com", "8005", 1528 &hints, gai_cb, &a_out[5]); 1529 tt_assert(r); 1530 1531 /* 6: PF_UNSPEC request for nosuchplace.example.com should give NEXIST. 1532 */ 1533 hints.ai_family = PF_UNSPEC; 1534 r = evdns_getaddrinfo(dns_base, "nosuchplace.example.com", "8006", 1535 &hints, gai_cb, &a_out[6]); 1536 tt_assert(r); 1537 1538 /* 7: PF_UNSPEC request for v6timeout.example.com should give an ipv4 1539 * address only. */ 1540 hints.ai_family = PF_UNSPEC; 1541 r = evdns_getaddrinfo(dns_base, "v6timeout.example.com", "8007", 1542 &hints, gai_cb, &a_out[7]); 1543 tt_assert(r); 1544 1545 /* 8: PF_UNSPEC request for v6timeout-nonexist.example.com should give 1546 * a NEXIST */ 1547 hints.ai_family = PF_UNSPEC; 1548 r = evdns_getaddrinfo(dns_base, "v6timeout-nonexist.example.com", 1549 "8008", &hints, gai_cb, &a_out[8]); 1550 tt_assert(r); 1551 1552 /* 9: AI_ADDRCONFIG should at least not crash. Can't test it more 1553 * without knowing what kind of internet we have. */ 1554 hints.ai_flags |= EVUTIL_AI_ADDRCONFIG; 1555 r = evdns_getaddrinfo(dns_base, "both.example.com", 1556 "8009", &hints, gai_cb, &a_out[9]); 1557 tt_assert(r); 1558 1559 /* 10: PF_UNSPEC for v4timeout.example.com should give an ipv6 address 1560 * only. */ 1561 hints.ai_family = PF_UNSPEC; 1562 hints.ai_flags = 0; 1563 r = evdns_getaddrinfo(dns_base, "v4timeout.example.com", "8010", 1564 &hints, gai_cb, &a_out[10]); 1565 tt_assert(r); 1566 1567 /* 11: timeout.example.com: cancel it after 100 msec. */ 1568 r = evdns_getaddrinfo(dns_base, "all-timeout.example.com", "8011", 1569 &hints, gai_cb, &a_out[11]); 1570 tt_assert(r); 1571 { 1572 struct timeval tv; 1573 tv.tv_sec = 0; 1574 tv.tv_usec = 100*1000; /* 100 msec */ 1575 event_base_once(data->base, -1, EV_TIMEOUT, cancel_gai_cb, 1576 r, &tv); 1577 } 1578 1579 /* XXXXX There are more tests we could do, including: 1580 1581 - A test to elicit NODATA. 1582 1583 */ 1584 1585 n_gai_results_pending = 12; 1586 exit_base_on_no_pending_results = data->base; 1587 1588 event_base_dispatch(data->base); 1589 1590 /* 0: both.example.com */ 1591 tt_int_op(a_out[0].err, ==, 0); 1592 tt_assert(a_out[0].ai); 1593 tt_assert(a_out[0].ai->ai_next); 1594 tt_assert(!a_out[0].ai->ai_next->ai_next); 1595 a = ai_find_by_family(a_out[0].ai, PF_INET); 1596 tt_assert(a); 1597 test_ai_eq(a, "80.80.32.32:8000", SOCK_STREAM, IPPROTO_TCP); 1598 a = ai_find_by_family(a_out[0].ai, PF_INET6); 1599 tt_assert(a); 1600 test_ai_eq(a, "[80ff::bbbb]:8000", SOCK_STREAM, IPPROTO_TCP); 1601 tt_assert(a_out[0].ai->ai_canonname); 1602 tt_str_op(a_out[0].ai->ai_canonname, ==, "both-canonical.example.com"); 1603 1604 /* 1: v4only.example.com */ 1605 tt_int_op(a_out[1].err, ==, 0); 1606 tt_assert(a_out[1].ai); 1607 tt_assert(! a_out[1].ai->ai_next); 1608 test_ai_eq(a_out[1].ai, "18.52.86.120:8001", SOCK_STREAM, IPPROTO_TCP); 1609 tt_assert(a_out[1].ai->ai_canonname == NULL); 1610 1611 1612 /* 2: v6only.example.com */ 1613 tt_int_op(a_out[2].err, ==, 0); 1614 tt_assert(a_out[2].ai); 1615 tt_assert(! a_out[2].ai->ai_next); 1616 test_ai_eq(a_out[2].ai, "[b0b::f00d]:8002", SOCK_STREAM, IPPROTO_TCP); 1617 1618 /* 3: v4assert.example.com */ 1619 tt_int_op(a_out[3].err, ==, 0); 1620 tt_assert(a_out[3].ai); 1621 tt_assert(! a_out[3].ai->ai_next); 1622 test_ai_eq(a_out[3].ai, "18.52.86.120:8003", SOCK_STREAM, IPPROTO_TCP); 1623 1624 /* 4: v6assert.example.com */ 1625 tt_int_op(a_out[4].err, ==, 0); 1626 tt_assert(a_out[4].ai); 1627 tt_assert(! a_out[4].ai->ai_next); 1628 test_ai_eq(a_out[4].ai, "[b0b::f00d]:8004", SOCK_STREAM, IPPROTO_TCP); 1629 1630 /* 5: nosuchplace.example.com (inet) */ 1631 tt_int_op(a_out[5].err, ==, EVUTIL_EAI_NONAME); 1632 tt_assert(! a_out[5].ai); 1633 1634 /* 6: nosuchplace.example.com (unspec) */ 1635 tt_int_op(a_out[6].err, ==, EVUTIL_EAI_NONAME); 1636 tt_assert(! a_out[6].ai); 1637 1638 /* 7: v6timeout.example.com */ 1639 tt_int_op(a_out[7].err, ==, 0); 1640 tt_assert(a_out[7].ai); 1641 tt_assert(! a_out[7].ai->ai_next); 1642 test_ai_eq(a_out[7].ai, "171.205.239.1:8007", SOCK_STREAM, IPPROTO_TCP); 1643 1644 /* 8: v6timeout-nonexist.example.com */ 1645 tt_int_op(a_out[8].err, ==, EVUTIL_EAI_NONAME); 1646 tt_assert(! a_out[8].ai); 1647 1648 /* 9: both (ADDRCONFIG) */ 1649 tt_int_op(a_out[9].err, ==, 0); 1650 tt_assert(a_out[9].ai); 1651 a = ai_find_by_family(a_out[9].ai, PF_INET); 1652 if (a) 1653 test_ai_eq(a, "80.80.32.32:8009", SOCK_STREAM, IPPROTO_TCP); 1654 else 1655 tt_assert(ai_find_by_family(a_out[9].ai, PF_INET6)); 1656 a = ai_find_by_family(a_out[9].ai, PF_INET6); 1657 if (a) 1658 test_ai_eq(a, "[80ff::bbbb]:8009", SOCK_STREAM, IPPROTO_TCP); 1659 else 1660 tt_assert(ai_find_by_family(a_out[9].ai, PF_INET)); 1661 1662 /* 10: v4timeout.example.com */ 1663 tt_int_op(a_out[10].err, ==, 0); 1664 tt_assert(a_out[10].ai); 1665 tt_assert(! a_out[10].ai->ai_next); 1666 test_ai_eq(a_out[10].ai, "[a0a::ff01]:8010", SOCK_STREAM, IPPROTO_TCP); 1667 1668 /* 11: cancelled request. */ 1669 tt_int_op(a_out[11].err, ==, EVUTIL_EAI_CANCEL); 1670 tt_assert(a_out[11].ai == NULL); 1671 1672 end: 1673 if (local_outcome.ai) 1674 evutil_freeaddrinfo(local_outcome.ai); 1675 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) 1676 for (i=0;i<(int)ARRAY_SIZE(a_out);++i) { 1677 if (a_out[i].ai) 1678 evutil_freeaddrinfo(a_out[i].ai); 1679 } 1680 if (port) 1681 evdns_close_server_port(port); 1682 if (dns_base) 1683 evdns_base_free(dns_base, 0); 1684 } 1685 1686 struct gaic_request_status { 1687 int magic; 1688 struct event_base *base; 1689 struct evdns_base *dns_base; 1690 struct evdns_getaddrinfo_request *request; 1691 struct event cancel_event; 1692 int canceled; 1693 }; 1694 1695 #define GAIC_MAGIC 0x1234abcd 1696 1697 static int pending = 0; 1698 1699 static void 1700 gaic_cancel_request_cb(evutil_socket_t fd, short what, void *arg) 1701 { 1702 struct gaic_request_status *status = arg; 1703 1704 tt_assert(status->magic == GAIC_MAGIC); 1705 status->canceled = 1; 1706 evdns_getaddrinfo_cancel(status->request); 1707 return; 1708 end: 1709 event_base_loopexit(status->base, NULL); 1710 } 1711 1712 static void 1713 gaic_server_cb(struct evdns_server_request *req, void *arg) 1714 { 1715 ev_uint32_t answer = 0x7f000001; 1716 tt_assert(req->nquestions); 1717 evdns_server_request_add_a_reply(req, req->questions[0]->name, 1, 1718 &answer, 100); 1719 evdns_server_request_respond(req, 0); 1720 return; 1721 end: 1722 evdns_server_request_respond(req, DNS_ERR_REFUSED); 1723 } 1724 1725 1726 static void 1727 gaic_getaddrinfo_cb(int result, struct evutil_addrinfo *res, void *arg) 1728 { 1729 struct gaic_request_status *status = arg; 1730 struct event_base *base = status->base; 1731 tt_assert(status->magic == GAIC_MAGIC); 1732 1733 if (result == EVUTIL_EAI_CANCEL) { 1734 tt_assert(status->canceled); 1735 } 1736 event_del(&status->cancel_event); 1737 1738 memset(status, 0xf0, sizeof(*status)); 1739 free(status); 1740 1741 end: 1742 if (--pending <= 0) 1743 event_base_loopexit(base, NULL); 1744 } 1745 1746 static void 1747 gaic_launch(struct event_base *base, struct evdns_base *dns_base) 1748 { 1749 struct gaic_request_status *status = calloc(1, sizeof(*status)); 1750 tt_assert(status); 1751 struct timeval tv = { 0, 10000 }; 1752 status->magic = GAIC_MAGIC; 1753 status->base = base; 1754 status->dns_base = dns_base; 1755 event_assign(&status->cancel_event, base, -1, 0, gaic_cancel_request_cb, 1756 status); 1757 status->request = evdns_getaddrinfo(dns_base, 1758 "foobar.bazquux.example.com", "80", NULL, gaic_getaddrinfo_cb, 1759 status); 1760 event_add(&status->cancel_event, &tv); 1761 ++pending; 1762 } 1763 1764 #ifdef EVENT_SET_MEM_FUNCTIONS_IMPLEMENTED 1765 /* FIXME: We should move this to regress_main.c if anything else needs it.*/ 1766 1767 /* Trivial replacements for malloc/free/realloc to check for memory leaks. 1768 * Not threadsafe. */ 1769 static int allocated_chunks = 0; 1770 1771 static void * 1772 cnt_malloc(size_t sz) 1773 { 1774 allocated_chunks += 1; 1775 return malloc(sz); 1776 } 1777 1778 static void * 1779 cnt_realloc(void *old, size_t sz) 1780 { 1781 if (!old) 1782 allocated_chunks += 1; 1783 if (!sz) 1784 allocated_chunks -= 1; 1785 return realloc(old, sz); 1786 } 1787 1788 static void 1789 cnt_free(void *ptr) 1790 { 1791 allocated_chunks -= 1; 1792 free(ptr); 1793 } 1794 1795 struct testleak_env_t { 1796 struct event_base *base; 1797 struct evdns_base *dns_base; 1798 struct evdns_request *req; 1799 struct generic_dns_callback_result r; 1800 }; 1801 1802 static void * 1803 testleak_setup(const struct testcase_t *testcase) 1804 { 1805 struct testleak_env_t *env; 1806 1807 allocated_chunks = 0; 1808 1809 /* Reset allocation counter, to start allocations from the very beginning. 1810 * (this will avoid false-positive negative numbers for allocated_chunks) 1811 */ 1812 libevent_global_shutdown(); 1813 1814 event_set_mem_functions(cnt_malloc, cnt_realloc, cnt_free); 1815 1816 event_enable_debug_mode(); 1817 1818 /* not mm_calloc: we don't want to mess with the count. */ 1819 env = calloc(1, sizeof(struct testleak_env_t)); 1820 env->base = event_base_new(); 1821 env->dns_base = evdns_base_new(env->base, 0); 1822 env->req = evdns_base_resolve_ipv4( 1823 env->dns_base, "example.com", DNS_QUERY_NO_SEARCH, 1824 generic_dns_callback, &env->r); 1825 return env; 1826 } 1827 1828 static int 1829 testleak_cleanup(const struct testcase_t *testcase, void *env_) 1830 { 1831 int ok = 0; 1832 struct testleak_env_t *env = env_; 1833 tt_assert(env); 1834 #ifdef EVENT__DISABLE_DEBUG_MODE 1835 tt_int_op(allocated_chunks, ==, 0); 1836 #else 1837 libevent_global_shutdown(); 1838 tt_int_op(allocated_chunks, ==, 0); 1839 #endif 1840 ok = 1; 1841 end: 1842 if (env) { 1843 if (env->dns_base) 1844 evdns_base_free(env->dns_base, 0); 1845 if (env->base) 1846 event_base_free(env->base); 1847 free(env); 1848 } 1849 return ok; 1850 } 1851 1852 static struct testcase_setup_t testleak_funcs = { 1853 testleak_setup, testleak_cleanup 1854 }; 1855 1856 static void 1857 test_dbg_leak_cancel(void *env_) 1858 { 1859 /* cancel, loop, free/dns, free/base */ 1860 struct testleak_env_t *env = env_; 1861 int send_err_shutdown = 1; 1862 evdns_cancel_request(env->dns_base, env->req); 1863 env->req = 0; 1864 1865 /* `req` is freed in callback, that's why one loop is required. */ 1866 event_base_loop(env->base, EVLOOP_NONBLOCK); 1867 1868 /* send_err_shutdown means nothing as soon as our request is 1869 * already canceled */ 1870 evdns_base_free(env->dns_base, send_err_shutdown); 1871 env->dns_base = 0; 1872 event_base_free(env->base); 1873 env->base = 0; 1874 } 1875 1876 static void 1877 dbg_leak_resume(void *env_, int cancel, int send_err_shutdown) 1878 { 1879 /* cancel, loop, free/dns, free/base */ 1880 struct testleak_env_t *env = env_; 1881 if (cancel) { 1882 evdns_cancel_request(env->dns_base, env->req); 1883 tt_assert(!evdns_base_resume(env->dns_base)); 1884 } else { 1885 /* TODO: No nameservers, request can't be processed, must be errored */ 1886 tt_assert(!evdns_base_resume(env->dns_base)); 1887 } 1888 1889 /** 1890 * Because we don't cancel request, 1891 * and want our callback to recieve DNS_ERR_SHUTDOWN, 1892 * we use deferred callback, and there was 1893 * - one extra malloc(), 1894 * @see reply_schedule_callback() 1895 * - and one missing free 1896 * @see request_finished() (req->handle->pending_cb = 1) 1897 * than we don't need to count in testleak_cleanup() 1898 * 1899 * So just decrement allocated_chunks to 2, 1900 * like we already take care about it. 1901 */ 1902 if (!cancel && send_err_shutdown) { 1903 allocated_chunks -= 2; 1904 } 1905 1906 event_base_loop(env->base, EVLOOP_NONBLOCK); 1907 1908 end: 1909 evdns_base_free(env->dns_base, send_err_shutdown); 1910 env->dns_base = 0; 1911 1912 event_base_free(env->base); 1913 env->base = 0; 1914 } 1915 1916 #define IMPL_DBG_LEAK_RESUME(name, cancel, send_err_shutdown) \ 1917 static void \ 1918 test_dbg_leak_##name##_(void *env_) \ 1919 { \ 1920 dbg_leak_resume(env_, cancel, send_err_shutdown); \ 1921 } 1922 IMPL_DBG_LEAK_RESUME(resume, 0, 0) 1923 IMPL_DBG_LEAK_RESUME(cancel_and_resume, 1, 0) 1924 IMPL_DBG_LEAK_RESUME(resume_send_err, 0, 1) 1925 IMPL_DBG_LEAK_RESUME(cancel_and_resume_send_err, 1, 1) 1926 1927 static void 1928 test_dbg_leak_shutdown(void *env_) 1929 { 1930 /* free/dns, loop, free/base */ 1931 struct testleak_env_t *env = env_; 1932 int send_err_shutdown = 1; 1933 1934 /* `req` is freed both with `send_err_shutdown` and without it, 1935 * the only difference is `evdns_callback` call */ 1936 env->req = 0; 1937 1938 evdns_base_free(env->dns_base, send_err_shutdown); 1939 env->dns_base = 0; 1940 1941 /* `req` is freed in callback, that's why one loop is required */ 1942 event_base_loop(env->base, EVLOOP_NONBLOCK); 1943 event_base_free(env->base); 1944 env->base = 0; 1945 } 1946 #endif 1947 1948 static void 1949 test_getaddrinfo_async_cancel_stress(void *ptr) 1950 { 1951 struct event_base *base; 1952 struct evdns_base *dns_base = NULL; 1953 struct evdns_server_port *server = NULL; 1954 evutil_socket_t fd = -1; 1955 struct sockaddr_in sin; 1956 struct sockaddr_storage ss; 1957 ev_socklen_t slen; 1958 int i; 1959 1960 base = event_base_new(); 1961 dns_base = evdns_base_new(base, 0); 1962 1963 memset(&sin, 0, sizeof(sin)); 1964 sin.sin_family = AF_INET; 1965 sin.sin_port = 0; 1966 sin.sin_addr.s_addr = htonl(0x7f000001); 1967 if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { 1968 tt_abort_perror("socket"); 1969 } 1970 evutil_make_socket_nonblocking(fd); 1971 if (bind(fd, (struct sockaddr*)&sin, sizeof(sin))<0) { 1972 tt_abort_perror("bind"); 1973 } 1974 server = evdns_add_server_port_with_base(base, fd, 0, gaic_server_cb, 1975 base); 1976 1977 memset(&ss, 0, sizeof(ss)); 1978 slen = sizeof(ss); 1979 if (getsockname(fd, (struct sockaddr*)&ss, &slen)<0) { 1980 tt_abort_perror("getsockname"); 1981 } 1982 evdns_base_nameserver_sockaddr_add(dns_base, 1983 (struct sockaddr*)&ss, slen, 0); 1984 1985 for (i = 0; i < 1000; ++i) { 1986 gaic_launch(base, dns_base); 1987 } 1988 1989 event_base_dispatch(base); 1990 1991 end: 1992 if (dns_base) 1993 evdns_base_free(dns_base, 1); 1994 if (server) 1995 evdns_close_server_port(server); 1996 if (base) 1997 event_base_free(base); 1998 if (fd >= 0) 1999 evutil_closesocket(fd); 2000 } 2001 2002 2003 #define DNS_LEGACY(name, flags) \ 2004 { #name, run_legacy_test_fn, flags|TT_LEGACY, &legacy_setup, \ 2005 dns_##name } 2006 2007 struct testcase_t dns_testcases[] = { 2008 DNS_LEGACY(server, TT_FORK|TT_NEED_BASE), 2009 DNS_LEGACY(gethostbyname, TT_FORK|TT_NEED_BASE|TT_NEED_DNS|TT_OFF_BY_DEFAULT), 2010 DNS_LEGACY(gethostbyname6, TT_FORK|TT_NEED_BASE|TT_NEED_DNS|TT_OFF_BY_DEFAULT), 2011 DNS_LEGACY(gethostbyaddr, TT_FORK|TT_NEED_BASE|TT_NEED_DNS|TT_OFF_BY_DEFAULT), 2012 { "resolve_reverse", dns_resolve_reverse, TT_FORK|TT_OFF_BY_DEFAULT, NULL, NULL }, 2013 { "search", dns_search_test, TT_FORK|TT_NEED_BASE, &basic_setup, NULL }, 2014 { "search_cancel", dns_search_cancel_test, 2015 TT_FORK|TT_NEED_BASE, &basic_setup, NULL }, 2016 { "retry", dns_retry_test, TT_FORK|TT_NEED_BASE|TT_NO_LOGS, &basic_setup, NULL }, 2017 { "retry_disable_when_inactive", dns_retry_disable_when_inactive_test, 2018 TT_FORK|TT_NEED_BASE|TT_NO_LOGS, &basic_setup, NULL }, 2019 { "reissue", dns_reissue_test, TT_FORK|TT_NEED_BASE|TT_NO_LOGS, &basic_setup, NULL }, 2020 { "reissue_disable_when_inactive", dns_reissue_disable_when_inactive_test, 2021 TT_FORK|TT_NEED_BASE|TT_NO_LOGS, &basic_setup, NULL }, 2022 { "inflight", dns_inflight_test, TT_FORK|TT_NEED_BASE, &basic_setup, NULL }, 2023 { "bufferevent_connect_hostname", test_bufferevent_connect_hostname, 2024 TT_FORK|TT_NEED_BASE, &basic_setup, NULL }, 2025 { "disable_when_inactive", dns_disable_when_inactive_test, 2026 TT_FORK|TT_NEED_BASE, &basic_setup, NULL }, 2027 { "disable_when_inactive_no_ns", dns_disable_when_inactive_no_ns_test, 2028 TT_FORK|TT_NEED_BASE, &basic_setup, NULL }, 2029 2030 { "getaddrinfo_async", test_getaddrinfo_async, 2031 TT_FORK|TT_NEED_BASE, &basic_setup, (char*)"" }, 2032 { "getaddrinfo_cancel_stress", test_getaddrinfo_async_cancel_stress, 2033 TT_FORK, NULL, NULL }, 2034 2035 #ifdef EVENT_SET_MEM_FUNCTIONS_IMPLEMENTED 2036 { "leak_shutdown", test_dbg_leak_shutdown, TT_FORK, &testleak_funcs, NULL }, 2037 { "leak_cancel", test_dbg_leak_cancel, TT_FORK, &testleak_funcs, NULL }, 2038 2039 { "leak_resume", test_dbg_leak_resume_, TT_FORK, &testleak_funcs, NULL }, 2040 { "leak_cancel_and_resume", test_dbg_leak_cancel_and_resume_, 2041 TT_FORK, &testleak_funcs, NULL }, 2042 { "leak_resume_send_err", test_dbg_leak_resume_send_err_, 2043 TT_FORK, &testleak_funcs, NULL }, 2044 { "leak_cancel_and_resume_send_err", test_dbg_leak_cancel_and_resume_send_err_, 2045 TT_FORK, &testleak_funcs, NULL }, 2046 #endif 2047 2048 END_OF_TESTCASES 2049 }; 2050 2051