1 /*- 2 * Copyright (c) 2006 Michael Bushkov <bushman@freebsd.org> 3 * All rights reserved. 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 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 */ 27 28 #include <sys/cdefs.h> 29 __FBSDID("$FreeBSD$"); 30 31 #include <sys/param.h> 32 #include <sys/socket.h> 33 #include <arpa/inet.h> 34 #include <netinet/in.h> 35 #include <errno.h> 36 #include <netdb.h> 37 #include <resolv.h> 38 #include <stdio.h> 39 #include <stdlib.h> 40 #include <string.h> 41 #include <stringlist.h> 42 #include <unistd.h> 43 44 #include <atf-c.h> 45 46 #include "freebsd_test_suite/macros.h" 47 #include "testutil.h" 48 49 enum test_methods { 50 TEST_GETHOSTBYNAME2, 51 TEST_GETHOSTBYADDR, 52 TEST_GETHOSTBYNAME2_GETADDRINFO, 53 TEST_GETHOSTBYADDR_GETNAMEINFO, 54 TEST_BUILD_SNAPSHOT, 55 TEST_BUILD_ADDR_SNAPSHOT 56 }; 57 58 static int ipnode_flags = 0; 59 static int af_type = AF_INET; 60 static bool use_ipnode_functions; 61 62 DECLARE_TEST_DATA(hostent) 63 DECLARE_TEST_FILE_SNAPSHOT(hostent) 64 DECLARE_1PASS_TEST(hostent) 65 DECLARE_2PASS_TEST(hostent) 66 67 /* These stubs will use gethostby***() or getipnodeby***() functions, 68 * depending on the use_ipnode_functions global variable value */ 69 static struct hostent *__gethostbyname2(const char *, int); 70 static struct hostent *__gethostbyaddr(const void *, socklen_t, int); 71 static void __freehostent(struct hostent *); 72 73 static void clone_hostent(struct hostent *, struct hostent const *); 74 static int compare_hostent(struct hostent *, struct hostent *, void *); 75 static void dump_hostent(struct hostent *); 76 static void free_hostent(struct hostent *); 77 78 static int is_hostent_equal(struct hostent *, struct addrinfo *); 79 80 static void sdump_hostent(struct hostent *, char *, size_t); 81 static int hostent_read_hostlist_func(struct hostent *, char *); 82 static int hostent_read_snapshot_addr(char *, unsigned char *, size_t); 83 static int hostent_read_snapshot_func(struct hostent *, char *); 84 85 static int hostent_test_correctness(struct hostent *, void *); 86 static int hostent_test_gethostbyaddr(struct hostent *, void *); 87 static int hostent_test_getaddrinfo_eq(struct hostent *, void *); 88 static int hostent_test_getnameinfo_eq(struct hostent *, void *); 89 90 static void usage(void) __attribute__((__noreturn__)); 91 92 IMPLEMENT_TEST_DATA(hostent) 93 IMPLEMENT_TEST_FILE_SNAPSHOT(hostent) 94 IMPLEMENT_1PASS_TEST(hostent) 95 IMPLEMENT_2PASS_TEST(hostent) 96 97 static struct hostent * 98 __gethostbyname2(const char *name, int af) 99 { 100 struct hostent *he; 101 int error; 102 103 if (use_ipnode_functions) { 104 error = 0; 105 he = getipnodebyname(name, af, ipnode_flags, &error); 106 if (he == NULL) 107 errno = error; 108 } else 109 he = gethostbyname2(name, af); 110 111 return (he); 112 } 113 114 static struct hostent * 115 __gethostbyaddr(const void *addr, socklen_t len, int af) 116 { 117 struct hostent *he; 118 int error; 119 120 if (use_ipnode_functions) { 121 error = 0; 122 he = getipnodebyaddr(addr, len, af, &error); 123 if (he == NULL) 124 errno = error; 125 } else 126 he = gethostbyaddr(addr, len, af); 127 128 return (he); 129 } 130 131 static void 132 __freehostent(struct hostent *he) 133 { 134 135 /* NOTE: checking for he != NULL - just in case */ 136 if (use_ipnode_functions && he != NULL) 137 freehostent(he); 138 } 139 140 static void 141 clone_hostent(struct hostent *dest, struct hostent const *src) 142 { 143 ATF_REQUIRE(dest != NULL); 144 ATF_REQUIRE(src != NULL); 145 146 char **cp; 147 int aliases_num; 148 int addrs_num; 149 size_t offset; 150 151 memset(dest, 0, sizeof(struct hostent)); 152 153 if (src->h_name != NULL) { 154 dest->h_name = strdup(src->h_name); 155 ATF_REQUIRE(dest->h_name != NULL); 156 } 157 158 dest->h_addrtype = src->h_addrtype; 159 dest->h_length = src->h_length; 160 161 if (src->h_aliases != NULL) { 162 aliases_num = 0; 163 for (cp = src->h_aliases; *cp; ++cp) 164 ++aliases_num; 165 166 dest->h_aliases = calloc(1, (aliases_num + 1) * 167 sizeof(char *)); 168 ATF_REQUIRE(dest->h_aliases != NULL); 169 170 for (cp = src->h_aliases; *cp; ++cp) { 171 dest->h_aliases[cp - src->h_aliases] = strdup(*cp); 172 ATF_REQUIRE(dest->h_aliases[cp - src->h_aliases] != NULL); 173 } 174 } 175 176 if (src->h_addr_list != NULL) { 177 addrs_num = 0; 178 for (cp = src->h_addr_list; *cp; ++cp) 179 ++addrs_num; 180 181 dest->h_addr_list = calloc(1, (addrs_num + 1) * sizeof(char *)); 182 ATF_REQUIRE(dest->h_addr_list != NULL); 183 184 for (cp = src->h_addr_list; *cp; ++cp) { 185 offset = cp - src->h_addr_list; 186 dest->h_addr_list[offset] = malloc(src->h_length); 187 ATF_REQUIRE(dest->h_addr_list[offset] != NULL); 188 memcpy(dest->h_addr_list[offset], 189 src->h_addr_list[offset], src->h_length); 190 } 191 } 192 } 193 194 static void 195 free_hostent(struct hostent *ht) 196 { 197 char **cp; 198 199 ATF_REQUIRE(ht != NULL); 200 201 free(ht->h_name); 202 203 if (ht->h_aliases != NULL) { 204 for (cp = ht->h_aliases; *cp; ++cp) 205 free(*cp); 206 free(ht->h_aliases); 207 } 208 209 if (ht->h_addr_list != NULL) { 210 for (cp = ht->h_addr_list; *cp; ++cp) 211 free(*cp); 212 free(ht->h_addr_list); 213 } 214 } 215 216 static int 217 compare_hostent(struct hostent *ht1, struct hostent *ht2, void *mdata) 218 { 219 char **c1, **c2, **ct, **cb; 220 int b; 221 222 if (ht1 == ht2) 223 return 0; 224 225 if (ht1 == NULL || ht2 == NULL) 226 goto errfin; 227 228 if (ht1->h_name == NULL || ht2->h_name == NULL) 229 goto errfin; 230 231 if (ht1->h_addrtype != ht2->h_addrtype || 232 ht1->h_length != ht2->h_length || 233 strcmp(ht1->h_name, ht2->h_name) != 0) 234 goto errfin; 235 236 c1 = ht1->h_aliases; 237 c2 = ht2->h_aliases; 238 239 if ((ht1->h_aliases == NULL || ht2->h_aliases == NULL) && 240 ht1->h_aliases != ht2->h_aliases) 241 goto errfin; 242 243 if (c1 != NULL && c2 != NULL) { 244 cb = c1; 245 for (;*c1; ++c1) { 246 b = 0; 247 for (ct = c2; *ct; ++ct) { 248 if (strcmp(*c1, *ct) == 0) { 249 b = 1; 250 break; 251 } 252 } 253 if (b == 0) { 254 printf("h1 aliases item can't be found in h2 " 255 "aliases\n"); 256 goto errfin; 257 } 258 } 259 260 c1 = cb; 261 for (;*c2; ++c2) { 262 b = 0; 263 for (ct = c1; *ct; ++ct) { 264 if (strcmp(*c2, *ct) == 0) { 265 b = 1; 266 break; 267 } 268 } 269 if (b == 0) { 270 printf("h2 aliases item can't be found in h1 " 271 "aliases\n"); 272 goto errfin; 273 } 274 } 275 } 276 277 c1 = ht1->h_addr_list; 278 c2 = ht2->h_addr_list; 279 280 if ((ht1->h_addr_list == NULL || ht2->h_addr_list== NULL) && 281 ht1->h_addr_list != ht2->h_addr_list) 282 goto errfin; 283 284 if (c1 != NULL && c2 != NULL) { 285 cb = c1; 286 for (; *c1; ++c1) { 287 b = 0; 288 for (ct = c2; *ct; ++ct) { 289 if (memcmp(*c1, *ct, ht1->h_length) == 0) { 290 b = 1; 291 break; 292 } 293 } 294 if (b == 0) { 295 printf("h1 addresses item can't be found in " 296 "h2 addresses\n"); 297 goto errfin; 298 } 299 } 300 301 c1 = cb; 302 for (; *c2; ++c2) { 303 b = 0; 304 for (ct = c1; *ct; ++ct) { 305 if (memcmp(*c2, *ct, ht1->h_length) == 0) { 306 b = 1; 307 break; 308 } 309 } 310 if (b == 0) { 311 printf("h2 addresses item can't be found in " 312 "h1 addresses\n"); 313 goto errfin; 314 } 315 } 316 } 317 318 return 0; 319 320 errfin: 321 if (mdata == NULL) { 322 printf("following structures are not equal:\n"); 323 dump_hostent(ht1); 324 dump_hostent(ht2); 325 } 326 327 return (-1); 328 } 329 330 static int 331 check_addrinfo_for_name(struct addrinfo *ai, char const *name) 332 { 333 struct addrinfo *ai2; 334 335 for (ai2 = ai; ai2 != NULL; ai2 = ai2->ai_next) { 336 if (strcmp(ai2->ai_canonname, name) == 0) 337 return (0); 338 } 339 340 return (-1); 341 } 342 343 static int 344 check_addrinfo_for_addr(struct addrinfo *ai, char const *addr, 345 socklen_t addrlen, int af) 346 { 347 struct addrinfo *ai2; 348 349 for (ai2 = ai; ai2 != NULL; ai2 = ai2->ai_next) { 350 if (af != ai2->ai_family) 351 continue; 352 353 switch (af) { 354 case AF_INET: 355 if (memcmp(addr, 356 (void *)&((struct sockaddr_in *)ai2->ai_addr)->sin_addr, 357 MIN(addrlen, ai2->ai_addrlen)) == 0) 358 return (0); 359 break; 360 case AF_INET6: 361 if (memcmp(addr, 362 (void *)&((struct sockaddr_in6 *)ai2->ai_addr)->sin6_addr, 363 MIN(addrlen, ai2->ai_addrlen)) == 0) 364 return (0); 365 break; 366 default: 367 break; 368 } 369 } 370 371 return (-1); 372 } 373 374 static int 375 is_hostent_equal(struct hostent *he, struct addrinfo *ai) 376 { 377 char **cp; 378 int rv; 379 380 #ifdef DEBUG 381 printf("checking equality of he and ai\n"); 382 #endif 383 384 rv = check_addrinfo_for_name(ai, he->h_name); 385 if (rv != 0) { 386 printf("not equal - he->h_name couldn't be found\n"); 387 return (rv); 388 } 389 390 for (cp = he->h_addr_list; *cp; ++cp) { 391 rv = check_addrinfo_for_addr(ai, *cp, he->h_length, 392 he->h_addrtype); 393 if (rv != 0) { 394 printf("not equal - one of he->h_addr_list couldn't be found\n"); 395 return (rv); 396 } 397 } 398 399 #ifdef DEBUG 400 printf("equal\n"); 401 #endif 402 403 return (0); 404 } 405 406 static void 407 sdump_hostent(struct hostent *ht, char *buffer, size_t buflen) 408 { 409 char **cp; 410 size_t i; 411 int written; 412 413 written = snprintf(buffer, buflen, "%s %d %d", 414 ht->h_name, ht->h_addrtype, ht->h_length); 415 buffer += written; 416 if (written > buflen) 417 return; 418 buflen -= written; 419 420 if (ht->h_aliases != NULL) { 421 if (*(ht->h_aliases) != NULL) { 422 for (cp = ht->h_aliases; *cp; ++cp) { 423 written = snprintf(buffer, buflen, " %s",*cp); 424 buffer += written; 425 if (written > buflen) 426 return; 427 buflen -= written; 428 429 if (buflen == 0) 430 return; 431 } 432 } else { 433 written = snprintf(buffer, buflen, " noaliases"); 434 buffer += written; 435 if (written > buflen) 436 return; 437 buflen -= written; 438 } 439 } else { 440 written = snprintf(buffer, buflen, " (null)"); 441 buffer += written; 442 if (written > buflen) 443 return; 444 buflen -= written; 445 } 446 447 written = snprintf(buffer, buflen, " : "); 448 buffer += written; 449 if (written > buflen) 450 return; 451 buflen -= written; 452 453 if (ht->h_addr_list != NULL) { 454 if (*(ht->h_addr_list) != NULL) { 455 for (cp = ht->h_addr_list; *cp; ++cp) { 456 for (i = 0; i < ht->h_length; ++i ) { 457 written = snprintf(buffer, buflen, 458 i + 1 != ht->h_length ? "%d." : "%d", 459 (unsigned char)(*cp)[i]); 460 buffer += written; 461 if (written > buflen) 462 return; 463 buflen -= written; 464 465 if (buflen == 0) 466 return; 467 } 468 469 if (*(cp + 1) ) { 470 written = snprintf(buffer, buflen, " "); 471 buffer += written; 472 if (written > buflen) 473 return; 474 buflen -= written; 475 } 476 } 477 } else { 478 written = snprintf(buffer, buflen, " noaddrs"); 479 buffer += written; 480 if (written > buflen) 481 return; 482 buflen -= written; 483 } 484 } else { 485 written = snprintf(buffer, buflen, " (null)"); 486 buffer += written; 487 if (written > buflen) 488 return; 489 buflen -= written; 490 } 491 } 492 493 static int 494 hostent_read_hostlist_func(struct hostent *he, char *line) 495 { 496 struct hostent *result; 497 int rv; 498 499 #ifdef DEBUG 500 printf("resolving %s: ", line); 501 #endif 502 result = __gethostbyname2(line, af_type); 503 if (result != NULL) { 504 #ifdef DEBUG 505 printf("found\n"); 506 #endif 507 508 rv = hostent_test_correctness(result, NULL); 509 if (rv != 0) { 510 __freehostent(result); 511 return (rv); 512 } 513 514 clone_hostent(he, result); 515 __freehostent(result); 516 } else { 517 #ifdef DEBUG 518 printf("not found\n"); 519 #endif 520 memset(he, 0, sizeof(struct hostent)); 521 he->h_name = strdup(line); 522 ATF_REQUIRE(he->h_name != NULL); 523 } 524 return (0); 525 } 526 527 static int 528 hostent_read_snapshot_addr(char *addr, unsigned char *result, size_t len) 529 { 530 char *s, *ps, *ts; 531 532 ps = addr; 533 while ( (s = strsep(&ps, ".")) != NULL) { 534 if (len == 0) 535 return (-1); 536 537 *result = (unsigned char)strtol(s, &ts, 10); 538 ++result; 539 if (*ts != '\0') 540 return (-1); 541 542 --len; 543 } 544 if (len != 0) 545 return (-1); 546 else 547 return (0); 548 } 549 550 static int 551 hostent_read_snapshot_func(struct hostent *ht, char *line) 552 { 553 StringList *sl1, *sl2; 554 char *s, *ps, *ts; 555 int i, rv; 556 557 #ifdef DEBUG 558 printf("1 line read from snapshot:\n%s\n", line); 559 #endif 560 561 rv = 0; 562 i = 0; 563 sl1 = sl2 = NULL; 564 ps = line; 565 memset(ht, 0, sizeof(struct hostent)); 566 while ((s = strsep(&ps, " ")) != NULL) { 567 switch (i) { 568 case 0: 569 ht->h_name = strdup(s); 570 ATF_REQUIRE(ht->h_name != NULL); 571 break; 572 573 case 1: 574 ht->h_addrtype = (int)strtol(s, &ts, 10); 575 if (*ts != '\0') 576 goto fin; 577 break; 578 579 case 2: 580 ht->h_length = (int)strtol(s, &ts, 10); 581 if (*ts != '\0') 582 goto fin; 583 break; 584 585 case 3: 586 if (sl1 == NULL) { 587 if (strcmp(s, "(null)") == 0) 588 return (0); 589 590 sl1 = sl_init(); 591 ATF_REQUIRE(sl1 != NULL); 592 593 if (strcmp(s, "noaliases") != 0) { 594 ts = strdup(s); 595 ATF_REQUIRE(ts != NULL); 596 sl_add(sl1, ts); 597 } 598 } else { 599 if (strcmp(s, ":") == 0) 600 ++i; 601 else { 602 ts = strdup(s); 603 ATF_REQUIRE(ts != NULL); 604 sl_add(sl1, ts); 605 } 606 } 607 break; 608 609 case 4: 610 if (sl2 == NULL) { 611 if (strcmp(s, "(null)") == 0) 612 return (0); 613 614 sl2 = sl_init(); 615 ATF_REQUIRE(sl2 != NULL); 616 617 if (strcmp(s, "noaddrs") != 0) { 618 ts = calloc(1, ht->h_length); 619 ATF_REQUIRE(ts != NULL); 620 rv = hostent_read_snapshot_addr(s, 621 (unsigned char *)ts, 622 ht->h_length); 623 sl_add(sl2, ts); 624 if (rv != 0) 625 goto fin; 626 } 627 } else { 628 ts = calloc(1, ht->h_length); 629 ATF_REQUIRE(ts != NULL); 630 rv = hostent_read_snapshot_addr(s, 631 (unsigned char *)ts, ht->h_length); 632 sl_add(sl2, ts); 633 if (rv != 0) 634 goto fin; 635 } 636 break; 637 default: 638 break; 639 } 640 641 if (i != 3 && i != 4) 642 ++i; 643 } 644 645 fin: 646 if (sl1 != NULL) { 647 sl_add(sl1, NULL); 648 ht->h_aliases = sl1->sl_str; 649 } 650 if (sl2 != NULL) { 651 sl_add(sl2, NULL); 652 ht->h_addr_list = sl2->sl_str; 653 } 654 655 if ((i != 4) || (rv != 0)) { 656 free_hostent(ht); 657 memset(ht, 0, sizeof(struct hostent)); 658 return (-1); 659 } 660 661 /* NOTE: is it a dirty hack or not? */ 662 free(sl1); 663 free(sl2); 664 return (0); 665 } 666 667 static void 668 dump_hostent(struct hostent *result) 669 { 670 if (result != NULL) { 671 char buffer[1024]; 672 sdump_hostent(result, buffer, sizeof(buffer)); 673 printf("%s\n", buffer); 674 } else 675 printf("(null)\n"); 676 } 677 678 static int 679 hostent_test_correctness(struct hostent *ht, void *mdata) 680 { 681 682 #ifdef DEBUG 683 printf("testing correctness with the following data:\n"); 684 dump_hostent(ht); 685 #endif 686 687 if (ht == NULL) 688 goto errfin; 689 690 if (ht->h_name == NULL) 691 goto errfin; 692 693 if (!((ht->h_addrtype >= 0) && (ht->h_addrtype < AF_MAX))) 694 goto errfin; 695 696 if ((ht->h_length != sizeof(struct in_addr)) && 697 (ht->h_length != sizeof(struct in6_addr))) 698 goto errfin; 699 700 if (ht->h_aliases == NULL) 701 goto errfin; 702 703 if (ht->h_addr_list == NULL) 704 goto errfin; 705 706 #ifdef DEBUG 707 printf("correct\n"); 708 #endif 709 710 return (0); 711 errfin: 712 printf("incorrect\n"); 713 714 return (-1); 715 } 716 717 static int 718 hostent_test_gethostbyaddr(struct hostent *he, void *mdata) 719 { 720 struct hostent *result; 721 struct hostent_test_data *addr_test_data; 722 int rv; 723 724 addr_test_data = (struct hostent_test_data *)mdata; 725 726 /* We should omit unresolved hostents */ 727 if (he->h_addr_list != NULL) { 728 char **cp; 729 for (cp = he->h_addr_list; *cp; ++cp) { 730 #ifdef DEBUG 731 printf("doing reverse lookup for %s\n", he->h_name); 732 #endif 733 734 result = __gethostbyaddr(*cp, he->h_length, 735 he->h_addrtype); 736 if (result == NULL) { 737 #ifdef DEBUG 738 printf("%s: warning: reverse lookup failed " 739 "for %s: %s\n", __func__, he->h_name, 740 strerror(errno)); 741 #endif 742 continue; 743 } 744 rv = hostent_test_correctness(result, NULL); 745 if (rv != 0) { 746 __freehostent(result); 747 return (rv); 748 } 749 750 if (addr_test_data != NULL) 751 TEST_DATA_APPEND(hostent, addr_test_data, 752 result); 753 754 __freehostent(result); 755 } 756 } 757 758 return (0); 759 } 760 761 static int 762 hostent_test_getaddrinfo_eq(struct hostent *he, void *mdata) 763 { 764 struct addrinfo *ai, hints; 765 int rv; 766 767 ai = NULL; 768 memset(&hints, 0, sizeof(struct addrinfo)); 769 hints.ai_family = af_type; 770 hints.ai_flags = AI_CANONNAME; 771 772 printf("using getaddrinfo() to resolve %s\n", he->h_name); 773 774 /* struct hostent *he was not resolved */ 775 if (he->h_addr_list == NULL) { 776 /* We can be sure that he->h_name is not NULL */ 777 rv = getaddrinfo(he->h_name, NULL, &hints, &ai); 778 if (rv == 0) { 779 printf("not ok - shouldn't have been resolved\n"); 780 return (-1); 781 } 782 } else { 783 rv = getaddrinfo(he->h_name, NULL, &hints, &ai); 784 if (rv != 0) { 785 printf("not ok - should have been resolved\n"); 786 return (-1); 787 } 788 789 rv = is_hostent_equal(he, ai); 790 if (rv != 0) { 791 printf("not ok - addrinfo and hostent are not equal\n"); 792 return (-1); 793 } 794 795 } 796 797 return (0); 798 } 799 800 static int 801 hostent_test_getnameinfo_eq(struct hostent *he, void *mdata) 802 { 803 char **cp; 804 char buffer[NI_MAXHOST]; 805 struct sockaddr_in sin; 806 struct sockaddr_in6 sin6; 807 struct sockaddr *saddr; 808 struct hostent *result; 809 int i, rv; 810 811 if (he->h_addr_list == NULL) 812 return (0); 813 814 for (cp = he->h_addr_list; *cp; ++cp) { 815 #ifdef DEBUG 816 printf("doing reverse lookup for %s\n", he->h_name); 817 #endif 818 result = __gethostbyaddr(*cp, he->h_length, 819 he->h_addrtype); 820 if (result != NULL) { 821 rv = hostent_test_correctness(result, NULL); 822 if (rv != 0) { 823 __freehostent(result); 824 return (rv); 825 } 826 } else 827 printf("%s: warning: reverse lookup failed " 828 "for %s: %s\n", __func__, he->h_name, 829 strerror(errno)); 830 831 switch (he->h_addrtype) { 832 case AF_INET: 833 memset(&sin, 0, sizeof(struct sockaddr_in)); 834 sin.sin_len = sizeof(struct sockaddr_in); 835 sin.sin_family = AF_INET; 836 memcpy(&sin.sin_addr, *cp, he->h_length); 837 838 saddr = (struct sockaddr *)&sin; 839 break; 840 case AF_INET6: 841 memset(&sin6, 0, sizeof(struct sockaddr_in6)); 842 sin6.sin6_len = sizeof(struct sockaddr_in6); 843 sin6.sin6_family = AF_INET6; 844 memcpy(&sin6.sin6_addr, *cp, he->h_length); 845 846 saddr = (struct sockaddr *)&sin6; 847 break; 848 default: 849 printf("warning: %d family is unsupported\n", 850 he->h_addrtype); 851 continue; 852 } 853 854 ATF_REQUIRE(saddr != NULL); 855 rv = getnameinfo(saddr, saddr->sa_len, buffer, 856 sizeof(buffer), NULL, 0, NI_NAMEREQD); 857 858 if (rv != 0 && result != NULL) { 859 printf("getnameinfo() didn't make the reverse " 860 "lookup, when it should have (%s)\n", 861 gai_strerror(rv)); 862 return (rv); 863 } 864 865 if (rv == 0 && result == NULL) { 866 printf("getnameinfo() made the " 867 "reverse lookup, when it shouldn't have\n"); 868 return (rv); 869 } 870 871 if (rv != 0 && result == NULL) { 872 #ifdef DEBUG 873 printf("both getnameinfo() and ***byaddr() failed as " 874 "expected\n"); 875 #endif 876 continue; 877 } 878 879 #ifdef DEBUG 880 printf("comparing %s with %s\n", result->h_name, 881 buffer); 882 #endif 883 884 /* 885 * An address might reverse resolve to hostname alias or the 886 * official hostname, e.g. moon.vub.ac.be. 887 */ 888 bool found_a_match; 889 890 if (strcmp(result->h_name, buffer) == 0) { 891 found_a_match = true; 892 #ifdef DEBUG 893 printf("matched official hostname\n"); 894 #endif 895 } else { 896 for (i = 0; i < nitems(result->h_aliases); i++) { 897 printf("[%d] resolved: %s\n", i, 898 result->h_aliases[i]); 899 if (strcmp(result->h_aliases[i], 900 buffer) == 0) { 901 printf("matched hostname alias\n"); 902 found_a_match = true; 903 break; 904 } 905 } 906 } 907 __freehostent(result); 908 909 if (found_a_match) { 910 #ifdef DEBUG 911 printf("getnameinfo() and ***byaddr() results are " 912 "equal\n"); 913 #endif 914 } else { 915 printf("getnameinfo() and ***byaddr() results are not " 916 "equal for %s\n", he->h_name); 917 return (-1); 918 } 919 } 920 921 return (0); 922 } 923 924 int 925 run_tests(const char *hostlist_file, const char *snapshot_file, int af_type, 926 enum test_methods method, bool use_ipv6_mapping) 927 { 928 struct hostent_test_data td, td_addr, td_snap; 929 res_state statp; 930 int rv = -2; 931 932 switch (af_type) { 933 case AF_INET: 934 ATF_REQUIRE_FEATURE("inet"); 935 ATF_REQUIRE(!use_ipv6_mapping); 936 break; 937 case AF_INET6: 938 ATF_REQUIRE_FEATURE("inet6"); 939 break; 940 default: 941 atf_tc_fail("unhandled address family: %d", af_type); 942 break; 943 } 944 945 if (!use_ipnode_functions) { 946 statp = __res_state(); 947 if (statp == NULL || ((statp->options & RES_INIT) == 0 && 948 res_ninit(statp) == -1)) { 949 printf("error: can't init res_state\n"); 950 951 return (-1); 952 } 953 954 if (use_ipv6_mapping) 955 statp->options |= RES_USE_INET6; 956 else 957 statp->options &= ~RES_USE_INET6; 958 } 959 960 TEST_DATA_INIT(hostent, &td, clone_hostent, free_hostent); 961 TEST_DATA_INIT(hostent, &td_addr, clone_hostent, free_hostent); 962 TEST_DATA_INIT(hostent, &td_snap, clone_hostent, free_hostent); 963 964 if (access(hostlist_file, R_OK) != 0) { 965 printf("can't access the hostlist file %s\n", hostlist_file); 966 rv = -1; 967 goto fin; 968 } 969 970 #ifdef DEBUG 971 printf("building host lists from %s\n", hostlist_file); 972 #endif 973 974 rv = TEST_SNAPSHOT_FILE_READ(hostent, hostlist_file, &td, 975 hostent_read_hostlist_func); 976 if (rv != 0) { 977 printf("failed to read the host list file: %s\n", 978 hostlist_file); 979 goto fin; 980 } 981 982 if (snapshot_file != NULL) { 983 if (access(snapshot_file, W_OK | R_OK) != 0) { 984 if (errno == ENOENT) { 985 if (method != TEST_GETHOSTBYADDR) 986 method = TEST_BUILD_SNAPSHOT; 987 else 988 method = TEST_BUILD_ADDR_SNAPSHOT; 989 } else { 990 printf("can't access the snapshot file %s\n", 991 snapshot_file); 992 rv = -1; 993 goto fin; 994 } 995 } else { 996 rv = TEST_SNAPSHOT_FILE_READ(hostent, snapshot_file, 997 &td_snap, hostent_read_snapshot_func); 998 if (rv != 0) { 999 printf("error reading snapshot file\n"); 1000 goto fin; 1001 } 1002 } 1003 } 1004 1005 switch (method) { 1006 case TEST_GETHOSTBYNAME2: 1007 if (snapshot_file != NULL) 1008 rv = DO_2PASS_TEST(hostent, &td, &td_snap, 1009 compare_hostent, NULL); 1010 break; 1011 case TEST_GETHOSTBYADDR: 1012 rv = DO_1PASS_TEST(hostent, &td, 1013 hostent_test_gethostbyaddr, (void *)&td_addr); 1014 if (rv != 0) 1015 goto fin; 1016 1017 if (snapshot_file != NULL) 1018 rv = DO_2PASS_TEST(hostent, &td_addr, &td_snap, 1019 compare_hostent, NULL); 1020 break; 1021 case TEST_GETHOSTBYNAME2_GETADDRINFO: 1022 rv = DO_1PASS_TEST(hostent, &td, 1023 hostent_test_getaddrinfo_eq, NULL); 1024 break; 1025 case TEST_GETHOSTBYADDR_GETNAMEINFO: 1026 rv = DO_1PASS_TEST(hostent, &td, 1027 hostent_test_getnameinfo_eq, NULL); 1028 break; 1029 case TEST_BUILD_SNAPSHOT: 1030 if (snapshot_file != NULL) { 1031 rv = TEST_SNAPSHOT_FILE_WRITE(hostent, snapshot_file, 1032 &td, sdump_hostent); 1033 } 1034 break; 1035 case TEST_BUILD_ADDR_SNAPSHOT: 1036 if (snapshot_file != NULL) { 1037 rv = DO_1PASS_TEST(hostent, &td, 1038 hostent_test_gethostbyaddr, (void *)&td_addr); 1039 if (rv != 0) 1040 goto fin; 1041 rv = TEST_SNAPSHOT_FILE_WRITE(hostent, snapshot_file, 1042 &td_addr, sdump_hostent); 1043 } 1044 break; 1045 default: 1046 rv = 0; 1047 break; 1048 } 1049 1050 fin: 1051 TEST_DATA_DESTROY(hostent, &td_snap); 1052 TEST_DATA_DESTROY(hostent, &td_addr); 1053 TEST_DATA_DESTROY(hostent, &td); 1054 1055 return (rv); 1056 } 1057 1058 #define HOSTLIST_FILE "mach" 1059 1060 #define _RUN_TESTS(tc, snapshot_file, af_type, method, use_ipv6_mapping) \ 1061 do { \ 1062 char *_hostlist_file; \ 1063 char *_snapshot_file; \ 1064 ATF_REQUIRE(0 < asprintf(&_hostlist_file, "%s/%s", \ 1065 atf_tc_get_config_var(tc, "srcdir"), HOSTLIST_FILE)); \ 1066 if (snapshot_file == NULL) \ 1067 _snapshot_file = NULL; \ 1068 else { \ 1069 _snapshot_file = strdup(snapshot_file); \ 1070 ATF_REQUIRE(_snapshot_file != NULL); \ 1071 } \ 1072 ATF_REQUIRE(run_tests(_hostlist_file, _snapshot_file, af_type, \ 1073 method, use_ipv6_mapping) == 0); \ 1074 } while(0) 1075 1076 #define RUN_HOST_TESTS(tc, snapshot_file, af_type, method, use_ipv6_mapping) \ 1077 do { \ 1078 use_ipnode_functions = false; \ 1079 _RUN_TESTS(tc, snapshot_file, af_type, method, use_ipv6_mapping); \ 1080 } while(0) 1081 1082 #define RUN_IPNODE_TESTS(tc, snapshot_file, af_type, method, use_ipv6_mapping) \ 1083 do { \ 1084 use_ipnode_functions = true; \ 1085 _RUN_TESTS(tc, snapshot_file, af_type, method, use_ipv6_mapping); \ 1086 } while(0) 1087 1088 ATF_TC_WITHOUT_HEAD(gethostbyaddr_ipv4); 1089 ATF_TC_BODY(gethostbyaddr_ipv4, tc) 1090 { 1091 1092 RUN_HOST_TESTS(tc, NULL, AF_INET, TEST_GETHOSTBYADDR, false); 1093 } 1094 1095 ATF_TC_WITHOUT_HEAD(gethostbyaddr_ipv4_with_snapshot); 1096 ATF_TC_BODY(gethostbyaddr_ipv4_with_snapshot, tc) 1097 { 1098 1099 RUN_HOST_TESTS(tc, "snapshot_htaddr4", AF_INET, TEST_GETHOSTBYADDR, false); 1100 } 1101 1102 ATF_TC_WITHOUT_HEAD(gethostbyaddr_ipv6); 1103 ATF_TC_BODY(gethostbyaddr_ipv6, tc) 1104 { 1105 1106 RUN_HOST_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYADDR, false); 1107 } 1108 1109 ATF_TC_WITHOUT_HEAD(gethostbyaddr_ipv6_AI_V4MAPPED); 1110 ATF_TC_BODY(gethostbyaddr_ipv6_AI_V4MAPPED, tc) 1111 { 1112 1113 ipnode_flags = AI_V4MAPPED; 1114 RUN_HOST_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYADDR, true); 1115 } 1116 1117 ATF_TC_WITHOUT_HEAD(gethostbyaddr_ipv6_with_snapshot); 1118 ATF_TC_BODY(gethostbyaddr_ipv6_with_snapshot, tc) 1119 { 1120 1121 RUN_HOST_TESTS(tc, "snapshot_htaddr6", AF_INET6, TEST_GETHOSTBYADDR, false); 1122 } 1123 1124 ATF_TC_WITHOUT_HEAD(gethostbyaddr_ipv6_with_snapshot_AI_V4MAPPED); 1125 ATF_TC_BODY(gethostbyaddr_ipv6_with_snapshot_AI_V4MAPPED, tc) 1126 { 1127 1128 ipnode_flags = AI_V4MAPPED; 1129 RUN_HOST_TESTS(tc, "snapshot_htaddr6map", AF_INET6, TEST_GETHOSTBYADDR, true); 1130 } 1131 1132 ATF_TC_WITHOUT_HEAD(gethostbyname2_getaddrinfo_ipv4); 1133 ATF_TC_BODY(gethostbyname2_getaddrinfo_ipv4, tc) 1134 { 1135 1136 RUN_HOST_TESTS(tc, NULL, AF_INET, TEST_GETHOSTBYNAME2_GETADDRINFO, false); 1137 } 1138 1139 ATF_TC_WITHOUT_HEAD(gethostbyname2_getaddrinfo_ipv6); 1140 ATF_TC_BODY(gethostbyname2_getaddrinfo_ipv6, tc) 1141 { 1142 1143 RUN_HOST_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYNAME2_GETADDRINFO, false); 1144 } 1145 1146 ATF_TC_WITHOUT_HEAD(gethostbyaddr_getnameinfo_ipv4); 1147 ATF_TC_BODY(gethostbyaddr_getnameinfo_ipv4, tc) 1148 { 1149 1150 RUN_HOST_TESTS(tc, NULL, AF_INET, TEST_GETHOSTBYADDR_GETNAMEINFO, false); 1151 } 1152 1153 ATF_TC_WITHOUT_HEAD(gethostbyaddr_getnameinfo_ipv6); 1154 ATF_TC_BODY(gethostbyaddr_getnameinfo_ipv6, tc) 1155 { 1156 1157 RUN_HOST_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYADDR_GETNAMEINFO, false); 1158 } 1159 1160 ATF_TC_WITHOUT_HEAD(gethostbyname2_ipv4); 1161 ATF_TC_BODY(gethostbyname2_ipv4, tc) 1162 { 1163 1164 RUN_HOST_TESTS(tc, NULL, AF_INET, TEST_GETHOSTBYNAME2, false); 1165 } 1166 1167 ATF_TC_WITHOUT_HEAD(gethostbyname2_ipv4_with_snapshot); 1168 ATF_TC_BODY(gethostbyname2_ipv4_with_snapshot, tc) 1169 { 1170 1171 RUN_HOST_TESTS(tc, "snapshot_htname4", AF_INET, TEST_GETHOSTBYNAME2, false); 1172 } 1173 1174 ATF_TC_WITHOUT_HEAD(gethostbyname2_ipv6); 1175 ATF_TC_BODY(gethostbyname2_ipv6, tc) 1176 { 1177 1178 RUN_HOST_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYNAME2, false); 1179 } 1180 1181 ATF_TC_WITHOUT_HEAD(gethostbyname2_ipv6_AI_V4MAPPED); 1182 ATF_TC_BODY(gethostbyname2_ipv6_AI_V4MAPPED, tc) 1183 { 1184 1185 ipnode_flags = AI_V4MAPPED; 1186 RUN_HOST_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYNAME2, true); 1187 } 1188 1189 ATF_TC_WITHOUT_HEAD(gethostbyname2_ipv6_with_snapshot); 1190 ATF_TC_BODY(gethostbyname2_ipv6_with_snapshot, tc) 1191 { 1192 1193 RUN_HOST_TESTS(tc, "snapshot_htname6", AF_INET6, TEST_GETHOSTBYNAME2, false); 1194 } 1195 1196 ATF_TC_WITHOUT_HEAD(gethostbyname2_ipv6_with_snapshot_AI_V4MAPPED); 1197 ATF_TC_BODY(gethostbyname2_ipv6_with_snapshot_AI_V4MAPPED, tc) 1198 { 1199 1200 ipnode_flags = AI_V4MAPPED; 1201 RUN_HOST_TESTS(tc, "snapshot_htname6map", AF_INET6, TEST_GETHOSTBYNAME2, true); 1202 } 1203 1204 ATF_TC_WITHOUT_HEAD(getipnodebyaddr_ipv4); 1205 ATF_TC_BODY(getipnodebyaddr_ipv4, tc) 1206 { 1207 1208 RUN_IPNODE_TESTS(tc, NULL, AF_INET, TEST_GETHOSTBYADDR, false); 1209 } 1210 1211 ATF_TC_WITHOUT_HEAD(getipnodebyaddr_ipv4_with_snapshot); 1212 ATF_TC_BODY(getipnodebyaddr_ipv4_with_snapshot, tc) 1213 { 1214 1215 RUN_IPNODE_TESTS(tc, "snapshot_ipnodeaddr4", AF_INET, TEST_GETHOSTBYADDR, false); 1216 } 1217 1218 ATF_TC_WITHOUT_HEAD(getipnodebyaddr_getnameinfo_ipv4); 1219 ATF_TC_BODY(getipnodebyaddr_getnameinfo_ipv4, tc) 1220 { 1221 1222 RUN_IPNODE_TESTS(tc, NULL, AF_INET, TEST_GETHOSTBYADDR_GETNAMEINFO, false); 1223 } 1224 1225 ATF_TC_WITHOUT_HEAD(getipnodebyaddr_ipv6); 1226 ATF_TC_BODY(getipnodebyaddr_ipv6, tc) 1227 { 1228 1229 RUN_IPNODE_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYADDR, false); 1230 } 1231 1232 ATF_TC_WITHOUT_HEAD(getipnodebyaddr_ipv6_AI_V4MAPPED); 1233 ATF_TC_BODY(getipnodebyaddr_ipv6_AI_V4MAPPED, tc) 1234 { 1235 1236 ipnode_flags = AI_V4MAPPED; 1237 RUN_IPNODE_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYADDR, true); 1238 } 1239 1240 ATF_TC_WITHOUT_HEAD(getipnodebyaddr_ipv6_AI_V4MAPPED_CFG); 1241 ATF_TC_BODY(getipnodebyaddr_ipv6_AI_V4MAPPED_CFG, tc) 1242 { 1243 1244 ipnode_flags = AI_V4MAPPED_CFG; 1245 RUN_IPNODE_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYADDR, true); 1246 } 1247 1248 ATF_TC_WITHOUT_HEAD(getipnodebyaddr_ipv6_AI_V4MAPPED_CFG_AI_ALL); 1249 ATF_TC_BODY(getipnodebyaddr_ipv6_AI_V4MAPPED_CFG_AI_ALL, tc) 1250 { 1251 1252 ipnode_flags = AI_V4MAPPED_CFG | AI_ALL; 1253 RUN_IPNODE_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYADDR, true); 1254 } 1255 1256 ATF_TC_WITHOUT_HEAD(getipnodebyaddr_ipv6_with_snapshot); 1257 ATF_TC_BODY(getipnodebyaddr_ipv6_with_snapshot, tc) 1258 { 1259 1260 RUN_IPNODE_TESTS(tc, "snapshot_ipnodeaddr6", AF_INET6, TEST_GETHOSTBYADDR, false); 1261 } 1262 1263 ATF_TC_WITHOUT_HEAD(getipnodebyaddr_ipv6_with_snapshot_AI_V4MAPPED); 1264 ATF_TC_BODY(getipnodebyaddr_ipv6_with_snapshot_AI_V4MAPPED, tc) 1265 { 1266 1267 ipnode_flags = AI_V4MAPPED; 1268 RUN_IPNODE_TESTS(tc, 1269 "snapshot_ipnodeaddr6_AI_V4MAPPED", AF_INET6, 1270 TEST_GETHOSTBYADDR, true); 1271 } 1272 1273 ATF_TC_WITHOUT_HEAD(getipnodebyaddr_ipv6_with_snapshot_AI_V4MAPPED_CFG); 1274 ATF_TC_BODY(getipnodebyaddr_ipv6_with_snapshot_AI_V4MAPPED_CFG, tc) 1275 { 1276 1277 ipnode_flags = AI_V4MAPPED_CFG; 1278 RUN_IPNODE_TESTS(tc, 1279 "snapshot_ipnodeaddr6_AI_V4MAPPED_CFG", AF_INET6, 1280 TEST_GETHOSTBYADDR, true); 1281 } 1282 1283 ATF_TC_WITHOUT_HEAD(getipnodebyaddr_ipv6_with_snapshot_AI_V4MAPPED_CFG_AI_ALL); 1284 ATF_TC_BODY(getipnodebyaddr_ipv6_with_snapshot_AI_V4MAPPED_CFG_AI_ALL, tc) 1285 { 1286 1287 ipnode_flags = AI_V4MAPPED_CFG | AI_ALL; 1288 RUN_IPNODE_TESTS(tc, 1289 "snapshot_ipnodeaddr6_AI_V4MAPPED_CFG_AI_ALL", AF_INET6, 1290 TEST_GETHOSTBYADDR, true); 1291 } 1292 1293 ATF_TC_WITHOUT_HEAD(getipnodebyaddr_getnameinfo_ipv6); 1294 ATF_TC_BODY(getipnodebyaddr_getnameinfo_ipv6, tc) 1295 { 1296 1297 RUN_IPNODE_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYADDR_GETNAMEINFO, false); 1298 } 1299 1300 ATF_TC_WITHOUT_HEAD(getipnodebyname_ipv4); 1301 ATF_TC_BODY(getipnodebyname_ipv4, tc) 1302 { 1303 1304 RUN_IPNODE_TESTS(tc, NULL, AF_INET, TEST_GETHOSTBYNAME2, false); 1305 } 1306 1307 ATF_TC_WITHOUT_HEAD(getipnodebyname_ipv4_with_snapshot); 1308 ATF_TC_BODY(getipnodebyname_ipv4_with_snapshot, tc) 1309 { 1310 1311 RUN_IPNODE_TESTS(tc, "snapshot_ipnodename4", AF_INET, TEST_GETHOSTBYNAME2, false); 1312 } 1313 1314 ATF_TC_WITHOUT_HEAD(getipnodebyname_ipv4_AI_ADDRCONFIG); 1315 ATF_TC_BODY(getipnodebyname_ipv4_AI_ADDRCONFIG, tc) 1316 { 1317 1318 ipnode_flags = AI_ADDRCONFIG; 1319 RUN_IPNODE_TESTS(tc, NULL, AF_INET, TEST_GETHOSTBYNAME2, false); 1320 } 1321 1322 ATF_TC_WITHOUT_HEAD(getipnodebyname_ipv4_with_snapshot_AI_ADDRCONFIG); 1323 ATF_TC_BODY(getipnodebyname_ipv4_with_snapshot_AI_ADDRCONFIG, tc) 1324 { 1325 1326 ipnode_flags = AI_ADDRCONFIG; 1327 RUN_IPNODE_TESTS(tc, "snapshot_ipnodename4_AI_ADDRCONFIG", AF_INET, 1328 TEST_GETHOSTBYNAME2, false); 1329 } 1330 1331 ATF_TC_WITHOUT_HEAD(getipnodebyname_getaddrinfo_ipv4); 1332 ATF_TC_BODY(getipnodebyname_getaddrinfo_ipv4, tc) 1333 { 1334 1335 RUN_IPNODE_TESTS(tc, NULL, AF_INET, TEST_GETHOSTBYNAME2_GETADDRINFO, false); 1336 } 1337 1338 ATF_TC_WITHOUT_HEAD(getipnodebyname_ipv6); 1339 ATF_TC_BODY(getipnodebyname_ipv6, tc) 1340 { 1341 1342 RUN_IPNODE_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYNAME2, false); 1343 } 1344 1345 ATF_TC_WITHOUT_HEAD(getipnodebyname_ipv6_with_snapshot); 1346 ATF_TC_BODY(getipnodebyname_ipv6_with_snapshot, tc) 1347 { 1348 1349 RUN_IPNODE_TESTS(tc, "snapshot_ipnodename6", AF_INET6, TEST_GETHOSTBYNAME2, false); 1350 } 1351 1352 ATF_TC_WITHOUT_HEAD(getipnodebyname_ipv6_AI_ADDRCONFIG); 1353 ATF_TC_BODY(getipnodebyname_ipv6_AI_ADDRCONFIG, tc) 1354 { 1355 1356 ipnode_flags = AI_ADDRCONFIG; 1357 RUN_IPNODE_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYNAME2, false); 1358 } 1359 1360 ATF_TC_WITHOUT_HEAD(getipnodebyname_ipv6_AI_V4MAPPED); 1361 ATF_TC_BODY(getipnodebyname_ipv6_AI_V4MAPPED, tc) 1362 { 1363 1364 ipnode_flags = AI_V4MAPPED; 1365 RUN_IPNODE_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYNAME2, true); 1366 } 1367 1368 ATF_TC_WITHOUT_HEAD(getipnodebyname_ipv6_AI_V4MAPPED_CFG); 1369 ATF_TC_BODY(getipnodebyname_ipv6_AI_V4MAPPED_CFG, tc) 1370 { 1371 1372 ipnode_flags = AI_V4MAPPED_CFG; 1373 RUN_IPNODE_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYNAME2, true); 1374 } 1375 1376 ATF_TC_WITHOUT_HEAD(getipnodebyname_ipv6_AI_V4MAPPED_CFG_AI_ADDRCONFIG); 1377 ATF_TC_BODY(getipnodebyname_ipv6_AI_V4MAPPED_CFG_AI_ADDRCONFIG, tc) 1378 { 1379 1380 ipnode_flags = AI_V4MAPPED_CFG | AI_ADDRCONFIG; 1381 RUN_IPNODE_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYNAME2, false); 1382 } 1383 1384 ATF_TC_WITHOUT_HEAD(getipnodebyname_ipv6_AI_V4MAPPED_CFG_AI_ALL); 1385 ATF_TC_BODY(getipnodebyname_ipv6_AI_V4MAPPED_CFG_AI_ALL, tc) 1386 { 1387 1388 ipnode_flags = AI_V4MAPPED_CFG | AI_ALL; 1389 RUN_IPNODE_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYNAME2, true); 1390 } 1391 1392 ATF_TC_WITHOUT_HEAD(getipnodebyname_ipv6_with_snapshot_AI_V4MAPPED); 1393 ATF_TC_BODY(getipnodebyname_ipv6_with_snapshot_AI_V4MAPPED, tc) 1394 { 1395 1396 ipnode_flags = AI_V4MAPPED; 1397 RUN_IPNODE_TESTS(tc, 1398 "snapshot_ipnodename6_AI_V4MAPPED", AF_INET6, 1399 TEST_GETHOSTBYNAME2, true); 1400 } 1401 1402 ATF_TC_WITHOUT_HEAD(getipnodebyname_ipv6_with_snapshot_AI_V4MAPPED_CFG); 1403 ATF_TC_BODY(getipnodebyname_ipv6_with_snapshot_AI_V4MAPPED_CFG, tc) 1404 { 1405 1406 ipnode_flags = AI_V4MAPPED_CFG; 1407 RUN_IPNODE_TESTS(tc, 1408 "snapshot_ipnodename6_AI_V4MAPPED_CFG", AF_INET6, 1409 TEST_GETHOSTBYNAME2, true); 1410 } 1411 1412 ATF_TC_WITHOUT_HEAD(getipnodebyname_ipv6_with_snapshot_AI_V4MAPPED_CFG_AI_ADDRCONFIG); 1413 ATF_TC_BODY(getipnodebyname_ipv6_with_snapshot_AI_V4MAPPED_CFG_AI_ADDRCONFIG, tc) 1414 { 1415 1416 ipnode_flags = AI_V4MAPPED_CFG | AI_ADDRCONFIG; 1417 RUN_IPNODE_TESTS(tc, 1418 "snapshot_ipnodename6_AI_V4MAPPED_CFG_AI_ADDRCONFIG", AF_INET6, 1419 TEST_GETHOSTBYNAME2, false); 1420 } 1421 1422 ATF_TC_WITHOUT_HEAD(getipnodebyname_ipv6_with_snapshot_AI_V4MAPPED_CFG_AI_ALL); 1423 ATF_TC_BODY(getipnodebyname_ipv6_with_snapshot_AI_V4MAPPED_CFG_AI_ALL, tc) 1424 { 1425 1426 ipnode_flags = AI_V4MAPPED_CFG | AI_ALL; 1427 RUN_IPNODE_TESTS(tc, 1428 "snapshot_ipnodename6_AI_V4MAPPED_CFG_AI_ALL", AF_INET6, 1429 TEST_GETHOSTBYNAME2, true); 1430 } 1431 1432 ATF_TC_WITHOUT_HEAD(getipnodebyname_ipv6_with_snapshot_AI_ADDRCONFIG); 1433 ATF_TC_BODY(getipnodebyname_ipv6_with_snapshot_AI_ADDRCONFIG, tc) 1434 { 1435 1436 ipnode_flags = AI_ADDRCONFIG; 1437 RUN_IPNODE_TESTS(tc, "snapshot_ipnodename6_AI_ADDRCONFIG", AF_INET6, 1438 TEST_GETHOSTBYNAME2, false); 1439 } 1440 1441 ATF_TC_WITHOUT_HEAD(getipnodebyname_getaddrinfo_ipv6); 1442 ATF_TC_BODY(getipnodebyname_getaddrinfo_ipv6, tc) 1443 { 1444 1445 RUN_IPNODE_TESTS(tc, NULL, AF_INET6, TEST_GETHOSTBYNAME2_GETADDRINFO, false); 1446 } 1447 1448 ATF_TP_ADD_TCS(tp) 1449 { 1450 1451 /* gethostbyaddr */ 1452 ATF_TP_ADD_TC(tp, gethostbyaddr_ipv4); 1453 ATF_TP_ADD_TC(tp, gethostbyaddr_ipv4_with_snapshot); 1454 ATF_TP_ADD_TC(tp, gethostbyaddr_ipv6); 1455 ATF_TP_ADD_TC(tp, gethostbyaddr_ipv6_AI_V4MAPPED); /* XXX */ 1456 ATF_TP_ADD_TC(tp, gethostbyaddr_ipv6_with_snapshot); 1457 ATF_TP_ADD_TC(tp, gethostbyaddr_ipv6_with_snapshot_AI_V4MAPPED); 1458 ATF_TP_ADD_TC(tp, gethostbyaddr_getnameinfo_ipv4); 1459 ATF_TP_ADD_TC(tp, gethostbyaddr_getnameinfo_ipv6); 1460 1461 /* gethostbyname2 */ 1462 ATF_TP_ADD_TC(tp, gethostbyname2_getaddrinfo_ipv4); 1463 ATF_TP_ADD_TC(tp, gethostbyname2_getaddrinfo_ipv6); 1464 ATF_TP_ADD_TC(tp, gethostbyname2_ipv4); 1465 ATF_TP_ADD_TC(tp, gethostbyname2_ipv4_with_snapshot); 1466 ATF_TP_ADD_TC(tp, gethostbyname2_ipv6); 1467 ATF_TP_ADD_TC(tp, gethostbyname2_ipv6_AI_V4MAPPED); 1468 ATF_TP_ADD_TC(tp, gethostbyname2_ipv6_with_snapshot); 1469 ATF_TP_ADD_TC(tp, gethostbyname2_ipv6_with_snapshot_AI_V4MAPPED); 1470 1471 /* getipnodebyaddr */ 1472 ATF_TP_ADD_TC(tp, getipnodebyaddr_ipv4); 1473 ATF_TP_ADD_TC(tp, getipnodebyaddr_ipv4_with_snapshot); 1474 ATF_TP_ADD_TC(tp, getipnodebyaddr_getnameinfo_ipv4); 1475 ATF_TP_ADD_TC(tp, getipnodebyaddr_ipv6); 1476 ATF_TP_ADD_TC(tp, getipnodebyaddr_ipv6_AI_V4MAPPED); 1477 ATF_TP_ADD_TC(tp, getipnodebyaddr_ipv6_AI_V4MAPPED_CFG); 1478 ATF_TP_ADD_TC(tp, getipnodebyaddr_ipv6_AI_V4MAPPED_CFG_AI_ALL); 1479 ATF_TP_ADD_TC(tp, getipnodebyaddr_ipv6_with_snapshot); 1480 ATF_TP_ADD_TC(tp, getipnodebyaddr_ipv6_with_snapshot_AI_V4MAPPED); 1481 ATF_TP_ADD_TC(tp, getipnodebyaddr_ipv6_with_snapshot_AI_V4MAPPED_CFG); 1482 ATF_TP_ADD_TC(tp, getipnodebyaddr_ipv6_with_snapshot_AI_V4MAPPED_CFG_AI_ALL); 1483 ATF_TP_ADD_TC(tp, getipnodebyaddr_getnameinfo_ipv6); 1484 1485 /* getipnodebyname */ 1486 ATF_TP_ADD_TC(tp, getipnodebyname_ipv4); 1487 ATF_TP_ADD_TC(tp, getipnodebyname_ipv4_with_snapshot); 1488 ATF_TP_ADD_TC(tp, getipnodebyname_ipv4_AI_ADDRCONFIG); 1489 ATF_TP_ADD_TC(tp, getipnodebyname_ipv4_with_snapshot_AI_ADDRCONFIG); 1490 ATF_TP_ADD_TC(tp, getipnodebyname_getaddrinfo_ipv4); 1491 ATF_TP_ADD_TC(tp, getipnodebyname_ipv6); 1492 ATF_TP_ADD_TC(tp, getipnodebyname_ipv6_with_snapshot); 1493 ATF_TP_ADD_TC(tp, getipnodebyname_ipv6_AI_ADDRCONFIG); 1494 ATF_TP_ADD_TC(tp, getipnodebyname_ipv6_AI_V4MAPPED); 1495 ATF_TP_ADD_TC(tp, getipnodebyname_ipv6_AI_V4MAPPED_CFG); 1496 ATF_TP_ADD_TC(tp, getipnodebyname_ipv6_AI_V4MAPPED_CFG_AI_ADDRCONFIG); 1497 ATF_TP_ADD_TC(tp, getipnodebyname_ipv6_AI_V4MAPPED_CFG_AI_ALL); 1498 ATF_TP_ADD_TC(tp, getipnodebyname_ipv6_with_snapshot_AI_V4MAPPED); 1499 ATF_TP_ADD_TC(tp, getipnodebyname_ipv6_with_snapshot_AI_V4MAPPED_CFG); 1500 ATF_TP_ADD_TC(tp, getipnodebyname_ipv6_with_snapshot_AI_V4MAPPED_CFG_AI_ADDRCONFIG); 1501 ATF_TP_ADD_TC(tp, getipnodebyname_ipv6_with_snapshot_AI_V4MAPPED_CFG_AI_ALL); 1502 ATF_TP_ADD_TC(tp, getipnodebyname_ipv6_with_snapshot_AI_ADDRCONFIG); 1503 ATF_TP_ADD_TC(tp, getipnodebyname_getaddrinfo_ipv6); 1504 1505 return (atf_no_error()); 1506 } 1507