external/bsd/bind/dist/contrib/queryperf/missing/getaddrinfo.c

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the project nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/types.h>
  33 #include <sys/param.h>
  34 #include <sys/socket.h>
  35 #include <netinet/in.h>
  36 #include <arpa/inet.h>
  37 #include <arpa/nameser.h>
  38 #include <netdb.h>
  39 #include <resolv.h>
  40 #include <string.h>
  41 #include <stdlib.h>
  42 #include <stddef.h>
  43 #include <ctype.h>
  44 #include <unistd.h>
  45
  46 #include "addrinfo.h"
  47
  48 #define SUCCESS 0
  49 #define ANY 0
  50 #define YES 1
  51 #define NO  0
  52
  53 static const char in_addrany[] = { 0, 0, 0, 0 };
  54 static const char in6_addrany[] = {
  55         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  56 };
  57 static const char in_loopback[] = { 127, 0, 0, 1 };
  58 static const char in6_loopback[] = {
  59         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
  60 };
  61
  62 struct sockinet {
  63         u_char  si_len;
  64         u_char  si_family;
  65         u_short si_port;
  66 };
  67
  68 static struct afd {
  69         int a_af;
  70         int a_addrlen;
  71         int a_socklen;
  72         int a_off;
  73         const char *a_addrany;
  74         const char *a_loopback;
  75 } afdl [] = {
  76 #ifdef INET6
  77 #define N_INET6 0
  78         {PF_INET6, sizeof(struct in6_addr),
  79          sizeof(struct sockaddr_in6),
  80          offsetof(struct sockaddr_in6, sin6_addr),
  81          in6_addrany, in6_loopback},
  82 #define N_INET  1
  83 #else
  84 #define N_INET  0
  85 #endif
  86         {PF_INET, sizeof(struct in_addr),
  87          sizeof(struct sockaddr_in),
  88          offsetof(struct sockaddr_in, sin_addr),
  89          in_addrany, in_loopback},
  90         {0, 0, 0, 0, NULL, NULL},
  91 };
  92
  93 #ifdef INET6
  94 #define PTON_MAX        16
  95 #else
  96 #define PTON_MAX        4
  97 #endif
  98
  99
 100 static int get_name(const char *, struct afd *,
 101                     struct addrinfo **, char *, struct addrinfo *,
 102                     int);
 103 static int get_addr(const char *, int, struct addrinfo **,
 104                     struct addrinfo *, int);
 105 static int get_addr0(const char *, int, struct addrinfo **,
 106                      struct addrinfo *, int);
 107 static int str_isnumber(const char *);
 108
 109 static char *ai_errlist[] = {
 110         "Success",
 111         "Address family for hostname not supported",    /* EAI_ADDRFAMILY */
 112         "Temporary failure in name resolution",         /* EAI_AGAIN      */
 113         "Invalid value for ai_flags",                   /* EAI_BADFLAGS   */
 114         "Non-recoverable failure in name resolution",   /* EAI_FAIL       */
 115         "ai_family not supported",                      /* EAI_FAMILY     */
 116         "Memory allocation failure",                    /* EAI_MEMORY     */
 117         "No address associated with hostname",          /* EAI_NODATA     */
 118         "hostname nor servname provided, or not known",/* EAI_NONAME     */
 119         "servname not supported for ai_socktype",       /* EAI_SERVICE    */
 120         "ai_socktype not supported",                    /* EAI_SOCKTYPE   */
 121         "System error returned in errno",               /* EAI_SYSTEM     */
 122         "Invalid value for hints",                      /* EAI_BADHINTS   */
 123         "Resolved protocol is unknown",                 /* EAI_PROTOCOL   */
 124         "Unknown error",                                /* EAI_MAX        */
 125 };
 126
 127 #define GET_CANONNAME(ai, str) \
 128 if (pai->ai_flags & AI_CANONNAME) {\
 129         if (((ai)->ai_canonname = (char *)malloc(strlen(str) + 1)) != NULL) {\
 130                 strcpy((ai)->ai_canonname, (str));\
 131         } else {\
 132                 error = EAI_MEMORY;\
 133                 goto free;\
 134         }\
 135 }
 136
 137 #ifdef HAVE_SA_LEN
 138 #define SET_AILEN(ai,l) (ai)->ai_addr->sa_len = (ai)->ai_addrlen = (l)
 139 #else
 140 #define SET_AILEN(ai,l) (ai)->ai_addrlen = (l)
 141 #endif
 142
 143 #define GET_AI(ai, afd, addr, port) {\
 144         char *p;\
 145         if (((ai) = (struct addrinfo *)malloc(sizeof(struct addrinfo) +\
 146                                               ((afd)->a_socklen)))\
 147             == NULL) {\
 148                 error = EAI_MEMORY;\
 149                 goto free;\
 150         }\
 151         memcpy(ai, pai, sizeof(struct addrinfo));\
 152         (ai)->ai_addr = (struct sockaddr *)((ai) + 1);\
 153         memset((ai)->ai_addr, 0, (afd)->a_socklen);\
 154         SET_AILEN((ai), (afd)->a_socklen);\
 155         (ai)->ai_addr->sa_family = (ai)->ai_family = (afd)->a_af;\
 156         ((struct sockinet *)(ai)->ai_addr)->si_port = port;\
 157         p = (char *)((ai)->ai_addr);\
 158         memcpy(p + (afd)->a_off, (addr), (afd)->a_addrlen);\
 159 }
 160
 161 #define ERR(err) { error = (err); goto bad; }
 162
 163 char *
 164 gai_strerror(ecode)
 165         int ecode;
 166 {
 167         if (ecode < 0 || ecode > EAI_MAX)
 168                 ecode = EAI_MAX;
 169         return ai_errlist[ecode];
 170 }
 171
 172 void
 173 freeaddrinfo(ai)
 174         struct addrinfo *ai;
 175 {
 176         struct addrinfo *next;
 177
 178         do {
 179                 next = ai->ai_next;
 180                 if (ai->ai_canonname)
 181                         free(ai->ai_canonname);
 182                 /* no need to free(ai->ai_addr) */
 183                 free(ai);
 184         } while ((ai = next) != NULL);
 185 }
 186
 187 static int
 188 str_isnumber(p)
 189         const char *p;
 190 {
 191         char *q = (char *)p;
 192         while (*q) {
 193                 if (! isdigit(*q))
 194                         return NO;
 195                 q++;
 196         }
 197         return YES;
 198 }
 199
 200 int
 201 getaddrinfo(hostname, servname, hints, res)
 202         const char *hostname, *servname;
 203         const struct addrinfo *hints;
 204         struct addrinfo **res;
 205 {
 206         struct addrinfo sentinel;
 207         struct addrinfo *top = NULL;
 208         struct addrinfo *cur;
 209         int i, error = 0;
 210         char pton[PTON_MAX];
 211         struct addrinfo ai;
 212         struct addrinfo *pai;
 213         u_short port;
 214
 215         /* initialize file static vars */
 216         sentinel.ai_next = NULL;
 217         cur = &sentinel;
 218         pai = &ai;
 219         pai->ai_flags = 0;
 220         pai->ai_family = PF_UNSPEC;
 221         pai->ai_socktype = ANY;
 222         pai->ai_protocol = ANY;
 223         pai->ai_addrlen = 0;
 224         pai->ai_canonname = NULL;
 225         pai->ai_addr = NULL;
 226         pai->ai_next = NULL;
 227         port = ANY;
 228
 229         if (hostname == NULL && servname == NULL)
 230                 return EAI_NONAME;
 231         if (hints) {
 232                 /* error check for hints */
 233                 if (hints->ai_addrlen || hints->ai_canonname ||
 234                     hints->ai_addr || hints->ai_next)
 235                         ERR(EAI_BADHINTS); /* xxx */
 236                 if (hints->ai_flags & ~AI_MASK)
 237                         ERR(EAI_BADFLAGS);
 238                 switch (hints->ai_family) {
 239                 case PF_UNSPEC:
 240                 case PF_INET:
 241 #ifdef INET6
 242                 case PF_INET6:
 243 #endif
 244                         break;
 245                 default:
 246                         ERR(EAI_FAMILY);
 247                 }
 248                 memcpy(pai, hints, sizeof(*pai));
 249                 switch (pai->ai_socktype) {
 250                 case ANY:
 251                         switch (pai->ai_protocol) {
 252                         case ANY:
 253                                 break;
 254                         case IPPROTO_UDP:
 255                                 pai->ai_socktype = SOCK_DGRAM;
 256                                 break;
 257                         case IPPROTO_TCP:
 258                                 pai->ai_socktype = SOCK_STREAM;
 259                                 break;
 260                         default:
 261                                 pai->ai_socktype = SOCK_RAW;
 262                                 break;
 263                         }
 264                         break;
 265                 case SOCK_RAW:
 266                         break;
 267                 case SOCK_DGRAM:
 268                         if (pai->ai_protocol != IPPROTO_UDP &&
 269                             pai->ai_protocol != ANY)
 270                                 ERR(EAI_BADHINTS);      /*xxx*/
 271                         pai->ai_protocol = IPPROTO_UDP;
 272                         break;
 273                 case SOCK_STREAM:
 274                         if (pai->ai_protocol != IPPROTO_TCP &&
 275                             pai->ai_protocol != ANY)
 276                                 ERR(EAI_BADHINTS);      /*xxx*/
 277                         pai->ai_protocol = IPPROTO_TCP;
 278                         break;
 279                 default:
 280                         ERR(EAI_SOCKTYPE);
 281                         break;
 282                 }
 283         }
 284
 285         /*
 286          * service port
 287          */
 288         if (servname) {
 289                 if (str_isnumber(servname)) {
 290                         if (pai->ai_socktype == ANY) {
 291                                 /* caller accept *ANY* socktype */
 292                                 pai->ai_socktype = SOCK_DGRAM;
 293                                 pai->ai_protocol = IPPROTO_UDP;
 294                         }
 295                         port = htons(atoi(servname));
 296                 } else {
 297                         struct servent *sp;
 298                         char *proto;
 299
 300                         proto = NULL;
 301                         switch (pai->ai_socktype) {
 302                         case ANY:
 303                                 proto = NULL;
 304                                 break;
 305                         case SOCK_DGRAM:
 306                                 proto = "udp";
 307                                 break;
 308                         case SOCK_STREAM:
 309                                 proto = "tcp";
 310                                 break;
 311                         default:
 312                                 fprintf(stderr, "panic!\n");
 313                                 break;
 314                         }
 315                         if ((sp = getservbyname(servname, proto)) == NULL)
 316                                 ERR(EAI_SERVICE);
 317                         port = sp->s_port;
 318                         if (pai->ai_socktype == ANY) {
 319                                 if (strcmp(sp->s_proto, "udp") == 0) {
 320                                         pai->ai_socktype = SOCK_DGRAM;
 321                                         pai->ai_protocol = IPPROTO_UDP;
 322                                 } else if (strcmp(sp->s_proto, "tcp") == 0) {
 323                                         pai->ai_socktype = SOCK_STREAM;
 324                                         pai->ai_protocol = IPPROTO_TCP;
 325                                 } else
 326                                         ERR(EAI_PROTOCOL);      /*xxx*/
 327                         }
 328                 }
 329         }
 330
 331         /*
 332          * hostname == NULL.
 333          * passive socket -> anyaddr (0.0.0.0 or ::)
 334          * non-passive socket -> localhost (127.0.0.1 or ::1)
 335          */
 336         if (hostname == NULL) {
 337                 struct afd *afd;
 338                 int s;
 339
 340                 for (afd = &afdl[0]; afd->a_af; afd++) {
 341                         if (!(pai->ai_family == PF_UNSPEC
 342                            || pai->ai_family == afd->a_af)) {
 343                                 continue;
 344                         }
 345
 346                         /*
 347                          * filter out AFs that are not supported by the kernel
 348                          * XXX errno?
 349                          */
 350                         s = socket(afd->a_af, SOCK_DGRAM, 0);
 351                         if (s < 0)
 352                                 continue;
 353                         close(s);
 354
 355                         if (pai->ai_flags & AI_PASSIVE) {
 356                                 GET_AI(cur->ai_next, afd, afd->a_addrany, port);
 357                                 /* xxx meaningless?
 358                                  * GET_CANONNAME(cur->ai_next, "anyaddr");
 359                                  */
 360                         } else {
 361                                 GET_AI(cur->ai_next, afd, afd->a_loopback,
 362                                         port);
 363                                 /* xxx meaningless?
 364                                  * GET_CANONNAME(cur->ai_next, "localhost");
 365                                  */
 366                         }
 367                         cur = cur->ai_next;
 368                 }
 369                 top = sentinel.ai_next;
 370                 if (top)
 371                         goto good;
 372                 else
 373                         ERR(EAI_FAMILY);
 374         }
 375
 376         /* hostname as numeric name */
 377         for (i = 0; afdl[i].a_af; i++) {
 378                 if (inet_pton(afdl[i].a_af, hostname, pton) == 1) {
 379                         u_long v4a;
 380                         u_char pfx;
 381
 382                         switch (afdl[i].a_af) {
 383                         case AF_INET:
 384                                 v4a = ntohl(((struct in_addr *)pton)->s_addr);
 385                                 if (IN_MULTICAST(v4a) || IN_EXPERIMENTAL(v4a))
 386                                         pai->ai_flags &= ~AI_CANONNAME;
 387                                 v4a >>= IN_CLASSA_NSHIFT;
 388                                 if (v4a == 0 || v4a == IN_LOOPBACKNET)
 389                                         pai->ai_flags &= ~AI_CANONNAME;
 390                                 break;
 391 #ifdef INET6
 392                         case AF_INET6:
 393                                 pfx = ((struct in6_addr *)pton)->s6_addr[0];
 394                                 if (pfx == 0 || pfx == 0xfe || pfx == 0xff)
 395                                         pai->ai_flags &= ~AI_CANONNAME;
 396                                 break;
 397 #endif
 398                         }
 399
 400                         if (pai->ai_family == afdl[i].a_af ||
 401                             pai->ai_family == PF_UNSPEC) {
 402                                 if (! (pai->ai_flags & AI_CANONNAME)) {
 403                                         GET_AI(top, &afdl[i], pton, port);
 404                                         goto good;
 405                                 }
 406                                 /*
 407                                  * if AI_CANONNAME and if reverse lookup
 408                                  * fail, return ai anyway to pacify
 409                                  * calling application.
 410                                  *
 411                                  * XXX getaddrinfo() is a name->address
 412                                  * translation function, and it looks strange
 413                                  * that we do addr->name translation here.
 414                                  */
 415                                 get_name(pton, &afdl[i], &top, pton, pai, port);
 416                                 goto good;
 417                         } else
 418                                 ERR(EAI_FAMILY);        /*xxx*/
 419                 }
 420         }
 421
 422         if (pai->ai_flags & AI_NUMERICHOST)
 423                 ERR(EAI_NONAME);
 424
 425         /* hostname as alphabetical name */
 426         error = get_addr(hostname, pai->ai_family, &top, pai, port);
 427         if (error == 0) {
 428                 if (top) {
 429  good:
 430                         *res = top;
 431                         return SUCCESS;
 432                 } else
 433                         error = EAI_FAIL;
 434         }
 435  free:
 436         if (top)
 437                 freeaddrinfo(top);
 438  bad:
 439         *res = NULL;
 440         return error;
 441 }
 442
 443 static int
 444 get_name(addr, afd, res, numaddr, pai, port0)
 445         const char *addr;
 446         struct afd *afd;
 447         struct addrinfo **res;
 448         char *numaddr;
 449         struct addrinfo *pai;
 450         int port0;
 451 {
 452         u_short port = port0 & 0xffff;
 453         struct hostent *hp;
 454         struct addrinfo *cur;
 455         int error = 0;
 456         hp = gethostbyaddr(addr, afd->a_addrlen, afd->a_af);
 457         if (hp && hp->h_name && hp->h_name[0] && hp->h_addr_list[0]) {
 458                 GET_AI(cur, afd, hp->h_addr_list[0], port);
 459                 GET_CANONNAME(cur, hp->h_name);
 460         } else
 461                 GET_AI(cur, afd, numaddr, port);
 462
 463         *res = cur;
 464         return SUCCESS;
 465  free:
 466         if (cur)
 467                 freeaddrinfo(cur);
 468
 469  /* bad: */
 470         *res = NULL;
 471         return error;
 472 }
 473
 474 static int
 475 get_addr(hostname, af, res0, pai, port0)
 476         const char *hostname;
 477         int af;
 478         struct addrinfo **res0;
 479         struct addrinfo *pai;
 480         int port0;
 481 {
 482         int i, error, ekeep;
 483         struct addrinfo *cur;
 484         struct addrinfo **res;
 485         int retry;
 486         int s;
 487
 488         res = res0;
 489         ekeep = 0;
 490         error = 0;
 491         for (i = 0; afdl[i].a_af; i++) {
 492                 retry = 0;
 493                 if (af == AF_UNSPEC) {
 494                         /*
 495                          * filter out AFs that are not supported by the kernel
 496                          * XXX errno?
 497                          */
 498                         s = socket(afdl[i].a_af, SOCK_DGRAM, 0);
 499                         if (s < 0)
 500                                 continue;
 501                         close(s);
 502                 } else {
 503                         if (af != afdl[i].a_af)
 504                                 continue;
 505                 }
 506                 /* It is WRONG, we need getipnodebyname(). */
 507 again:
 508                 error = get_addr0(hostname, afdl[i].a_af, res, pai, port0);
 509                 switch (error) {
 510                 case EAI_AGAIN:
 511                         if (++retry < 3)
 512                                 goto again;
 513                         /* FALL THROUGH*/
 514                 default:
 515                         if (ekeep == 0)
 516                                 ekeep = error;
 517                         break;
 518                 }
 519                 if (*res) {
 520                         /* make chain of addrs */
 521                         for (cur = *res;
 522                              cur && cur->ai_next;
 523                              cur = cur->ai_next)
 524                                 ;
 525                         if (!cur)
 526                                 return EAI_FAIL;
 527                         res = &cur->ai_next;
 528                 }
 529         }
 530
 531         /* if we got something, it's okay */
 532         if (*res0)
 533                 return 0;
 534
 535         return error ? error : ekeep;
 536 }
 537
 538 static int
 539 get_addr0(hostname, af, res, pai, port0)
 540         const char *hostname;
 541         int af;
 542         struct addrinfo **res;
 543         struct addrinfo *pai;
 544         int port0;
 545 {
 546         u_short port = port0 & 0xffff;
 547         struct addrinfo sentinel;
 548         struct hostent *hp;
 549         struct addrinfo *top, *cur;
 550         struct afd *afd;
 551         int i, error = 0, h_error;
 552         char *ap;
 553
 554         top = NULL;
 555         sentinel.ai_next = NULL;
 556         cur = &sentinel;
 557
 558 #ifdef HAVE_GETHOSTBYNAME2
 559         if (af == AF_UNSPEC) {
 560                 error = EAI_FAIL;
 561                 goto bad;
 562         }
 563         hp = gethostbyname2(hostname, af);
 564 #else
 565         if (af != AF_UNSPEC && af != AF_INET) {
 566                 error = EAI_FAIL;
 567                 goto bad;
 568         }
 569         hp = gethostbyname(hostname);
 570 #endif
 571         h_error = h_errno;
 572
 573         if (hp == NULL) {
 574                 switch (h_error) {
 575                 case HOST_NOT_FOUND:
 576                 case NO_DATA:
 577                         error = EAI_NODATA;
 578                         break;
 579                 case TRY_AGAIN:
 580                         error = EAI_AGAIN;
 581                         break;
 582                 case NO_RECOVERY:
 583                 case NETDB_INTERNAL:
 584                 default:
 585                         error = EAI_FAIL;
 586                         break;
 587                 }
 588                 goto bad;
 589         }
 590
 591         if ((hp->h_name == NULL) || (hp->h_name[0] == 0) ||
 592             (hp->h_addr_list[0] == NULL))
 593                 ERR(EAI_FAIL);
 594
 595         for (i = 0; (ap = hp->h_addr_list[i]) != NULL; i++) {
 596                 switch (af) {
 597 #ifdef INET6
 598                 case AF_INET6:
 599                         afd = &afdl[N_INET6];
 600                         break;
 601 #endif
 602 #ifndef INET6
 603                 default:        /* AF_UNSPEC */
 604 #endif
 605                 case AF_INET:
 606                         afd = &afdl[N_INET];
 607                         break;
 608 #ifdef INET6
 609                 default:        /* AF_UNSPEC */
 610                         if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)ap)) {
 611                                 ap += sizeof(struct in6_addr) -
 612                                         sizeof(struct in_addr);
 613                                 afd = &afdl[N_INET];
 614                         } else
 615                                 afd = &afdl[N_INET6];
 616                         break;
 617 #endif
 618                 }
 619                 GET_AI(cur->ai_next, afd, ap, port);
 620                 if (cur == &sentinel) {
 621                         top = cur->ai_next;
 622                         GET_CANONNAME(top, hp->h_name);
 623                 }
 624                 cur = cur->ai_next;
 625         }
 626         *res = top;
 627         return SUCCESS;
 628  free:
 629         if (top)
 630                 freeaddrinfo(top);
 631  bad:
 632         *res = NULL;
 633         return error;
 634 }