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