1/* 2 * Copyright (C) 2004, 2007, 2008 Internet Systems Consortium, Inc. ("ISC") 3 * Copyright (C) 2000-2002 Internet Software Consortium. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH 10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, 12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 15 * PERFORMANCE OF THIS SOFTWARE. 16 */ 17 18/* $Id: lwtest.c,v 1.32 2008/04/02 02:37:42 marka Exp $ */ 19 20#include <config.h> 21 22#include <assert.h> 23#include <stdlib.h> 24 25#include <isc/net.h> 26#include <isc/string.h> 27 28#include <lwres/lwres.h> 29#include <lwres/netdb.h> 30#include <lwres/net.h> 31 32/* 33 * XXX getnameinfo errors, which don't appear to be standard. 34 */ 35#define ENI_NOSERVNAME 1 36#define ENI_NOHOSTNAME 2 37#define ENI_MEMORY 3 38#define ENI_SYSTEM 4 39#define ENI_FAMILY 5 40#define ENI_SALEN 6 41#define ENI_NOSOCKET 7 42 43static int fails = 0; 44 45static void 46CHECK(lwres_result_t val, const char *msg) { 47 if (val != 0) { 48 printf("I:%s returned %d\n", msg, val); 49 exit(1); 50 } 51} 52 53static unsigned char TESTSTRING[] = 54 "This is a test. This is only a test. !!!"; 55 56static lwres_context_t *ctx; 57 58static void 59test_noop(void) { 60 lwres_result_t ret; 61 lwres_lwpacket_t pkt, pkt2; 62 lwres_nooprequest_t nooprequest, *nooprequest2; 63 lwres_noopresponse_t noopresponse, *noopresponse2; 64 lwres_buffer_t b; 65 66 pkt.pktflags = 0; 67 pkt.serial = 0x11223344; 68 pkt.recvlength = 0x55667788; 69 pkt.result = 0; 70 71 nooprequest.datalength = strlen((char *)TESTSTRING); 72 nooprequest.data = TESTSTRING; 73 ret = lwres_nooprequest_render(ctx, &nooprequest, &pkt, &b); 74 CHECK(ret, "lwres_nooprequest_render"); 75 76 /* 77 * Now, parse it into a new structure. 78 */ 79 lwres_buffer_first(&b); 80 ret = lwres_lwpacket_parseheader(&b, &pkt2); 81 CHECK(ret, "lwres_lwpacket_parseheader"); 82 83 nooprequest2 = NULL; 84 ret = lwres_nooprequest_parse(ctx, &b, &pkt2, &nooprequest2); 85 CHECK(ret, "lwres_nooprequest_parse"); 86 87 assert(nooprequest.datalength == nooprequest2->datalength); 88 assert(memcmp(nooprequest.data, nooprequest2->data, 89 nooprequest.datalength) == 0); 90 91 lwres_nooprequest_free(ctx, &nooprequest2); 92 93 lwres_context_freemem(ctx, b.base, b.length); 94 b.base = NULL; 95 b.length = 0; 96 97 pkt.pktflags = 0; 98 pkt.serial = 0x11223344; 99 pkt.recvlength = 0x55667788; 100 pkt.result = 0xdeadbeef; 101 102 noopresponse.datalength = strlen((char *)TESTSTRING); 103 noopresponse.data = TESTSTRING; 104 ret = lwres_noopresponse_render(ctx, &noopresponse, &pkt, &b); 105 CHECK(ret, "lwres_noopresponse_render"); 106 107 /* 108 * Now, parse it into a new structure. 109 */ 110 lwres_buffer_first(&b); 111 ret = lwres_lwpacket_parseheader(&b, &pkt2); 112 CHECK(ret, "lwres_lwpacket_parseheader"); 113 114 noopresponse2 = NULL; 115 ret = lwres_noopresponse_parse(ctx, &b, &pkt2, &noopresponse2); 116 CHECK(ret, "lwres_noopresponse_parse"); 117 118 assert(noopresponse.datalength == noopresponse2->datalength); 119 assert(memcmp(noopresponse.data, noopresponse2->data, 120 noopresponse.datalength) == 0); 121 122 lwres_noopresponse_free(ctx, &noopresponse2); 123 124 lwres_context_freemem(ctx, b.base, b.length); 125 b.base = NULL; 126 b.length = 0; 127} 128 129static void 130test_gabn(const char *target, lwres_result_t expected, const char *address, 131 lwres_uint32_t af) 132{ 133 lwres_gabnresponse_t *res; 134 unsigned char addrbuf[16]; 135 lwres_addr_t *addr; 136 char outbuf[64]; 137 unsigned int len; 138 lwres_result_t ret; 139 140 res = NULL; 141 ret = lwres_getaddrsbyname(ctx, target, 142 LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6, 143 &res); 144 if (ret != expected) { 145 printf("I:gabn(%s) failed: %d\n", target, ret); 146 if (res != NULL) 147 lwres_gabnresponse_free(ctx, &res); 148 fails++; 149 return; 150 } 151 if (ret == LWRES_R_SUCCESS) { 152 if (af == LWRES_ADDRTYPE_V4) { 153 len = 4; 154 ret = inet_pton(AF_INET, address, addrbuf); 155 assert(ret == 1); 156 } else { 157 len = 16; 158 ret = inet_pton(AF_INET6, address, addrbuf); 159 assert(ret == 1); 160 } 161 addr = LWRES_LIST_HEAD(res->addrs); 162 if (addr == NULL) { 163 printf("I:gabn(%s) returned empty list\n", target); 164 fails++; 165 return; 166 } 167 while (addr != NULL) { 168 if (addr->family != af || addr->length != len || 169 memcmp(addr->address, addrbuf, len) == 0) 170 break; 171 addr = LWRES_LIST_NEXT(addr, link); 172 } 173 if (addr == NULL) { 174 addr = LWRES_LIST_HEAD(res->addrs); 175 if (addr->family == LWRES_ADDRTYPE_V4) 176 (void)inet_ntop(AF_INET, addr->address, 177 outbuf, sizeof(outbuf)); 178 else 179 (void)inet_ntop(AF_INET6, addr->address, 180 outbuf, sizeof(outbuf)); 181 printf("I:gabn(%s) returned %s, expected %s\n", 182 target, outbuf, address); 183 fails++; 184 return; 185 } 186 } 187 if (res != NULL) 188 lwres_gabnresponse_free(ctx, &res); 189} 190 191static void 192test_gnba(const char *target, lwres_uint32_t af, lwres_result_t expected, 193 const char *name) 194{ 195 lwres_gnbaresponse_t *res; 196 lwres_result_t ret; 197 unsigned char addrbuf[16]; 198 unsigned int len; 199 200 if (af == LWRES_ADDRTYPE_V4) { 201 len = 4; 202 ret = inet_pton(AF_INET, target, addrbuf); 203 assert(ret == 1); 204 } else { 205 len = 16; 206 ret = inet_pton(AF_INET6, target, addrbuf); 207 assert(ret == 1); 208 } 209 210 res = NULL; 211 ret = lwres_getnamebyaddr(ctx, af, len, addrbuf, &res); 212 if (ret != expected) { 213 printf("I:gnba(%s) failed: %d\n", target, ret); 214 if (res != NULL) 215 lwres_gnbaresponse_free(ctx, &res); 216 fails++; 217 return; 218 } 219 if (ret == LWRES_R_SUCCESS && strcasecmp(res->realname, name) != 0) { 220 printf("I:gnba(%s) returned %s, expected %s\n", 221 target, res->realname, name); 222 fails++; 223 return; 224 } 225 if (res != NULL) 226 lwres_gnbaresponse_free(ctx, &res); 227} 228 229static void 230test_gethostbyname(const char *name, const char *address) { 231 struct hostent *hp; 232 unsigned char addrbuf[16]; 233 int ret; 234 235 hp = gethostbyname(name); 236 if (hp == NULL) { 237 if (address == NULL && h_errno == HOST_NOT_FOUND) 238 return; 239 else if (h_errno != HOST_NOT_FOUND) { 240 printf("I:gethostbyname(%s) failed: %s\n", 241 name, hstrerror(h_errno)); 242 fails++; 243 return; 244 } else { 245 printf("I:gethostbyname(%s) returned not found\n", 246 name); 247 fails++; 248 return; 249 } 250 } else { 251 ret = inet_pton(AF_INET, address, addrbuf); 252 assert(ret == 1); 253 if (memcmp(hp->h_addr_list[0], addrbuf, hp->h_length) != 0) { 254 char outbuf[16]; 255 (void)inet_ntop(AF_INET, hp->h_addr_list[0], 256 outbuf, sizeof(outbuf)); 257 printf("I:gethostbyname(%s) returned %s, " 258 "expected %s\n", name, outbuf, address); 259 fails++; 260 return; 261 } 262 } 263} 264 265static void 266test_gethostbyname2(const char *name, const char *address, int af) { 267 struct hostent *hp; 268 unsigned char addrbuf[16]; 269 int len, ret; 270 271 hp = gethostbyname2(name, af); 272 if (hp == NULL) { 273 if (address == NULL && h_errno == HOST_NOT_FOUND) 274 return; 275 else if (h_errno != HOST_NOT_FOUND) { 276 printf("I:gethostbyname(%s) failed: %s\n", 277 name, hstrerror(h_errno)); 278 fails++; 279 return; 280 } else { 281 printf("I:gethostbyname(%s) returned not found\n", 282 name); 283 fails++; 284 return; 285 } 286 } else { 287 if (af == AF_INET) 288 len = 4; 289 else 290 len = 16; 291 ret = inet_pton(af, address, addrbuf); 292 assert(ret == 1); 293 if (hp->h_addrtype != af) { 294 printf("I:gethostbyname(%s) returned wrong family\n", 295 name); 296 fails++; 297 return; 298 } 299 if (len != (int)hp->h_length || 300 memcmp(hp->h_addr_list[0], addrbuf, hp->h_length) != 0) 301 { 302 char outbuf[16]; 303 (void)inet_ntop(af, hp->h_addr_list[0], 304 outbuf, sizeof(outbuf)); 305 printf("I:gethostbyname(%s) returned %s, " 306 "expected %s\n", name, outbuf, address); 307 fails++; 308 return; 309 } 310 } 311} 312 313static void 314test_getipnodebyname(const char *name, const char *address, int af, 315 int v4map, int all) 316{ 317 struct hostent *hp; 318 unsigned char addrbuf[16]; 319 int len, ret; 320 int error_num; 321 int flags = 0; 322 323 if (v4map) 324 flags |= AI_V4MAPPED; 325 if (all) 326 flags |= AI_ALL; 327 328 hp = getipnodebyname(name, af, flags, &error_num); 329 if (hp == NULL) { 330 if (address == NULL && error_num == HOST_NOT_FOUND) 331 return; 332 else if (error_num != HOST_NOT_FOUND) { 333 printf("I:getipnodebyname(%s) failed: %d\n", 334 name, error_num); 335 fails++; 336 return; 337 } else { 338 printf("I:getipnodebyname(%s) returned not found\n", 339 name); 340 fails++; 341 return; 342 } 343 } else { 344 if (af == AF_INET) 345 len = 4; 346 else 347 len = 16; 348 ret = inet_pton(af, address, addrbuf); 349 assert(ret == 1); 350 if (hp->h_addrtype != af) { 351 printf("I:getipnodebyname(%s) returned wrong family\n", 352 name); 353 freehostent(hp); 354 fails++; 355 return; 356 } 357 if (len != (int)hp->h_length || 358 memcmp(hp->h_addr_list[0], addrbuf, hp->h_length) != 0) 359 { 360 char outbuf[16]; 361 (void)inet_ntop(af, hp->h_addr_list[0], 362 outbuf, sizeof(outbuf)); 363 printf("I:getipnodebyname(%s) returned %s, " 364 "expected %s\n", name, outbuf, address); 365 freehostent(hp); 366 fails++; 367 return; 368 } 369 freehostent(hp); 370 } 371} 372 373static void 374test_gethostbyaddr(const char *address, int af, const char *name) { 375 struct hostent *hp; 376 char addrbuf[16]; 377 int len, ret; 378 379 if (af == AF_INET) 380 len = 4; 381 else 382 len = 16; 383 ret = inet_pton(af, address, addrbuf); 384 assert(ret == 1); 385 386 hp = gethostbyaddr(addrbuf, len, af); 387 388 if (hp == NULL) { 389 if (name == NULL && h_errno == HOST_NOT_FOUND) 390 return; 391 else if (h_errno != HOST_NOT_FOUND) { 392 printf("I:gethostbyaddr(%s) failed: %s\n", 393 address, hstrerror(h_errno)); 394 fails++; 395 return; 396 } else { 397 printf("I:gethostbyaddr(%s) returned not found\n", 398 address); 399 fails++; 400 return; 401 } 402 } else { 403 if (strcmp(hp->h_name, name) != 0) { 404 printf("I:gethostbyname(%s) returned %s, " 405 "expected %s\n", address, hp->h_name, name); 406 fails++; 407 return; 408 } 409 } 410} 411 412static void 413test_getipnodebyaddr(const char *address, int af, const char *name) { 414 struct hostent *hp; 415 char addrbuf[16]; 416 int len, ret; 417 int error_num; 418 419 if (af == AF_INET) 420 len = 4; 421 else 422 len = 16; 423 ret = inet_pton(af, address, addrbuf); 424 assert(ret == 1); 425 426 hp = getipnodebyaddr(addrbuf, len, af, &error_num); 427 428 if (hp == NULL) { 429 if (name == NULL && error_num == HOST_NOT_FOUND) 430 return; 431 else if (error_num != HOST_NOT_FOUND) { 432 printf("I:getipnodebyaddr(%s) failed: %d\n", 433 address, error_num); 434 fails++; 435 return; 436 } else { 437 printf("I:getipnodebyaddr(%s) returned not found\n", 438 address); 439 fails++; 440 return; 441 } 442 } else { 443 if (strcmp(hp->h_name, name) != 0) { 444 printf("I:getipnodebyaddr(%s) returned %s, " 445 "expected %s\n", address, hp->h_name, name); 446 freehostent(hp); 447 fails++; 448 return; 449 } 450 freehostent(hp); 451 } 452} 453 454static void 455test_getaddrinfo(const char *name, int af, int v4ok, int v6ok, 456 const char *address) 457{ 458 unsigned int len; 459 int ret; 460 struct addrinfo *ai; 461 struct addrinfo hint; 462 unsigned char addrbuf[16]; 463 464 if (v4ok == 1 && v6ok== 1) { 465 ret = getaddrinfo(name, NULL, NULL, &ai); 466 } else { 467 memset(&hint, 0, sizeof(hint)); 468 if (v4ok) 469 hint.ai_family = AF_INET; 470 else 471 hint.ai_family = AF_INET6; 472 ret = getaddrinfo(name, NULL, &hint, &ai); 473 } 474 if (ret != 0) { 475 if (address == NULL && ret == EAI_NODATA) 476 return; 477 else if (ret != EAI_NODATA) { 478 printf("I:getaddrinfo(%s,%d,%d) failed: %s\n", 479 name, v4ok, v6ok, gai_strerror(ret)); 480 fails++; 481 return; 482 } else { 483 printf("I:getaddrinfo(%s,%d,%d) returned not found\n", 484 name, v4ok, v6ok); 485 fails++; 486 return; 487 } 488 } else { 489 if (af == AF_INET) 490 len = sizeof(struct sockaddr_in); 491 else 492 len = sizeof(struct sockaddr_in6); 493 ret = inet_pton(af, address, addrbuf); 494 assert(ret == 1); 495 if (ai->ai_family != af) { 496 printf("I:getaddrinfo(%s) returned wrong family\n", 497 name); 498 fails++; 499 freeaddrinfo(ai); 500 return; 501 } 502 if (len != (unsigned int) ai->ai_addrlen) { 503 char outbuf[16]; 504 (void)inet_ntop(af, ai->ai_addr, 505 outbuf, sizeof(outbuf)); 506 printf("I:getaddrinfo(%s) returned %lub, " 507 "expected %ub\n", name, 508 (unsigned long)ai->ai_addrlen, len); 509 fails++; 510 freeaddrinfo(ai); 511 return; 512 } else if (af == AF_INET) { 513 struct sockaddr_in *sin; 514 sin = (struct sockaddr_in *) ai->ai_addr; 515 if (memcmp(&sin->sin_addr.s_addr, addrbuf, 4) != 0) { 516 char outbuf[16]; 517 (void)inet_ntop(af, &sin->sin_addr.s_addr, 518 outbuf, sizeof(outbuf)); 519 printf("I:getaddrinfo(%s) returned %s, " 520 "expected %s\n", name, outbuf, address); 521 fails++; 522 freeaddrinfo(ai); 523 return; 524 } 525 } else { 526 struct sockaddr_in6 *sin6; 527 sin6 = (struct sockaddr_in6 *) ai->ai_addr; 528 if (memcmp(sin6->sin6_addr.s6_addr, addrbuf, 16) != 0) 529 { 530 char outbuf[16]; 531 (void)inet_ntop(af, &sin6->sin6_addr.s6_addr, 532 outbuf, sizeof(outbuf)); 533 printf("I:getaddrinfo(%s) returned %s, " 534 "expected %s\n", name, outbuf, address); 535 fails++; 536 freeaddrinfo(ai); 537 return; 538 } 539 } 540 freeaddrinfo(ai); 541 } 542} 543 544static void 545test_getnameinfo(const char *address, int af, const char *name) { 546 int ret; 547 struct sockaddr_in sin; 548 struct sockaddr_in6 sin6; 549 struct sockaddr *sa; 550 int salen; 551 char host[1025]; 552 553 if (af == AF_INET) { 554 memset(&sin, 0, sizeof(sin)); 555 ret = inet_pton(AF_INET, address, &sin.sin_addr.s_addr); 556 assert(ret == 1); 557 sin.sin_family = AF_INET; 558#ifdef LWRES_PLATFORM_HAVESALEN 559 sin.sin_len = sizeof(sin); 560#endif 561 sa = (struct sockaddr *) &sin; 562 salen = sizeof(sin); 563 } else { 564 memset(&sin6, 0, sizeof(sin6)); 565 ret = inet_pton(AF_INET6, address, sin6.sin6_addr.s6_addr); 566 assert(ret == 1); 567 sin6.sin6_family = AF_INET6; 568#ifdef LWRES_PLATFORM_HAVESALEN 569 sin6.sin6_len = sizeof(sin6); 570#endif 571 sa = (struct sockaddr *) &sin6; 572 salen = sizeof(sin6); 573 } 574 sa->sa_family = af; 575 576 ret = getnameinfo(sa, salen, host, sizeof(host), NULL, 0, NI_NAMEREQD); 577 578 if (ret != 0) { 579 if (name == NULL && ret == ENI_NOHOSTNAME) 580 return; 581 else if (ret != ENI_NOHOSTNAME) { 582 printf("I:getnameinfo(%s) failed: %d\n", 583 address, ret); 584 fails++; 585 return; 586 } else { 587 printf("I:getnameinfo(%s) returned not found\n", 588 address); 589 fails++; 590 return; 591 } 592 } else { 593 if (name == NULL) { 594 printf("I:getnameinfo(%s) returned %s, " 595 "expected NULL\n", address, host); 596 fails++; 597 return; 598 } else if (strcmp(host, name) != 0) { 599 printf("I:getnameinfo(%s) returned %s, expected %s\n", 600 address, host, name); 601 fails++; 602 return; 603 } 604 } 605} 606 607static void 608test_getrrsetbyname(const char *name, int rdclass, int rdtype, 609 unsigned int nrdatas, unsigned int nsigs, 610 int should_pass) 611{ 612 int ret; 613 struct rrsetinfo *rrinfo = NULL; 614 ret = getrrsetbyname(name, rdclass, rdtype, 0, &rrinfo); 615 if (ret != 0 && should_pass == 1) { 616 printf("I:getrrsetbyname(%s, %d) failed\n", name, rdtype); 617 fails++; 618 return; 619 } else if (ret == 0 && should_pass == 0) { 620 printf("I:getrrsetbyname(%s, %d) unexpectedly succeeded\n", 621 name, rdtype); 622 fails++; 623 freerrset(rrinfo); 624 return; 625 } else if (ret != 0) 626 return; 627 if (rrinfo->rri_nrdatas != nrdatas) { 628 printf("I:getrrsetbyname(%s, %d): got %d rr, expected %d\n", 629 name, rdtype, rrinfo->rri_nrdatas, nrdatas); 630 fails++; 631 } 632 if (rrinfo->rri_nsigs != nsigs) { 633 printf("I:getrrsetbyname(%s, %d): got %d sig, expected %d\n", 634 name, rdtype, rrinfo->rri_nsigs, nsigs); 635 fails++; 636 } 637 freerrset(rrinfo); 638 return; 639} 640 641int 642main(void) { 643 lwres_result_t ret; 644 645 lwres_udp_port = 9210; 646 lwres_resolv_conf = "resolv.conf"; 647 648 ret = lwres_context_create(&ctx, NULL, NULL, NULL, 0); 649 CHECK(ret, "lwres_context_create"); 650 651 ret = lwres_conf_parse(ctx, "resolv.conf"); 652 CHECK(ret, "lwres_conf_parse"); 653 654 test_noop(); 655 656 test_gabn("a.example1", LWRES_R_SUCCESS, "10.0.1.1", 657 LWRES_ADDRTYPE_V4); 658 test_gabn("a.example1.", LWRES_R_SUCCESS, "10.0.1.1", 659 LWRES_ADDRTYPE_V4); 660 test_gabn("a.example2", LWRES_R_SUCCESS, "10.0.2.1", 661 LWRES_ADDRTYPE_V4); 662 test_gabn("a.example2.", LWRES_R_SUCCESS, "10.0.2.1", 663 LWRES_ADDRTYPE_V4); 664 test_gabn("a.example3", LWRES_R_NOTFOUND, NULL, LWRES_ADDRTYPE_V4); 665 test_gabn("a.example3.", LWRES_R_NOTFOUND, NULL, LWRES_ADDRTYPE_V4); 666 test_gabn("a", LWRES_R_SUCCESS, "10.0.1.1", LWRES_ADDRTYPE_V4); 667 test_gabn("a.", LWRES_R_NOTFOUND, NULL, LWRES_ADDRTYPE_V4); 668 669 test_gabn("a2", LWRES_R_SUCCESS, "10.0.1.1", LWRES_ADDRTYPE_V4); 670 test_gabn("a3", LWRES_R_NOTFOUND, NULL, LWRES_ADDRTYPE_V4); 671 672 test_gabn("b.example1", LWRES_R_SUCCESS, 673 "eeee:eeee:eeee:eeee:ffff:ffff:ffff:ffff", 674 LWRES_ADDRTYPE_V6); 675 test_gabn("b.example1.", LWRES_R_SUCCESS, 676 "eeee:eeee:eeee:eeee:ffff:ffff:ffff:ffff", 677 LWRES_ADDRTYPE_V6); 678 test_gabn("b.example2", LWRES_R_SUCCESS, 679 "eeee:eeee:eeee:eeee:ffff:ffff:ffff:ffff", 680 LWRES_ADDRTYPE_V6); 681 test_gabn("b.example2.", LWRES_R_SUCCESS, 682 "eeee:eeee:eeee:eeee:ffff:ffff:ffff:ffff", 683 LWRES_ADDRTYPE_V6); 684 test_gabn("b.example3", LWRES_R_NOTFOUND, NULL, LWRES_ADDRTYPE_V6); 685 test_gabn("b.example3.", LWRES_R_NOTFOUND, NULL, LWRES_ADDRTYPE_V6); 686 test_gabn("b", LWRES_R_SUCCESS, 687 "eeee:eeee:eeee:eeee:ffff:ffff:ffff:ffff", 688 LWRES_ADDRTYPE_V6); 689 test_gabn("b.", LWRES_R_NOTFOUND, NULL, LWRES_ADDRTYPE_V6); 690 691 test_gabn("d.example1", LWRES_R_NOTFOUND, NULL, LWRES_ADDRTYPE_V6); 692 693 test_gabn("x", LWRES_R_SUCCESS, "10.1.10.1", LWRES_ADDRTYPE_V4); 694 test_gabn("x.", LWRES_R_SUCCESS, "10.1.10.1", LWRES_ADDRTYPE_V4); 695 696 test_gnba("10.10.10.1", LWRES_ADDRTYPE_V4, LWRES_R_SUCCESS, 697 "ipv4.example"); 698 test_gnba("10.10.10.17", LWRES_ADDRTYPE_V4, LWRES_R_NOTFOUND, 699 NULL); 700 test_gnba("0123:4567:89ab:cdef:0123:4567:89ab:cdef", 701 LWRES_ADDRTYPE_V6, LWRES_R_SUCCESS, "ip6.int.example"); 702 test_gnba("0123:4567:89ab:cdef:0123:4567:89ab:cde0", 703 LWRES_ADDRTYPE_V6, LWRES_R_NOTFOUND, NULL); 704 test_gnba("1123:4567:89ab:cdef:0123:4567:89ab:cdef", 705 LWRES_ADDRTYPE_V6, LWRES_R_SUCCESS, "ip6.arpa.example"); 706 test_gnba("1123:4567:89ab:cdef:0123:4567:89ab:cde0", 707 LWRES_ADDRTYPE_V6, LWRES_R_NOTFOUND, NULL); 708 709 test_gethostbyname("a.example1.", "10.0.1.1"); 710 test_gethostbyname("q.example1.", NULL); 711 712 test_gethostbyname2("a.example1.", "10.0.1.1", AF_INET); 713 test_gethostbyname2("b.example1.", 714 "eeee:eeee:eeee:eeee:ffff:ffff:ffff:ffff", 715 AF_INET6); 716 test_gethostbyname2("q.example1.", NULL, AF_INET); 717 718 test_getipnodebyname("a.example1.", "10.0.1.1", AF_INET, 0, 0); 719 test_getipnodebyname("b.example1.", 720 "eeee:eeee:eeee:eeee:ffff:ffff:ffff:ffff", 721 AF_INET6, 0, 0); 722 test_getipnodebyname("a.example1.", 723 "::ffff:10.0.1.1", AF_INET6, 1, 0); 724 test_getipnodebyname("a.example1.", 725 "::ffff:10.0.1.1", AF_INET6, 1, 1); 726 test_getipnodebyname("b.example1.", 727 "eeee:eeee:eeee:eeee:ffff:ffff:ffff:ffff", 728 AF_INET6, 1, 1); 729 test_getipnodebyname("q.example1.", NULL, AF_INET, 0, 0); 730 731 test_gethostbyaddr("10.10.10.1", AF_INET, "ipv4.example"); 732 test_gethostbyaddr("10.10.10.17", AF_INET, NULL); 733 test_gethostbyaddr("0123:4567:89ab:cdef:0123:4567:89ab:cdef", 734 AF_INET6, "ip6.int.example"); 735 test_gethostbyaddr("1123:4567:89ab:cdef:0123:4567:89ab:cdef", 736 AF_INET6, "ip6.arpa.example"); 737 738 test_getipnodebyaddr("10.10.10.1", AF_INET, "ipv4.example"); 739 test_getipnodebyaddr("10.10.10.17", AF_INET, NULL); 740 test_getipnodebyaddr("0123:4567:89ab:cdef:0123:4567:89ab:cdef", 741 AF_INET6, "ip6.int.example"); 742 test_getipnodebyaddr("1123:4567:89ab:cdef:0123:4567:89ab:cdef", 743 AF_INET6, "ip6.arpa.example"); 744 745 test_getaddrinfo("a.example1.", AF_INET, 1, 1, "10.0.1.1"); 746 test_getaddrinfo("a.example1.", AF_INET, 1, 0, "10.0.1.1"); 747 test_getaddrinfo("a.example1.", AF_INET, 0, 1, NULL); 748 test_getaddrinfo("b.example1.", AF_INET6, 1, 1, 749 "eeee:eeee:eeee:eeee:ffff:ffff:ffff:ffff"); 750 test_getaddrinfo("b.example1.", AF_INET6, 1, 0, NULL); 751 test_getaddrinfo("b.example1.", AF_INET6, 0, 1, 752 "eeee:eeee:eeee:eeee:ffff:ffff:ffff:ffff"); 753 754 test_getnameinfo("10.10.10.1", AF_INET, "ipv4.example"); 755 test_getnameinfo("10.10.10.17", AF_INET, NULL); 756 test_getnameinfo("0123:4567:89ab:cdef:0123:4567:89ab:cdef", 757 AF_INET6, "ip6.int.example"); 758 test_getnameinfo("1123:4567:89ab:cdef:0123:4567:89ab:cdef", 759 AF_INET6, "ip6.arpa.example"); 760 test_getnameinfo("1122:3344:5566:7788:99aa:bbcc:ddee:ff00", 761 AF_INET6, "dname.example1"); 762 763 test_getrrsetbyname("a", 1, 1, 1, 0, 1); 764 test_getrrsetbyname("a.example1.", 1, 1, 1, 0, 1); 765 test_getrrsetbyname("e.example1.", 1, 1, 1, 1, 1); 766 test_getrrsetbyname("e.example1.", 1, 255, 1, 1, 0); 767 test_getrrsetbyname("e.example1.", 1, 46, 2, 0, 1); 768 test_getrrsetbyname("", 1, 1, 0, 0, 0); 769 770 if (fails == 0) 771 printf("I:ok\n"); 772 return (fails); 773} 774