bin/tests/system/lwresd/lwtest.c

   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
  43 static int fails = 0;
  44
  45 static void
  46 CHECK(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
  53 static unsigned char TESTSTRING[] =
  54         "This is a test.  This is only a test.  !!!";
  55
  56 static lwres_context_t *ctx;
  57
  58 static void
  59 test_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
 129 static void
 130 test_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
 191 static void
 192 test_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
 229 static void
 230 test_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
 265 static void
 266 test_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
 313 static void
 314 test_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
 373 static void
 374 test_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
 412 static void
 413 test_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
 454 static void
 455 test_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
 544 static void
 545 test_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
 607 static void
 608 test_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
 641 int
 642 main(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 }