lib/libc/net/getaddrinfo.c

   1 /*      $KAME: getaddrinfo.c,v 1.15 2000/07/09 04:37:24 itojun Exp $    */
   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 /*
  33  * "#ifdef FAITH" part is local hack for supporting IPv4-v6 translator.
  34  *
  35  * Issues to be discussed:
  36  * - Return values.  There are nonstandard return values defined and used
  37  *   in the source code.  This is because RFC2553 is silent about which error
  38  *   code must be returned for which situation.
  39  * - freeaddrinfo(NULL).  RFC2553 is silent about it.  XNET 5.2 says it is
  40  *   invalid.  current code - SEGV on freeaddrinfo(NULL)
  41  *
  42  * Note:
  43  * - The code filters out AFs that are not supported by the kernel,
  44  *   when globbing NULL hostname (to loopback, or wildcard).  Is it the right
  45  *   thing to do?  What is the relationship with post-RFC2553 AI_ADDRCONFIG
  46  *   in ai_flags?
  47  * - (post-2553) semantics of AI_ADDRCONFIG itself is too vague.
  48  *   (1) what should we do against numeric hostname (2) what should we do
  49  *   against NULL hostname (3) what is AI_ADDRCONFIG itself.  AF not ready?
  50  *   non-loopback address configured?  global address configured?
  51  *
  52  * OS specific notes for freebsd4:
  53  * - FreeBSD supported $GAI.  The code does not.
  54  */
  55
  56 #include <sys/cdefs.h>
  57 __FBSDID("$FreeBSD$");
  58
  59 #include "namespace.h"
  60 #include <sys/types.h>
  61 #include <sys/param.h>
  62 #include <sys/socket.h>
  63 #include <net/if.h>
  64 #include <netinet/in.h>
  65 #include <net/if_types.h>
  66 #include <ifaddrs.h>
  67 #include <sys/queue.h>
  68 #ifdef INET6
  69 #include <net/if_var.h>
  70 #include <sys/sysctl.h>
  71 #include <sys/ioctl.h>
  72 #include <netinet6/in6_var.h>
  73 #include <netinet6/nd6.h>
  74 #endif
  75 #include <arpa/inet.h>
  76 #include <arpa/nameser.h>
  77 #include <rpc/rpc.h>
  78 #include <rpcsvc/yp_prot.h>
  79 #include <rpcsvc/ypclnt.h>
  80 #include <netdb.h>
  81 #include <resolv.h>
  82 #include <string.h>
  83 #include <stdlib.h>
  84 #include <stddef.h>
  85 #include <ctype.h>
  86 #include <unistd.h>
  87 #include <stdio.h>
  88 #include <errno.h>
  89
  90 #include "res_config.h"
  91
  92 #ifdef DEBUG
  93 #include <syslog.h>
  94 #endif
  95
  96 #include <stdarg.h>
  97 #include <nsswitch.h>
  98 #include "un-namespace.h"
  99 #include "netdb_private.h"
 100 #include "libc_private.h"
 101 #ifdef NS_CACHING
 102 #include "nscache.h"
 103 #endif
 104
 105 #if defined(__KAME__) && defined(INET6)
 106 # define FAITH
 107 #endif
 108
 109 #define ANY 0
 110 #define YES 1
 111 #define NO  0
 112
 113 static const char in_addrany[] = { 0, 0, 0, 0 };
 114 static const char in_loopback[] = { 127, 0, 0, 1 };
 115 #ifdef INET6
 116 static const char in6_addrany[] = {
 117         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 118 };
 119 static const char in6_loopback[] = {
 120         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
 121 };
 122 #endif
 123
 124 struct policyqueue {
 125         TAILQ_ENTRY(policyqueue) pc_entry;
 126 #ifdef INET6
 127         struct in6_addrpolicy pc_policy;
 128 #endif
 129 };
 130 TAILQ_HEAD(policyhead, policyqueue);
 131
 132 static const struct afd {
 133         int a_af;
 134         int a_addrlen;
 135         socklen_t a_socklen;
 136         int a_off;
 137         const char *a_addrany;
 138         const char *a_loopback;
 139         int a_scoped;
 140 } afdl [] = {
 141 #ifdef INET6
 142 #define N_INET6 0
 143         {PF_INET6, sizeof(struct in6_addr),
 144          sizeof(struct sockaddr_in6),
 145          offsetof(struct sockaddr_in6, sin6_addr),
 146          in6_addrany, in6_loopback, 1},
 147 #define N_INET 1
 148 #else
 149 #define N_INET 0
 150 #endif
 151         {PF_INET, sizeof(struct in_addr),
 152          sizeof(struct sockaddr_in),
 153          offsetof(struct sockaddr_in, sin_addr),
 154          in_addrany, in_loopback, 0},
 155         {0, 0, 0, 0, NULL, NULL, 0},
 156 };
 157
 158 struct explore {
 159         int e_af;
 160         int e_socktype;
 161         int e_protocol;
 162         int e_wild;
 163 #define WILD_AF(ex)             ((ex)->e_wild & 0x01)
 164 #define WILD_SOCKTYPE(ex)       ((ex)->e_wild & 0x02)
 165 #define WILD_PROTOCOL(ex)       ((ex)->e_wild & 0x04)
 166 };
 167
 168 static const struct explore explore[] = {
 169 #if 0
 170         { PF_LOCAL, ANY, ANY, 0x01 },
 171 #endif
 172 #ifdef INET6
 173         { PF_INET6, SOCK_DGRAM, IPPROTO_UDP, 0x07 },
 174         { PF_INET6, SOCK_STREAM, IPPROTO_TCP, 0x07 },
 175         { PF_INET6, SOCK_STREAM, IPPROTO_SCTP, 0x03 },
 176         { PF_INET6, SOCK_SEQPACKET, IPPROTO_SCTP, 0x07 },
 177         { PF_INET6, SOCK_DGRAM, IPPROTO_UDPLITE, 0x03 },
 178         { PF_INET6, SOCK_RAW, ANY, 0x05 },
 179 #endif
 180         { PF_INET, SOCK_DGRAM, IPPROTO_UDP, 0x07 },
 181         { PF_INET, SOCK_STREAM, IPPROTO_TCP, 0x07 },
 182         { PF_INET, SOCK_STREAM, IPPROTO_SCTP, 0x03 },
 183         { PF_INET, SOCK_SEQPACKET, IPPROTO_SCTP, 0x07 },
 184         { PF_INET, SOCK_DGRAM, IPPROTO_UDPLITE, 0x03 },
 185         { PF_INET, SOCK_RAW, ANY, 0x05 },
 186         { -1, 0, 0, 0 },
 187 };
 188
 189 #ifdef INET6
 190 #define PTON_MAX        16
 191 #else
 192 #define PTON_MAX        4
 193 #endif
 194
 195 #define AIO_SRCFLAG_DEPRECATED  0x1
 196
 197 struct ai_order {
 198         union {
 199                 struct sockaddr_storage aiou_ss;
 200                 struct sockaddr aiou_sa;
 201         } aio_src_un;
 202 #define aio_srcsa aio_src_un.aiou_sa
 203         u_int32_t aio_srcflag;
 204         int aio_srcscope;
 205         int aio_dstscope;
 206         struct policyqueue *aio_srcpolicy;
 207         struct policyqueue *aio_dstpolicy;
 208         struct addrinfo *aio_ai;
 209         int aio_matchlen;
 210 };
 211
 212 static const ns_src default_dns_files[] = {
 213         { NSSRC_FILES,  NS_SUCCESS },
 214         { NSSRC_DNS,    NS_SUCCESS },
 215         { 0 }
 216 };
 217
 218 struct res_target {
 219         struct res_target *next;
 220         const char *name;       /* domain name */
 221         int qclass, qtype;      /* class and type of query */
 222         u_char *answer;         /* buffer to put answer */
 223         int anslen;             /* size of answer buffer */
 224         int n;                  /* result length */
 225 };
 226
 227 #define MAXPACKET       (64*1024)
 228
 229 typedef union {
 230         HEADER hdr;
 231         u_char buf[MAXPACKET];
 232 } querybuf;
 233
 234 static int str2number(const char *, int *);
 235 static int explore_copy(const struct addrinfo *, const struct addrinfo *,
 236         struct addrinfo **);
 237 static int explore_null(const struct addrinfo *,
 238         const char *, struct addrinfo **);
 239 static int explore_numeric(const struct addrinfo *, const char *,
 240         const char *, struct addrinfo **, const char *);
 241 static int explore_numeric_scope(const struct addrinfo *, const char *,
 242         const char *, struct addrinfo **);
 243 static int get_canonname(const struct addrinfo *,
 244         struct addrinfo *, const char *);
 245 static struct addrinfo *get_ai(const struct addrinfo *,
 246         const struct afd *, const char *);
 247 static struct addrinfo *copy_ai(const struct addrinfo *);
 248 static int get_portmatch(const struct addrinfo *, const char *);
 249 static int get_port(struct addrinfo *, const char *, int);
 250 static const struct afd *find_afd(int);
 251 static int addrconfig(struct addrinfo *);
 252 #ifdef INET6
 253 static int is_ifdisabled(char *);
 254 #endif
 255 static void set_source(struct ai_order *, struct policyhead *);
 256 static int comp_dst(const void *, const void *);
 257 #ifdef INET6
 258 static int ip6_str2scopeid(char *, struct sockaddr_in6 *, u_int32_t *);
 259 #endif
 260 static int gai_addr2scopetype(struct sockaddr *);
 261
 262 static int explore_fqdn(const struct addrinfo *, const char *,
 263         const char *, struct addrinfo **);
 264
 265 static int reorder(struct addrinfo *);
 266 static int get_addrselectpolicy(struct policyhead *);
 267 static void free_addrselectpolicy(struct policyhead *);
 268 static struct policyqueue *match_addrselectpolicy(struct sockaddr *,
 269         struct policyhead *);
 270 static int matchlen(struct sockaddr *, struct sockaddr *);
 271
 272 static struct addrinfo *getanswer(const querybuf *, int, const char *, int,
 273         const struct addrinfo *, res_state);
 274 #if defined(RESOLVSORT)
 275 static int addr4sort(struct addrinfo *, res_state);
 276 #endif
 277 static int _dns_getaddrinfo(void *, void *, va_list);
 278 static void _sethtent(FILE **);
 279 static void _endhtent(FILE **);
 280 static struct addrinfo *_gethtent(FILE **, const char *,
 281         const struct addrinfo *);
 282 static int _files_getaddrinfo(void *, void *, va_list);
 283 #ifdef YP
 284 static struct addrinfo *_yphostent(char *, const struct addrinfo *);
 285 static int _yp_getaddrinfo(void *, void *, va_list);
 286 #endif
 287 #ifdef NS_CACHING
 288 static int addrinfo_id_func(char *, size_t *, va_list, void *);
 289 static int addrinfo_marshal_func(char *, size_t *, void *, va_list, void *);
 290 static int addrinfo_unmarshal_func(char *, size_t, void *, va_list, void *);
 291 #endif
 292
 293 static int res_queryN(const char *, struct res_target *, res_state);
 294 static int res_searchN(const char *, struct res_target *, res_state);
 295 static int res_querydomainN(const char *, const char *,
 296         struct res_target *, res_state);
 297
 298 /* XXX macros that make external reference is BAD. */
 299
 300 #define GET_AI(ai, afd, addr) \
 301 do { \
 302         /* external reference: pai, error, and label free */ \
 303         (ai) = get_ai(pai, (afd), (addr)); \
 304         if ((ai) == NULL) { \
 305                 error = EAI_MEMORY; \
 306                 goto free; \
 307         } \
 308 } while (/*CONSTCOND*/0)
 309
 310 #define GET_PORT(ai, serv) \
 311 do { \
 312         /* external reference: error and label free */ \
 313         error = get_port((ai), (serv), 0); \
 314         if (error != 0) \
 315                 goto free; \
 316 } while (/*CONSTCOND*/0)
 317
 318 #define GET_CANONNAME(ai, str) \
 319 do { \
 320         /* external reference: pai, error and label free */ \
 321         error = get_canonname(pai, (ai), (str)); \
 322         if (error != 0) \
 323                 goto free; \
 324 } while (/*CONSTCOND*/0)
 325
 326 #define ERR(err) \
 327 do { \
 328         /* external reference: error, and label bad */ \
 329         error = (err); \
 330         goto bad; \
 331         /*NOTREACHED*/ \
 332 } while (/*CONSTCOND*/0)
 333
 334 #define MATCH_FAMILY(x, y, w) \
 335         ((x) == (y) || (/*CONSTCOND*/(w) && ((x) == PF_UNSPEC || (y) == PF_UNSPEC)))
 336 #define MATCH(x, y, w) \
 337         ((x) == (y) || (/*CONSTCOND*/(w) && ((x) == ANY || (y) == ANY)))
 338
 339 void
 340 freeaddrinfo(struct addrinfo *ai)
 341 {
 342         struct addrinfo *next;
 343
 344         do {
 345                 next = ai->ai_next;
 346                 if (ai->ai_canonname)
 347                         free(ai->ai_canonname);
 348                 /* no need to free(ai->ai_addr) */
 349                 free(ai);
 350                 ai = next;
 351         } while (ai);
 352 }
 353
 354 static int
 355 str2number(const char *p, int *portp)
 356 {
 357         char *ep;
 358         unsigned long v;
 359
 360         if (*p == '\0')
 361                 return -1;
 362         ep = NULL;
 363         errno = 0;
 364         v = strtoul(p, &ep, 10);
 365         if (errno == 0 && ep && *ep == '\0' && v <= UINT_MAX) {
 366                 *portp = v;
 367                 return 0;
 368         } else
 369                 return -1;
 370 }
 371
 372 int
 373 getaddrinfo(const char *hostname, const char *servname,
 374     const struct addrinfo *hints, struct addrinfo **res)
 375 {
 376         struct addrinfo sentinel;
 377         struct addrinfo *cur;
 378         int error = 0;
 379         struct addrinfo ai, ai0, *afai;
 380         struct addrinfo *pai;
 381         const struct afd *afd;
 382         const struct explore *ex;
 383         struct addrinfo *afailist[sizeof(afdl)/sizeof(afdl[0])];
 384         struct addrinfo *afai_unspec;
 385         int found;
 386         int numeric = 0;
 387
 388         /* ensure we return NULL on errors */
 389         *res = NULL;
 390
 391         memset(&ai, 0, sizeof(ai));
 392
 393         memset(afailist, 0, sizeof(afailist));
 394         afai_unspec = NULL;
 395
 396         memset(&sentinel, 0, sizeof(sentinel));
 397         cur = &sentinel;
 398         pai = &ai;
 399         pai->ai_flags = 0;
 400         pai->ai_family = PF_UNSPEC;
 401         pai->ai_socktype = ANY;
 402         pai->ai_protocol = ANY;
 403         pai->ai_addrlen = 0;
 404         pai->ai_canonname = NULL;
 405         pai->ai_addr = NULL;
 406         pai->ai_next = NULL;
 407
 408         if (hostname == NULL && servname == NULL)
 409                 return EAI_NONAME;
 410         if (hints) {
 411                 /* error check for hints */
 412                 if (hints->ai_addrlen || hints->ai_canonname ||
 413                     hints->ai_addr || hints->ai_next)
 414                         ERR(EAI_BADHINTS); /* xxx */
 415                 if (hints->ai_flags & ~AI_MASK)
 416                         ERR(EAI_BADFLAGS);
 417                 switch (hints->ai_family) {
 418                 case PF_UNSPEC:
 419                 case PF_INET:
 420 #ifdef INET6
 421                 case PF_INET6:
 422 #endif
 423                         break;
 424                 default:
 425                         ERR(EAI_FAMILY);
 426                 }
 427                 memcpy(pai, hints, sizeof(*pai));
 428
 429                 /*
 430                  * if both socktype/protocol are specified, check if they
 431                  * are meaningful combination.
 432                  */
 433                 if (pai->ai_socktype != ANY && pai->ai_protocol != ANY) {
 434                         for (ex = explore; ex->e_af >= 0; ex++) {
 435                                 if (!MATCH_FAMILY(pai->ai_family, ex->e_af,
 436                                     WILD_AF(ex)))
 437                                         continue;
 438                                 if (!MATCH(pai->ai_socktype, ex->e_socktype,
 439                                     WILD_SOCKTYPE(ex)))
 440                                         continue;
 441                                 if (!MATCH(pai->ai_protocol, ex->e_protocol,
 442                                     WILD_PROTOCOL(ex)))
 443                                         continue;
 444
 445                                 /* matched */
 446                                 break;
 447                         }
 448
 449                         if (ex->e_af < 0)
 450                                 ERR(EAI_BADHINTS);
 451                 }
 452         }
 453
 454         /*
 455          * RFC 3493: AI_ALL and AI_V4MAPPED are effective only against
 456          * AF_INET6 query.  They need to be ignored if specified in other
 457          * occassions.
 458          */
 459         switch (pai->ai_flags & (AI_ALL | AI_V4MAPPED)) {
 460         case AI_V4MAPPED:
 461         case AI_ALL | AI_V4MAPPED:
 462 #ifdef INET6
 463                 if (pai->ai_family != AF_INET6)
 464                         pai->ai_flags &= ~(AI_ALL | AI_V4MAPPED);
 465                 break;
 466 #endif
 467         case AI_ALL:
 468                 pai->ai_flags &= ~(AI_ALL | AI_V4MAPPED);
 469                 break;
 470         }
 471
 472         /*
 473          * check for special cases.  (1) numeric servname is disallowed if
 474          * socktype/protocol are left unspecified. (2) servname is disallowed
 475          * for raw and other inet{,6} sockets.
 476          */
 477         if (MATCH_FAMILY(pai->ai_family, PF_INET, 1)
 478 #ifdef PF_INET6
 479             || MATCH_FAMILY(pai->ai_family, PF_INET6, 1)
 480 #endif
 481             ) {
 482                 ai0 = *pai;     /* backup *pai */
 483
 484                 if (pai->ai_family == PF_UNSPEC) {
 485 #ifdef PF_INET6
 486                         pai->ai_family = PF_INET6;
 487 #else
 488                         pai->ai_family = PF_INET;
 489 #endif
 490                 }
 491                 error = get_portmatch(pai, servname);
 492                 if (error)
 493                         goto bad;
 494
 495                 *pai = ai0;
 496         }
 497
 498         ai0 = *pai;
 499
 500         /*
 501          * NULL hostname, or numeric hostname.
 502          * If numeric representation of AF1 can be interpreted as FQDN
 503          * representation of AF2, we need to think again about the code below.
 504          */
 505         found = 0;
 506         for (afd = afdl; afd->a_af; afd++) {
 507                 *pai = ai0;
 508
 509                 if (!MATCH_FAMILY(pai->ai_family, afd->a_af, 1))
 510                         continue;
 511
 512                 if (pai->ai_family == PF_UNSPEC)
 513                         pai->ai_family = afd->a_af;
 514
 515                 if (hostname == NULL) {
 516                         error = explore_null(pai, servname,
 517                             &afailist[afd - afdl]);
 518
 519                         /*
 520                          * Errors from explore_null should be unexpected and
 521                          * be caught to avoid returning an incomplete result.
 522                          */
 523                         if (error != 0)
 524                                 goto bad;
 525                 } else {
 526                         error = explore_numeric_scope(pai, hostname, servname,
 527                             &afailist[afd - afdl]);
 528
 529                         /*
 530                          * explore_numeric_scope returns an error for address
 531                          * families that do not match that of hostname.
 532                          * Thus we should not catch the error at this moment.
 533                          */
 534                 }
 535
 536                 if (!error && afailist[afd - afdl])
 537                         found++;
 538         }
 539         if (found) {
 540                 numeric = 1;
 541                 goto globcopy;
 542         }
 543
 544         if (hostname == NULL)
 545                 ERR(EAI_NONAME);        /* used to be EAI_NODATA */
 546         if (pai->ai_flags & AI_NUMERICHOST)
 547                 ERR(EAI_NONAME);
 548
 549         if ((pai->ai_flags & AI_ADDRCONFIG) != 0 && !addrconfig(&ai0))
 550                 ERR(EAI_FAIL);
 551
 552         /*
 553          * hostname as alphabetical name.
 554          */
 555         *pai = ai0;
 556         error = explore_fqdn(pai, hostname, servname, &afai_unspec);
 557
 558 globcopy:
 559         for (ex = explore; ex->e_af >= 0; ex++) {
 560                 *pai = ai0;
 561
 562                 if (!MATCH_FAMILY(pai->ai_family, ex->e_af, WILD_AF(ex)))
 563                         continue;
 564                 if (!MATCH(pai->ai_socktype, ex->e_socktype,
 565                     WILD_SOCKTYPE(ex)))
 566                         continue;
 567                 if (!MATCH(pai->ai_protocol, ex->e_protocol,
 568                     WILD_PROTOCOL(ex)))
 569                         continue;
 570
 571                 if (pai->ai_family == PF_UNSPEC)
 572                         pai->ai_family = ex->e_af;
 573                 if (pai->ai_socktype == ANY && ex->e_socktype != ANY)
 574                         pai->ai_socktype = ex->e_socktype;
 575                 if (pai->ai_protocol == ANY && ex->e_protocol != ANY)
 576                         pai->ai_protocol = ex->e_protocol;
 577
 578                 /*
 579                  * if the servname does not match socktype/protocol, ignore it.
 580                  */
 581                 if (get_portmatch(pai, servname) != 0)
 582                         continue;
 583
 584                 if (afai_unspec)
 585                         afai = afai_unspec;
 586                 else {
 587                         if ((afd = find_afd(pai->ai_family)) == NULL)
 588                                 continue;
 589                         /* XXX assumes that afd points inside afdl[] */
 590                         afai = afailist[afd - afdl];
 591                 }
 592                 if (!afai)
 593                         continue;
 594
 595                 error = explore_copy(pai, afai, &cur->ai_next);
 596                 if (error != 0)
 597                         goto bad;
 598
 599                 while (cur && cur->ai_next)
 600                         cur = cur->ai_next;
 601         }
 602
 603         /*
 604          * ensure we return either:
 605          * - error == 0, non-NULL *res
 606          * - error != 0, NULL *res
 607          */
 608         if (error == 0) {
 609                 if (sentinel.ai_next) {
 610                         /*
 611                          * If the returned entry is for an active connection,
 612                          * and the given name is not numeric, reorder the
 613                          * list, so that the application would try the list
 614                          * in the most efficient order.  Since the head entry
 615                          * of the original list may contain ai_canonname and
 616                          * that entry may be moved elsewhere in the new list,
 617                          * we keep the pointer and will  restore it in the new
 618                          * head entry.  (Note that RFC3493 requires the head
 619                          * entry store it when requested by the caller).
 620                          */
 621                         if (hints == NULL || !(hints->ai_flags & AI_PASSIVE)) {
 622                                 if (!numeric) {
 623                                         char *canonname;
 624
 625                                         canonname =
 626                                             sentinel.ai_next->ai_canonname;
 627                                         sentinel.ai_next->ai_canonname = NULL;
 628                                         (void)reorder(&sentinel);
 629                                         if (sentinel.ai_next->ai_canonname ==
 630                                             NULL) {
 631                                                 sentinel.ai_next->ai_canonname
 632                                                     = canonname;
 633                                         } else if (canonname != NULL)
 634                                                 free(canonname);
 635                                 }
 636                         }
 637                         *res = sentinel.ai_next;
 638                 } else
 639                         error = EAI_FAIL;
 640         }
 641
 642 bad:
 643         if (afai_unspec)
 644                 freeaddrinfo(afai_unspec);
 645         for (afd = afdl; afd->a_af; afd++) {
 646                 if (afailist[afd - afdl])
 647                         freeaddrinfo(afailist[afd - afdl]);
 648         }
 649         if (!*res)
 650                 if (sentinel.ai_next)
 651                         freeaddrinfo(sentinel.ai_next);
 652
 653         return (error);
 654 }
 655
 656 static int
 657 reorder(struct addrinfo *sentinel)
 658 {
 659         struct addrinfo *ai, **aip;
 660         struct ai_order *aio;
 661         int i, n;
 662         struct policyhead policyhead;
 663
 664         /* count the number of addrinfo elements for sorting. */
 665         for (n = 0, ai = sentinel->ai_next; ai != NULL; ai = ai->ai_next, n++)
 666                 ;
 667
 668         /*
 669          * If the number is small enough, we can skip the reordering process.
 670          */
 671         if (n <= 1)
 672                 return(n);
 673
 674         /* allocate a temporary array for sort and initialization of it. */
 675         if ((aio = malloc(sizeof(*aio) * n)) == NULL)
 676                 return(n);      /* give up reordering */
 677         memset(aio, 0, sizeof(*aio) * n);
 678
 679         /* retrieve address selection policy from the kernel */
 680         TAILQ_INIT(&policyhead);
 681         if (!get_addrselectpolicy(&policyhead)) {
 682                 /* no policy is installed into kernel, we don't sort. */
 683                 free(aio);
 684                 return (n);
 685         }
 686
 687         for (i = 0, ai = sentinel->ai_next; i < n; ai = ai->ai_next, i++) {
 688                 aio[i].aio_ai = ai;
 689                 aio[i].aio_dstscope = gai_addr2scopetype(ai->ai_addr);
 690                 aio[i].aio_dstpolicy = match_addrselectpolicy(ai->ai_addr,
 691                                                               &policyhead);
 692                 set_source(&aio[i], &policyhead);
 693         }
 694
 695         /* perform sorting. */
 696         qsort(aio, n, sizeof(*aio), comp_dst);
 697
 698         /* reorder the addrinfo chain. */
 699         for (i = 0, aip = &sentinel->ai_next; i < n; i++) {
 700                 *aip = aio[i].aio_ai;
 701                 aip = &aio[i].aio_ai->ai_next;
 702         }
 703         *aip = NULL;
 704
 705         /* cleanup and return */
 706         free(aio);
 707         free_addrselectpolicy(&policyhead);
 708         return(n);
 709 }
 710
 711 static int
 712 get_addrselectpolicy(struct policyhead *head)
 713 {
 714 #ifdef INET6
 715         int mib[] = { CTL_NET, PF_INET6, IPPROTO_IPV6, IPV6CTL_ADDRCTLPOLICY };
 716         size_t l;
 717         char *buf;
 718         struct in6_addrpolicy *pol, *ep;
 719
 720         if (sysctl(mib, sizeof(mib) / sizeof(mib[0]), NULL, &l, NULL, 0) < 0)
 721                 return (0);
 722         if (l == 0)
 723                 return (0);
 724         if ((buf = malloc(l)) == NULL)
 725                 return (0);
 726         if (sysctl(mib, sizeof(mib) / sizeof(mib[0]), buf, &l, NULL, 0) < 0) {
 727                 free(buf);
 728                 return (0);
 729         }
 730
 731         ep = (struct in6_addrpolicy *)(buf + l);
 732         for (pol = (struct in6_addrpolicy *)buf; pol + 1 <= ep; pol++) {
 733                 struct policyqueue *new;
 734
 735                 if ((new = malloc(sizeof(*new))) == NULL) {
 736                         free_addrselectpolicy(head); /* make the list empty */
 737                         break;
 738                 }
 739                 new->pc_policy = *pol;
 740                 TAILQ_INSERT_TAIL(head, new, pc_entry);
 741         }
 742
 743         free(buf);
 744         return (1);
 745 #else
 746         return (0);
 747 #endif
 748 }
 749
 750 static void
 751 free_addrselectpolicy(struct policyhead *head)
 752 {
 753         struct policyqueue *ent, *nent;
 754
 755         for (ent = TAILQ_FIRST(head); ent; ent = nent) {
 756                 nent = TAILQ_NEXT(ent, pc_entry);
 757                 TAILQ_REMOVE(head, ent, pc_entry);
 758                 free(ent);
 759         }
 760 }
 761
 762 static struct policyqueue *
 763 match_addrselectpolicy(struct sockaddr *addr, struct policyhead *head)
 764 {
 765 #ifdef INET6
 766         struct policyqueue *ent, *bestent = NULL;
 767         struct in6_addrpolicy *pol;
 768         int matchlen, bestmatchlen = -1;
 769         u_char *mp, *ep, *k, *p, m;
 770         struct sockaddr_in6 key;
 771
 772         switch(addr->sa_family) {
 773         case AF_INET6:
 774                 key = *(struct sockaddr_in6 *)addr;
 775                 break;
 776         case AF_INET:
 777                 /* convert the address into IPv4-mapped IPv6 address. */
 778                 memset(&key, 0, sizeof(key));
 779                 key.sin6_family = AF_INET6;
 780                 key.sin6_len = sizeof(key);
 781                 _map_v4v6_address(
 782                     (char *)&((struct sockaddr_in *)addr)->sin_addr,
 783                     (char *)&key.sin6_addr);
 784                 break;
 785         default:
 786                 return(NULL);
 787         }
 788
 789         for (ent = TAILQ_FIRST(head); ent; ent = TAILQ_NEXT(ent, pc_entry)) {
 790                 pol = &ent->pc_policy;
 791                 matchlen = 0;
 792
 793                 mp = (u_char *)&pol->addrmask.sin6_addr;
 794                 ep = mp + 16;   /* XXX: scope field? */
 795                 k = (u_char *)&key.sin6_addr;
 796                 p = (u_char *)&pol->addr.sin6_addr;
 797                 for (; mp < ep && *mp; mp++, k++, p++) {
 798                         m = *mp;
 799                         if ((*k & m) != *p)
 800                                 goto next; /* not match */
 801                         if (m == 0xff) /* short cut for a typical case */
 802                                 matchlen += 8;
 803                         else {
 804                                 while (m >= 0x80) {
 805                                         matchlen++;
 806                                         m <<= 1;
 807                                 }
 808                         }
 809                 }
 810
 811                 /* matched.  check if this is better than the current best. */
 812                 if (matchlen > bestmatchlen) {
 813                         bestent = ent;
 814                         bestmatchlen = matchlen;
 815                 }
 816
 817           next:
 818                 continue;
 819         }
 820
 821         return(bestent);
 822 #else
 823         return(NULL);
 824 #endif
 825
 826 }
 827
 828 static void
 829 set_source(struct ai_order *aio, struct policyhead *ph)
 830 {
 831         struct addrinfo ai = *aio->aio_ai;
 832         struct sockaddr_storage ss;
 833         socklen_t srclen;
 834         int s;
 835
 836         /* set unspec ("no source is available"), just in case */
 837         aio->aio_srcsa.sa_family = AF_UNSPEC;
 838         aio->aio_srcscope = -1;
 839
 840         switch(ai.ai_family) {
 841         case AF_INET:
 842 #ifdef INET6
 843         case AF_INET6:
 844 #endif
 845                 break;
 846         default:                /* ignore unsupported AFs explicitly */
 847                 return;
 848         }
 849
 850         /* XXX: make a dummy addrinfo to call connect() */
 851         ai.ai_socktype = SOCK_DGRAM;
 852         ai.ai_protocol = IPPROTO_UDP; /* is UDP too specific? */
 853         ai.ai_next = NULL;
 854         memset(&ss, 0, sizeof(ss));
 855         memcpy(&ss, ai.ai_addr, ai.ai_addrlen);
 856         ai.ai_addr = (struct sockaddr *)&ss;
 857         get_port(&ai, "1", 0);
 858
 859         /* open a socket to get the source address for the given dst */
 860         if ((s = _socket(ai.ai_family, ai.ai_socktype | SOCK_CLOEXEC,
 861             ai.ai_protocol)) < 0)
 862                 return;         /* give up */
 863 #ifdef INET6
 864         if (ai.ai_family == AF_INET6) {
 865                 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)ai.ai_addr;
 866                 int off = 0;
 867
 868                 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr))
 869                         (void)_setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY,
 870                             (char *)&off, sizeof(off));
 871         }
 872 #endif
 873         if (_connect(s, ai.ai_addr, ai.ai_addrlen) < 0)
 874                 goto cleanup;
 875         srclen = ai.ai_addrlen;
 876         if (_getsockname(s, &aio->aio_srcsa, &srclen) < 0) {
 877                 aio->aio_srcsa.sa_family = AF_UNSPEC;
 878                 goto cleanup;
 879         }
 880         aio->aio_srcscope = gai_addr2scopetype(&aio->aio_srcsa);
 881         aio->aio_srcpolicy = match_addrselectpolicy(&aio->aio_srcsa, ph);
 882         aio->aio_matchlen = matchlen(&aio->aio_srcsa, aio->aio_ai->ai_addr);
 883 #ifdef INET6
 884         if (ai.ai_family == AF_INET6) {
 885                 struct in6_ifreq ifr6;
 886                 u_int32_t flags6;
 887
 888                 memset(&ifr6, 0, sizeof(ifr6));
 889                 memcpy(&ifr6.ifr_addr, ai.ai_addr, ai.ai_addrlen);
 890                 if (_ioctl(s, SIOCGIFAFLAG_IN6, &ifr6) == 0) {
 891                         flags6 = ifr6.ifr_ifru.ifru_flags6;
 892                         if ((flags6 & IN6_IFF_DEPRECATED))
 893                                 aio->aio_srcflag |= AIO_SRCFLAG_DEPRECATED;
 894                 }
 895         }
 896 #endif
 897
 898   cleanup:
 899         _close(s);
 900         return;
 901 }
 902
 903 static int
 904 matchlen(struct sockaddr *src, struct sockaddr *dst)
 905 {
 906         int match = 0;
 907         u_char *s, *d;
 908         u_char *lim, r;
 909         int addrlen;
 910
 911         switch (src->sa_family) {
 912 #ifdef INET6
 913         case AF_INET6:
 914                 s = (u_char *)&((struct sockaddr_in6 *)src)->sin6_addr;
 915                 d = (u_char *)&((struct sockaddr_in6 *)dst)->sin6_addr;
 916                 addrlen = sizeof(struct in6_addr);
 917                 lim = s + addrlen;
 918                 break;
 919 #endif
 920         case AF_INET:
 921                 s = (u_char *)&((struct sockaddr_in *)src)->sin_addr;
 922                 d = (u_char *)&((struct sockaddr_in *)dst)->sin_addr;
 923                 addrlen = sizeof(struct in_addr);
 924                 lim = s + addrlen;
 925                 break;
 926         default:
 927                 return(0);
 928         }
 929
 930         while (s < lim)
 931                 if ((r = (*d++ ^ *s++)) != 0) {
 932                         while (r < addrlen * 8) {
 933                                 match++;
 934                                 r <<= 1;
 935                         }
 936                         break;
 937                 } else
 938                         match += 8;
 939         return(match);
 940 }
 941
 942 static int
 943 comp_dst(const void *arg1, const void *arg2)
 944 {
 945         const struct ai_order *dst1 = arg1, *dst2 = arg2;
 946
 947         /*
 948          * Rule 1: Avoid unusable destinations.
 949          * XXX: we currently do not consider if an appropriate route exists.
 950          */
 951         if (dst1->aio_srcsa.sa_family != AF_UNSPEC &&
 952             dst2->aio_srcsa.sa_family == AF_UNSPEC) {
 953                 return(-1);
 954         }
 955         if (dst1->aio_srcsa.sa_family == AF_UNSPEC &&
 956             dst2->aio_srcsa.sa_family != AF_UNSPEC) {
 957                 return(1);
 958         }
 959
 960         /* Rule 2: Prefer matching scope. */
 961         if (dst1->aio_dstscope == dst1->aio_srcscope &&
 962             dst2->aio_dstscope != dst2->aio_srcscope) {
 963                 return(-1);
 964         }
 965         if (dst1->aio_dstscope != dst1->aio_srcscope &&
 966             dst2->aio_dstscope == dst2->aio_srcscope) {
 967                 return(1);
 968         }
 969
 970         /* Rule 3: Avoid deprecated addresses. */
 971         if (dst1->aio_srcsa.sa_family != AF_UNSPEC &&
 972             dst2->aio_srcsa.sa_family != AF_UNSPEC) {
 973                 if (!(dst1->aio_srcflag & AIO_SRCFLAG_DEPRECATED) &&
 974                     (dst2->aio_srcflag & AIO_SRCFLAG_DEPRECATED)) {
 975                         return(-1);
 976                 }
 977                 if ((dst1->aio_srcflag & AIO_SRCFLAG_DEPRECATED) &&
 978                     !(dst2->aio_srcflag & AIO_SRCFLAG_DEPRECATED)) {
 979                         return(1);
 980                 }
 981         }
 982
 983         /* Rule 4: Prefer home addresses. */
 984         /* XXX: not implemented yet */
 985
 986         /* Rule 5: Prefer matching label. */
 987 #ifdef INET6
 988         if (dst1->aio_srcpolicy && dst1->aio_dstpolicy &&
 989             dst1->aio_srcpolicy->pc_policy.label ==
 990             dst1->aio_dstpolicy->pc_policy.label &&
 991             (dst2->aio_srcpolicy == NULL || dst2->aio_dstpolicy == NULL ||
 992              dst2->aio_srcpolicy->pc_policy.label !=
 993              dst2->aio_dstpolicy->pc_policy.label)) {
 994                 return(-1);
 995         }
 996         if (dst2->aio_srcpolicy && dst2->aio_dstpolicy &&
 997             dst2->aio_srcpolicy->pc_policy.label ==
 998             dst2->aio_dstpolicy->pc_policy.label &&
 999             (dst1->aio_srcpolicy == NULL || dst1->aio_dstpolicy == NULL ||
1000              dst1->aio_srcpolicy->pc_policy.label !=
1001              dst1->aio_dstpolicy->pc_policy.label)) {
1002                 return(1);
1003         }
1004 #endif
1005
1006         /* Rule 6: Prefer higher precedence. */
1007 #ifdef INET6
1008         if (dst1->aio_dstpolicy &&
1009             (dst2->aio_dstpolicy == NULL ||
1010              dst1->aio_dstpolicy->pc_policy.preced >
1011              dst2->aio_dstpolicy->pc_policy.preced)) {
1012                 return(-1);
1013         }
1014         if (dst2->aio_dstpolicy &&
1015             (dst1->aio_dstpolicy == NULL ||
1016              dst2->aio_dstpolicy->pc_policy.preced >
1017              dst1->aio_dstpolicy->pc_policy.preced)) {
1018                 return(1);
1019         }
1020 #endif
1021
1022         /* Rule 7: Prefer native transport. */
1023         /* XXX: not implemented yet */
1024
1025         /* Rule 8: Prefer smaller scope. */
1026         if (dst1->aio_dstscope >= 0 &&
1027             dst1->aio_dstscope < dst2->aio_dstscope) {
1028                 return(-1);
1029         }
1030         if (dst2->aio_dstscope >= 0 &&
1031             dst2->aio_dstscope < dst1->aio_dstscope) {
1032                 return(1);
1033         }
1034
1035         /*
1036          * Rule 9: Use longest matching prefix.
1037          * We compare the match length in a same AF only.
1038          */
1039         if (dst1->aio_ai->ai_addr->sa_family ==
1040             dst2->aio_ai->ai_addr->sa_family &&
1041             dst1->aio_ai->ai_addr->sa_family != AF_INET) {
1042                 if (dst1->aio_matchlen > dst2->aio_matchlen) {
1043                         return(-1);
1044                 }
1045                 if (dst1->aio_matchlen < dst2->aio_matchlen) {
1046                         return(1);
1047                 }
1048         }
1049
1050         /* Rule 10: Otherwise, leave the order unchanged. */
1051         return(-1);
1052 }
1053
1054 /*
1055  * Copy from scope.c.
1056  * XXX: we should standardize the functions and link them as standard
1057  * library.
1058  */
1059 static int
1060 gai_addr2scopetype(struct sockaddr *sa)
1061 {
1062 #ifdef INET6
1063         struct sockaddr_in6 *sa6;
1064 #endif
1065         struct sockaddr_in *sa4;
1066
1067         switch(sa->sa_family) {
1068 #ifdef INET6
1069         case AF_INET6:
1070                 sa6 = (struct sockaddr_in6 *)sa;
1071                 if (IN6_IS_ADDR_MULTICAST(&sa6->sin6_addr)) {
1072                         /* just use the scope field of the multicast address */
1073                         return(sa6->sin6_addr.s6_addr[2] & 0x0f);
1074                 }
1075                 /*
1076                  * Unicast addresses: map scope type to corresponding scope
1077                  * value defined for multcast addresses.
1078                  * XXX: hardcoded scope type values are bad...
1079                  */
1080                 if (IN6_IS_ADDR_LOOPBACK(&sa6->sin6_addr))
1081                         return(1); /* node local scope */
1082                 if (IN6_IS_ADDR_LINKLOCAL(&sa6->sin6_addr))
1083                         return(2); /* link-local scope */
1084                 if (IN6_IS_ADDR_SITELOCAL(&sa6->sin6_addr))
1085                         return(5); /* site-local scope */
1086                 return(14);     /* global scope */
1087                 break;
1088 #endif
1089         case AF_INET:
1090                 /*
1091                  * IPv4 pseudo scoping according to RFC 3484.
1092                  */
1093                 sa4 = (struct sockaddr_in *)sa;
1094                 /* IPv4 autoconfiguration addresses have link-local scope. */
1095                 if (((u_char *)&sa4->sin_addr)[0] == 169 &&
1096                     ((u_char *)&sa4->sin_addr)[1] == 254)
1097                         return(2);
1098                 /* Private addresses have site-local scope. */
1099                 if (((u_char *)&sa4->sin_addr)[0] == 10 ||
1100                     (((u_char *)&sa4->sin_addr)[0] == 172 &&
1101                      (((u_char *)&sa4->sin_addr)[1] & 0xf0) == 16) ||
1102                     (((u_char *)&sa4->sin_addr)[0] == 192 &&
1103                      ((u_char *)&sa4->sin_addr)[1] == 168))
1104                         return(14);     /* XXX: It should be 5 unless NAT */
1105                 /* Loopback addresses have link-local scope. */
1106                 if (((u_char *)&sa4->sin_addr)[0] == 127)
1107                         return(2);
1108                 return(14);
1109                 break;
1110         default:
1111                 errno = EAFNOSUPPORT; /* is this a good error? */
1112                 return(-1);
1113         }
1114 }
1115
1116 static int
1117 explore_copy(const struct addrinfo *pai, const struct addrinfo *src0,
1118     struct addrinfo **res)
1119 {
1120         int error;
1121         struct addrinfo sentinel, *cur;
1122         const struct addrinfo *src;
1123
1124         error = 0;
1125         sentinel.ai_next = NULL;
1126         cur = &sentinel;
1127
1128         for (src = src0; src != NULL; src = src->ai_next) {
1129                 if (src->ai_family != pai->ai_family)
1130                         continue;
1131
1132                 cur->ai_next = copy_ai(src);
1133                 if (!cur->ai_next) {
1134                         error = EAI_MEMORY;
1135                         goto fail;
1136                 }
1137
1138                 cur->ai_next->ai_socktype = pai->ai_socktype;
1139                 cur->ai_next->ai_protocol = pai->ai_protocol;
1140                 cur = cur->ai_next;
1141         }
1142
1143         *res = sentinel.ai_next;
1144         return 0;
1145
1146 fail:
1147         freeaddrinfo(sentinel.ai_next);
1148         return error;
1149 }
1150
1151 /*
1152  * hostname == NULL.
1153  * passive socket -> anyaddr (0.0.0.0 or ::)
1154  * non-passive socket -> localhost (127.0.0.1 or ::1)
1155  */
1156 static int
1157 explore_null(const struct addrinfo *pai, const char *servname,
1158     struct addrinfo **res)
1159 {
1160         int s;
1161         const struct afd *afd;
1162         struct addrinfo *ai;
1163         int error;
1164
1165         *res = NULL;
1166         ai = NULL;
1167
1168         /*
1169          * filter out AFs that are not supported by the kernel
1170          * XXX errno?
1171          */
1172         s = _socket(pai->ai_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1173         if (s < 0) {
1174                 if (errno != EMFILE)
1175                         return 0;
1176         } else
1177                 _close(s);
1178
1179         afd = find_afd(pai->ai_family);
1180         if (afd == NULL)
1181                 return 0;
1182
1183         if (pai->ai_flags & AI_PASSIVE) {
1184                 GET_AI(ai, afd, afd->a_addrany);
1185                 GET_PORT(ai, servname);
1186         } else {
1187                 GET_AI(ai, afd, afd->a_loopback);
1188                 GET_PORT(ai, servname);
1189         }
1190
1191         *res = ai;
1192         return 0;
1193
1194 free:
1195         if (ai != NULL)
1196                 freeaddrinfo(ai);
1197         return error;
1198 }
1199
1200 /*
1201  * numeric hostname
1202  */
1203 static int
1204 explore_numeric(const struct addrinfo *pai, const char *hostname,
1205     const char *servname, struct addrinfo **res, const char *canonname)
1206 {
1207         const struct afd *afd;
1208         struct addrinfo *ai, ai0;
1209         int error;
1210         char pton[PTON_MAX];
1211
1212         *res = NULL;
1213         ai = NULL;
1214
1215         afd = find_afd(pai->ai_family);
1216         if (afd == NULL)
1217                 return 0;
1218
1219         switch (afd->a_af) {
1220         case AF_INET:
1221                 /*
1222                  * RFC3493 requires getaddrinfo() to accept AF_INET formats
1223                  * that are accepted by inet_addr() and its family.  The
1224                  * accepted forms includes the "classful" one, which inet_pton
1225                  * does not accept.  So we need to separate the case for
1226                  * AF_INET.
1227                  */
1228                 if (inet_aton(hostname, (struct in_addr *)pton) != 1)
1229                         return 0;
1230                 break;
1231         default:
1232                 if (inet_pton(afd->a_af, hostname, pton) != 1) {
1233                         if (pai->ai_family != AF_INET6 ||
1234                             (pai->ai_flags & AI_V4MAPPED) != AI_V4MAPPED)
1235                                 return 0;
1236                         if (inet_aton(hostname, (struct in_addr *)pton) != 1)
1237                                 return 0;
1238                         afd = &afdl[N_INET];
1239                         ai0 = *pai;
1240                         ai0.ai_family = AF_INET;
1241                         pai = &ai0;
1242                 }
1243                 break;
1244         }
1245
1246         if (pai->ai_family == afd->a_af) {
1247                 GET_AI(ai, afd, pton);
1248                 GET_PORT(ai, servname);
1249                 if ((pai->ai_flags & AI_CANONNAME)) {
1250                         /*
1251                          * Set the numeric address itself as the canonical
1252                          * name, based on a clarification in RFC3493.
1253                          */
1254                         GET_CANONNAME(ai, canonname);
1255                 }
1256         } else {
1257                 /*
1258                  * XXX: This should not happen since we already matched the AF
1259                  * by find_afd.
1260                  */
1261                 ERR(EAI_FAMILY);
1262         }
1263
1264         *res = ai;
1265         return 0;
1266
1267 free:
1268 bad:
1269         if (ai != NULL)
1270                 freeaddrinfo(ai);
1271         return error;
1272 }
1273
1274 /*
1275  * numeric hostname with scope
1276  */
1277 static int
1278 explore_numeric_scope(const struct addrinfo *pai, const char *hostname,
1279     const char *servname, struct addrinfo **res)
1280 {
1281 #if !defined(SCOPE_DELIMITER) || !defined(INET6)
1282         return explore_numeric(pai, hostname, servname, res, hostname);
1283 #else
1284         const struct afd *afd;
1285         struct addrinfo *cur;
1286         int error;
1287         char *cp, *hostname2 = NULL, *scope, *addr;
1288         struct sockaddr_in6 *sin6;
1289
1290         afd = find_afd(pai->ai_family);
1291         if (afd == NULL)
1292                 return 0;
1293
1294         if (!afd->a_scoped)
1295                 return explore_numeric(pai, hostname, servname, res, hostname);
1296
1297         cp = strchr(hostname, SCOPE_DELIMITER);
1298         if (cp == NULL)
1299                 return explore_numeric(pai, hostname, servname, res, hostname);
1300
1301         /*
1302          * Handle special case of <scoped_address><delimiter><scope id>
1303          */
1304         hostname2 = strdup(hostname);
1305         if (hostname2 == NULL)
1306                 return EAI_MEMORY;
1307         /* terminate at the delimiter */
1308         hostname2[cp - hostname] = '\0';
1309         addr = hostname2;
1310         scope = cp + 1;
1311
1312         error = explore_numeric(pai, addr, servname, res, hostname);
1313         if (error == 0) {
1314                 u_int32_t scopeid;
1315
1316                 for (cur = *res; cur; cur = cur->ai_next) {
1317                         if (cur->ai_family != AF_INET6)
1318                                 continue;
1319                         sin6 = (struct sockaddr_in6 *)(void *)cur->ai_addr;
1320                         if (ip6_str2scopeid(scope, sin6, &scopeid) == -1) {
1321                                 free(hostname2);
1322                                 freeaddrinfo(*res);
1323                                 *res = NULL;
1324                                 return(EAI_NONAME); /* XXX: is return OK? */
1325                         }
1326                         sin6->sin6_scope_id = scopeid;
1327                 }
1328         }
1329
1330         free(hostname2);
1331
1332         if (error && *res) {
1333                 freeaddrinfo(*res);
1334                 *res = NULL;
1335         }
1336         return error;
1337 #endif
1338 }
1339
1340 static int
1341 get_canonname(const struct addrinfo *pai, struct addrinfo *ai, const char *str)
1342 {
1343         if ((pai->ai_flags & AI_CANONNAME) != 0) {
1344                 ai->ai_canonname = strdup(str);
1345                 if (ai->ai_canonname == NULL)
1346                         return EAI_MEMORY;
1347         }
1348         return 0;
1349 }
1350
1351 static struct addrinfo *
1352 get_ai(const struct addrinfo *pai, const struct afd *afd, const char *addr)
1353 {
1354         char *p;
1355         struct addrinfo *ai;
1356 #ifdef FAITH
1357         struct in6_addr faith_prefix;
1358         char *fp_str;
1359         int translate = 0;
1360 #endif
1361 #ifdef INET6
1362         struct in6_addr mapaddr;
1363 #endif
1364
1365 #ifdef FAITH
1366         /*
1367          * Transfrom an IPv4 addr into a special IPv6 addr format for
1368          * IPv6->IPv4 translation gateway. (only TCP is supported now)
1369          *
1370          * +-----------------------------------+------------+
1371          * | faith prefix part (12 bytes)      | embedded   |
1372          * |                                   | IPv4 addr part (4 bytes)
1373          * +-----------------------------------+------------+
1374          *
1375          * faith prefix part is specified as ascii IPv6 addr format
1376          * in environmental variable GAI.
1377          * For FAITH to work correctly, routing to faith prefix must be
1378          * setup toward a machine where a FAITH daemon operates.
1379          * Also, the machine must enable some mechanizm
1380          * (e.g. faith interface hack) to divert those packet with
1381          * faith prefixed destination addr to user-land FAITH daemon.
1382          */
1383         fp_str = getenv("GAI");
1384         if (fp_str && inet_pton(AF_INET6, fp_str, &faith_prefix) == 1 &&
1385             afd->a_af == AF_INET && pai->ai_socktype == SOCK_STREAM) {
1386                 u_int32_t v4a;
1387                 u_int8_t v4a_top;
1388
1389                 memcpy(&v4a, addr, sizeof v4a);
1390                 v4a_top = v4a >> IN_CLASSA_NSHIFT;
1391                 if (!IN_MULTICAST(v4a) && !IN_EXPERIMENTAL(v4a) &&
1392                     v4a_top != 0 && v4a != IN_LOOPBACKNET) {
1393                         afd = &afdl[N_INET6];
1394                         memcpy(&faith_prefix.s6_addr[12], addr,
1395                                sizeof(struct in_addr));
1396                         translate = 1;
1397                 }
1398         }
1399 #endif
1400
1401 #ifdef INET6
1402         if (afd->a_af == AF_INET && (pai->ai_flags & AI_V4MAPPED) != 0) {
1403                 afd = &afdl[N_INET6];
1404                 _map_v4v6_address(addr, (char *)&mapaddr);
1405                 addr = (char *)&mapaddr;
1406         }
1407 #endif
1408
1409         ai = (struct addrinfo *)malloc(sizeof(struct addrinfo)
1410                 + (afd->a_socklen));
1411         if (ai == NULL)
1412                 return NULL;
1413
1414         memcpy(ai, pai, sizeof(struct addrinfo));
1415         ai->ai_addr = (struct sockaddr *)(void *)(ai + 1);
1416         memset(ai->ai_addr, 0, (size_t)afd->a_socklen);
1417         ai->ai_addr->sa_len = afd->a_socklen;
1418         ai->ai_addrlen = afd->a_socklen;
1419         ai->ai_addr->sa_family = ai->ai_family = afd->a_af;
1420         p = (char *)(void *)(ai->ai_addr);
1421 #ifdef FAITH
1422         if (translate == 1)
1423                 memcpy(p + afd->a_off, &faith_prefix, (size_t)afd->a_addrlen);
1424         else
1425 #endif
1426         memcpy(p + afd->a_off, addr, (size_t)afd->a_addrlen);
1427         return ai;
1428 }
1429
1430 /* XXX need to malloc() the same way we do from other functions! */
1431 static struct addrinfo *
1432 copy_ai(const struct addrinfo *pai)
1433 {
1434         struct addrinfo *ai;
1435         size_t l;
1436
1437         l = sizeof(*ai) + pai->ai_addrlen;
1438         if ((ai = (struct addrinfo *)malloc(l)) == NULL)
1439                 return NULL;
1440         memset(ai, 0, l);
1441         memcpy(ai, pai, sizeof(*ai));
1442         ai->ai_addr = (struct sockaddr *)(void *)(ai + 1);
1443         memcpy(ai->ai_addr, pai->ai_addr, pai->ai_addrlen);
1444
1445         if (pai->ai_canonname) {
1446                 l = strlen(pai->ai_canonname) + 1;
1447                 if ((ai->ai_canonname = malloc(l)) == NULL) {
1448                         free(ai);
1449                         return NULL;
1450                 }
1451                 strlcpy(ai->ai_canonname, pai->ai_canonname, l);
1452         } else {
1453                 /* just to make sure */
1454                 ai->ai_canonname = NULL;
1455         }
1456
1457         ai->ai_next = NULL;
1458
1459         return ai;
1460 }
1461
1462 static int
1463 get_portmatch(const struct addrinfo *ai, const char *servname)
1464 {
1465
1466         /* get_port does not touch first argument when matchonly == 1. */
1467         /* LINTED const cast */
1468         return get_port((struct addrinfo *)ai, servname, 1);
1469 }
1470
1471 static int
1472 get_port(struct addrinfo *ai, const char *servname, int matchonly)
1473 {
1474         const char *proto;
1475         struct servent *sp;
1476         int port, error;
1477         int allownumeric;
1478
1479         if (servname == NULL)
1480                 return 0;
1481         switch (ai->ai_family) {
1482         case AF_INET:
1483 #ifdef AF_INET6
1484         case AF_INET6:
1485 #endif
1486                 break;
1487         default:
1488                 return 0;
1489         }
1490
1491         switch (ai->ai_socktype) {
1492         case SOCK_RAW:
1493                 return EAI_SERVICE;
1494         case SOCK_DGRAM:
1495         case SOCK_STREAM:
1496         case SOCK_SEQPACKET:
1497                 allownumeric = 1;
1498                 break;
1499         case ANY:
1500                 switch (ai->ai_family) {
1501                 case AF_INET:
1502 #ifdef AF_INET6
1503                 case AF_INET6:
1504 #endif
1505                         allownumeric = 1;
1506                         break;
1507                 default:
1508                         allownumeric = 0;
1509                         break;
1510                 }
1511                 break;
1512         default:
1513                 return EAI_SOCKTYPE;
1514         }
1515
1516         error = str2number(servname, &port);
1517         if (error == 0) {
1518                 if (!allownumeric)
1519                         return EAI_SERVICE;
1520                 if (port < 0 || port > 65535)
1521                         return EAI_SERVICE;
1522                 port = htons(port);
1523         } else {
1524                 if (ai->ai_flags & AI_NUMERICSERV)
1525                         return EAI_NONAME;
1526
1527                 switch (ai->ai_protocol) {
1528                 case IPPROTO_UDP:
1529                         proto = "udp";
1530                         break;
1531                 case IPPROTO_TCP:
1532                         proto = "tcp";
1533                         break;
1534                 case IPPROTO_SCTP:
1535                         proto = "sctp";
1536                         break;
1537                 case IPPROTO_UDPLITE:
1538                         proto = "udplite";
1539                         break;
1540                 default:
1541                         proto = NULL;
1542                         break;
1543                 }
1544
1545                 if ((sp = getservbyname(servname, proto)) == NULL)
1546                         return EAI_SERVICE;
1547                 port = sp->s_port;
1548         }
1549
1550         if (!matchonly) {
1551                 switch (ai->ai_family) {
1552                 case AF_INET:
1553                         ((struct sockaddr_in *)(void *)
1554                             ai->ai_addr)->sin_port = port;
1555                         break;
1556 #ifdef INET6
1557                 case AF_INET6:
1558                         ((struct sockaddr_in6 *)(void *)
1559                             ai->ai_addr)->sin6_port = port;
1560                         break;
1561 #endif
1562                 }
1563         }
1564
1565         return 0;
1566 }
1567
1568 static const struct afd *
1569 find_afd(int af)
1570 {
1571         const struct afd *afd;
1572
1573         if (af == PF_UNSPEC)
1574                 return NULL;
1575         for (afd = afdl; afd->a_af; afd++) {
1576                 if (afd->a_af == af)
1577                         return afd;
1578         }
1579         return NULL;
1580 }
1581
1582 /*
1583  * RFC 3493: AI_ADDRCONFIG check.  Determines which address families are
1584  * configured on the local system and correlates with pai->ai_family value.
1585  * If an address family is not configured on the system, it will not be
1586  * queried for.  For this purpose, loopback addresses are not considered
1587  * configured addresses.
1588  *
1589  * XXX PF_UNSPEC -> PF_INET6 + PF_INET mapping needs to be in sync with
1590  * _dns_getaddrinfo.
1591  */
1592 static int
1593 addrconfig(struct addrinfo *pai)
1594 {
1595         struct ifaddrs *ifaddrs, *ifa;
1596         struct sockaddr_in *sin;
1597 #ifdef INET6
1598         struct sockaddr_in6 *sin6;
1599 #endif
1600         int seen_inet = 0, seen_inet6 = 0;
1601
1602         if (getifaddrs(&ifaddrs) != 0)
1603                 return (0);
1604
1605         for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
1606                 if (ifa->ifa_addr == NULL || (ifa->ifa_flags & IFF_UP) == 0)
1607                         continue;
1608                 switch (ifa->ifa_addr->sa_family) {
1609                 case AF_INET:
1610                         if (seen_inet)
1611                                 continue;
1612                         sin = (struct sockaddr_in *)(ifa->ifa_addr);
1613                         if (htonl(sin->sin_addr.s_addr) == INADDR_LOOPBACK)
1614                                 continue;
1615                         seen_inet = 1;
1616                         break;
1617 #ifdef INET6
1618                 case AF_INET6:
1619                         if (seen_inet6)
1620                                 continue;
1621                         sin6 = (struct sockaddr_in6 *)(ifa->ifa_addr);
1622                         if (IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr))
1623                                 continue;
1624                         if ((ifa->ifa_flags & IFT_LOOP) != 0 &&
1625                             IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr))
1626                                 continue;
1627                         if (is_ifdisabled(ifa->ifa_name))
1628                                 continue;
1629                         seen_inet6 = 1;
1630                         break;
1631 #endif
1632                 }
1633         }
1634         freeifaddrs(ifaddrs);
1635
1636         switch(pai->ai_family) {
1637         case AF_INET6:
1638                 return (seen_inet6);
1639         case AF_INET:
1640                 return (seen_inet);
1641         case AF_UNSPEC:
1642                 if (seen_inet == seen_inet6)
1643                         return (seen_inet);
1644                 pai->ai_family = seen_inet ? AF_INET : AF_INET6;
1645                 return (1);
1646         }
1647         return (1);
1648 }
1649
1650 #ifdef INET6
1651 static int
1652 is_ifdisabled(char *name)
1653 {
1654         struct in6_ndireq nd;
1655         int fd;
1656
1657         if ((fd = _socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0)) < 0)
1658                 return (-1);
1659         memset(&nd, 0, sizeof(nd));
1660         strlcpy(nd.ifname, name, sizeof(nd.ifname));
1661         if (_ioctl(fd, SIOCGIFINFO_IN6, &nd) < 0) {
1662                 _close(fd);
1663                 return (-1);
1664         }
1665         _close(fd);
1666         return ((nd.ndi.flags & ND6_IFF_IFDISABLED) != 0);
1667 }
1668
1669 /* convert a string to a scope identifier. XXX: IPv6 specific */
1670 static int
1671 ip6_str2scopeid(char *scope, struct sockaddr_in6 *sin6, u_int32_t *scopeid)
1672 {
1673         u_long lscopeid;
1674         struct in6_addr *a6;
1675         char *ep;
1676
1677         a6 = &sin6->sin6_addr;
1678
1679         /* empty scopeid portion is invalid */
1680         if (*scope == '\0')
1681                 return -1;
1682
1683         if (IN6_IS_ADDR_LINKLOCAL(a6) || IN6_IS_ADDR_MC_LINKLOCAL(a6) ||
1684             IN6_IS_ADDR_MC_NODELOCAL(a6)) {
1685                 /*
1686                  * We currently assume a one-to-one mapping between links
1687                  * and interfaces, so we simply use interface indices for
1688                  * like-local scopes.
1689                  */
1690                 *scopeid = if_nametoindex(scope);
1691                 if (*scopeid == 0)
1692                         goto trynumeric;
1693                 return 0;
1694         }
1695
1696         /* still unclear about literal, allow numeric only - placeholder */
1697         if (IN6_IS_ADDR_SITELOCAL(a6) || IN6_IS_ADDR_MC_SITELOCAL(a6))
1698                 goto trynumeric;
1699         if (IN6_IS_ADDR_MC_ORGLOCAL(a6))
1700                 goto trynumeric;
1701         else
1702                 goto trynumeric;        /* global */
1703
1704         /* try to convert to a numeric id as a last resort */
1705   trynumeric:
1706         errno = 0;
1707         lscopeid = strtoul(scope, &ep, 10);
1708         *scopeid = (u_int32_t)(lscopeid & 0xffffffffUL);
1709         if (errno == 0 && ep && *ep == '\0' && *scopeid == lscopeid)
1710                 return 0;
1711         else
1712                 return -1;
1713 }
1714 #endif
1715
1716
1717 #ifdef NS_CACHING
1718 static int
1719 addrinfo_id_func(char *buffer, size_t *buffer_size, va_list ap,
1720     void *cache_mdata)
1721 {
1722         res_state statp;
1723         u_long res_options;
1724
1725         const int op_id = 0;    /* identifies the getaddrinfo for the cache */
1726         char *hostname;
1727         struct addrinfo *hints;
1728
1729         char *p;
1730         int ai_flags, ai_family, ai_socktype, ai_protocol;
1731         size_t desired_size, size;
1732
1733         statp = __res_state();
1734         res_options = statp->options & (RES_RECURSE | RES_DEFNAMES |
1735             RES_DNSRCH | RES_NOALIASES | RES_USE_INET6);
1736
1737         hostname = va_arg(ap, char *);
1738         hints = va_arg(ap, struct addrinfo *);
1739
1740         desired_size = sizeof(res_options) + sizeof(int) + sizeof(int) * 4;
1741         if (hostname != NULL) {
1742                 size = strlen(hostname);
1743                 desired_size += size + 1;
1744         } else
1745                 size = 0;
1746
1747         if (desired_size > *buffer_size) {
1748                 *buffer_size = desired_size;
1749                 return (NS_RETURN);
1750         }
1751
1752         if (hints == NULL)
1753                 ai_flags = ai_family = ai_socktype = ai_protocol = 0;
1754         else {
1755                 ai_flags = hints->ai_flags;
1756                 ai_family = hints->ai_family;
1757                 ai_socktype = hints->ai_socktype;
1758                 ai_protocol = hints->ai_protocol;
1759         }
1760
1761         p = buffer;
1762         memcpy(p, &res_options, sizeof(res_options));
1763         p += sizeof(res_options);
1764
1765         memcpy(p, &op_id, sizeof(int));
1766         p += sizeof(int);
1767
1768         memcpy(p, &ai_flags, sizeof(int));
1769         p += sizeof(int);
1770
1771         memcpy(p, &ai_family, sizeof(int));
1772         p += sizeof(int);
1773
1774         memcpy(p, &ai_socktype, sizeof(int));
1775         p += sizeof(int);
1776
1777         memcpy(p, &ai_protocol, sizeof(int));
1778         p += sizeof(int);
1779
1780         if (hostname != NULL)
1781                 memcpy(p, hostname, size);
1782
1783         *buffer_size = desired_size;
1784         return (NS_SUCCESS);
1785 }
1786
1787 static int
1788 addrinfo_marshal_func(char *buffer, size_t *buffer_size, void *retval,
1789     va_list ap, void *cache_mdata)
1790 {
1791         struct addrinfo *ai, *cai;
1792         char *p;
1793         size_t desired_size, size, ai_size;
1794
1795         ai = *((struct addrinfo **)retval);
1796
1797         desired_size = sizeof(size_t);
1798         ai_size = 0;
1799         for (cai = ai; cai != NULL; cai = cai->ai_next) {
1800                 desired_size += sizeof(struct addrinfo) + cai->ai_addrlen;
1801                 if (cai->ai_canonname != NULL)
1802                         desired_size += sizeof(size_t) +
1803                             strlen(cai->ai_canonname);
1804                 ++ai_size;
1805         }
1806
1807         if (desired_size > *buffer_size) {
1808                 /* this assignment is here for future use */
1809                 errno = ERANGE;
1810                 *buffer_size = desired_size;
1811                 return (NS_RETURN);
1812         }
1813
1814         memset(buffer, 0, desired_size);
1815         p = buffer;
1816
1817         memcpy(p, &ai_size, sizeof(size_t));
1818         p += sizeof(size_t);
1819         for (cai = ai; cai != NULL; cai = cai->ai_next) {
1820                 memcpy(p, cai, sizeof(struct addrinfo));
1821                 p += sizeof(struct addrinfo);
1822
1823                 memcpy(p, cai->ai_addr, cai->ai_addrlen);
1824                 p += cai->ai_addrlen;
1825
1826                 if (cai->ai_canonname != NULL) {
1827                         size = strlen(cai->ai_canonname);
1828                         memcpy(p, &size, sizeof(size_t));
1829                         p += sizeof(size_t);
1830
1831                         memcpy(p, cai->ai_canonname, size);
1832                         p += size;
1833                 }
1834         }
1835
1836         return (NS_SUCCESS);
1837 }
1838
1839 static int
1840 addrinfo_unmarshal_func(char *buffer, size_t buffer_size, void *retval,
1841     va_list ap, void *cache_mdata)
1842 {
1843         struct addrinfo new_ai, *result, *sentinel, *lasts;
1844
1845         char *p;
1846         size_t ai_size, ai_i, size;
1847
1848         p = buffer;
1849         memcpy(&ai_size, p, sizeof(size_t));
1850         p += sizeof(size_t);
1851
1852         result = NULL;
1853         lasts = NULL;
1854         for (ai_i = 0; ai_i < ai_size; ++ai_i) {
1855                 memcpy(&new_ai, p, sizeof(struct addrinfo));
1856                 p += sizeof(struct addrinfo);
1857                 size = new_ai.ai_addrlen + sizeof(struct addrinfo) +
1858                         _ALIGNBYTES;
1859
1860                 sentinel = (struct addrinfo *)malloc(size);
1861                 memset(sentinel, 0, size);
1862
1863                 memcpy(sentinel, &new_ai, sizeof(struct addrinfo));
1864                 sentinel->ai_addr = (struct sockaddr *)_ALIGN((char *)sentinel +
1865                     sizeof(struct addrinfo));
1866
1867                 memcpy(sentinel->ai_addr, p, new_ai.ai_addrlen);
1868                 p += new_ai.ai_addrlen;
1869
1870                 if (new_ai.ai_canonname != NULL) {
1871                         memcpy(&size, p, sizeof(size_t));
1872                         p += sizeof(size_t);
1873
1874                         sentinel->ai_canonname = (char *)malloc(size + 1);
1875                         memset(sentinel->ai_canonname, 0, size + 1);
1876
1877                         memcpy(sentinel->ai_canonname, p, size);
1878                         p += size;
1879                 }
1880
1881                 if (result == NULL) {
1882                         result = sentinel;
1883                         lasts = sentinel;
1884                 } else {
1885                         lasts->ai_next = sentinel;
1886                         lasts = sentinel;
1887                 }
1888         }
1889
1890         *((struct addrinfo **)retval) = result;
1891         return (NS_SUCCESS);
1892 }
1893 #endif /* NS_CACHING */
1894
1895 /*
1896  * FQDN hostname, DNS lookup
1897  */
1898 static int
1899 explore_fqdn(const struct addrinfo *pai, const char *hostname,
1900     const char *servname, struct addrinfo **res)
1901 {
1902         struct addrinfo *result;
1903         struct addrinfo *cur;
1904         int error = 0;
1905
1906 #ifdef NS_CACHING
1907         static const nss_cache_info cache_info =
1908         NS_COMMON_CACHE_INFO_INITIALIZER(
1909                 hosts, NULL, addrinfo_id_func, addrinfo_marshal_func,
1910                 addrinfo_unmarshal_func);
1911 #endif
1912         static const ns_dtab dtab[] = {
1913                 NS_FILES_CB(_files_getaddrinfo, NULL)
1914                 { NSSRC_DNS, _dns_getaddrinfo, NULL },  /* force -DHESIOD */
1915                 NS_NIS_CB(_yp_getaddrinfo, NULL)
1916 #ifdef NS_CACHING
1917                 NS_CACHE_CB(&cache_info)
1918 #endif
1919                 { 0 }
1920         };
1921
1922         result = NULL;
1923
1924         /*
1925          * if the servname does not match socktype/protocol, ignore it.
1926          */
1927         if (get_portmatch(pai, servname) != 0)
1928                 return 0;
1929
1930         switch (_nsdispatch(&result, dtab, NSDB_HOSTS, "getaddrinfo",
1931                         default_dns_files, hostname, pai)) {
1932         case NS_TRYAGAIN:
1933                 error = EAI_AGAIN;
1934                 goto free;
1935         case NS_UNAVAIL:
1936                 error = EAI_FAIL;
1937                 goto free;
1938         case NS_NOTFOUND:
1939                 error = EAI_NONAME;
1940                 goto free;
1941         case NS_SUCCESS:
1942                 error = 0;
1943                 for (cur = result; cur; cur = cur->ai_next) {
1944                         GET_PORT(cur, servname);
1945                         /* canonname should be filled already */
1946                 }
1947                 break;
1948         }
1949
1950         *res = result;
1951
1952         return 0;
1953
1954 free:
1955         if (result)
1956                 freeaddrinfo(result);
1957         return error;
1958 }
1959
1960 #ifdef DEBUG
1961 static const char AskedForGot[] =
1962         "gethostby*.getanswer: asked for \"%s\", got \"%s\"";
1963 #endif
1964
1965 static struct addrinfo *
1966 getanswer(const querybuf *answer, int anslen, const char *qname, int qtype,
1967     const struct addrinfo *pai, res_state res)
1968 {
1969         struct addrinfo sentinel, *cur;
1970         struct addrinfo ai;
1971         const struct afd *afd;
1972         char *canonname;
1973         const HEADER *hp;
1974         const u_char *cp;
1975         int n;
1976         const u_char *eom;
1977         char *bp, *ep;
1978         int type, class, ancount, qdcount;
1979         int haveanswer, had_error;
1980         char tbuf[MAXDNAME];
1981         int (*name_ok)(const char *);
1982         char hostbuf[8*1024];
1983
1984         memset(&sentinel, 0, sizeof(sentinel));
1985         cur = &sentinel;
1986
1987         canonname = NULL;
1988         eom = answer->buf + anslen;
1989         switch (qtype) {
1990         case T_A:
1991         case T_AAAA:
1992         case T_ANY:     /*use T_ANY only for T_A/T_AAAA lookup*/
1993                 name_ok = res_hnok;
1994                 break;
1995         default:
1996                 return (NULL);  /* XXX should be abort(); */
1997         }
1998         /*
1999          * find first satisfactory answer
2000          */
2001         hp = &answer->hdr;
2002         ancount = ntohs(hp->ancount);
2003         qdcount = ntohs(hp->qdcount);
2004         bp = hostbuf;
2005         ep = hostbuf + sizeof hostbuf;
2006         cp = answer->buf + HFIXEDSZ;
2007         if (qdcount != 1) {
2008                 RES_SET_H_ERRNO(res, NO_RECOVERY);
2009                 return (NULL);
2010         }
2011         n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
2012         if ((n < 0) || !(*name_ok)(bp)) {
2013                 RES_SET_H_ERRNO(res, NO_RECOVERY);
2014                 return (NULL);
2015         }
2016         cp += n + QFIXEDSZ;
2017         if (qtype == T_A || qtype == T_AAAA || qtype == T_ANY) {
2018                 /* res_send() has already verified that the query name is the
2019                  * same as the one we sent; this just gets the expanded name
2020                  * (i.e., with the succeeding search-domain tacked on).
2021                  */
2022                 n = strlen(bp) + 1;             /* for the \0 */
2023                 if (n >= MAXHOSTNAMELEN) {
2024                         RES_SET_H_ERRNO(res, NO_RECOVERY);
2025                         return (NULL);
2026                 }
2027                 canonname = bp;
2028                 bp += n;
2029                 /* The qname can be abbreviated, but h_name is now absolute. */
2030                 qname = canonname;
2031         }
2032         haveanswer = 0;
2033         had_error = 0;
2034         while (ancount-- > 0 && cp < eom && !had_error) {
2035                 n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
2036                 if ((n < 0) || !(*name_ok)(bp)) {
2037                         had_error++;
2038                         continue;
2039                 }
2040                 cp += n;                        /* name */
2041                 type = _getshort(cp);
2042                 cp += INT16SZ;                  /* type */
2043                 class = _getshort(cp);
2044                 cp += INT16SZ + INT32SZ;        /* class, TTL */
2045                 n = _getshort(cp);
2046                 cp += INT16SZ;                  /* len */
2047                 if (class != C_IN) {
2048                         /* XXX - debug? syslog? */
2049                         cp += n;
2050                         continue;               /* XXX - had_error++ ? */
2051                 }
2052                 if ((qtype == T_A || qtype == T_AAAA || qtype == T_ANY) &&
2053                     type == T_CNAME) {
2054                         n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
2055                         if ((n < 0) || !(*name_ok)(tbuf)) {
2056                                 had_error++;
2057                                 continue;
2058                         }
2059                         cp += n;
2060                         /* Get canonical name. */
2061                         n = strlen(tbuf) + 1;   /* for the \0 */
2062                         if (n > ep - bp || n >= MAXHOSTNAMELEN) {
2063                                 had_error++;
2064                                 continue;
2065                         }
2066                         strlcpy(bp, tbuf, ep - bp);
2067                         canonname = bp;
2068                         bp += n;
2069                         continue;
2070                 }
2071                 if (qtype == T_ANY) {
2072                         if (!(type == T_A || type == T_AAAA)) {
2073                                 cp += n;
2074                                 continue;
2075                         }
2076                 } else if (type != qtype) {
2077 #ifdef DEBUG
2078                         if (type != T_KEY && type != T_SIG &&
2079                             type != ns_t_dname)
2080                                 syslog(LOG_NOTICE|LOG_AUTH,
2081                "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
2082                                        qname, p_class(C_IN), p_type(qtype),
2083                                        p_type(type));
2084 #endif
2085                         cp += n;
2086                         continue;               /* XXX - had_error++ ? */
2087                 }
2088                 switch (type) {
2089                 case T_A:
2090                 case T_AAAA:
2091                         if (strcasecmp(canonname, bp) != 0) {
2092 #ifdef DEBUG
2093                                 syslog(LOG_NOTICE|LOG_AUTH,
2094                                        AskedForGot, canonname, bp);
2095 #endif
2096                                 cp += n;
2097                                 continue;       /* XXX - had_error++ ? */
2098                         }
2099                         if (type == T_A && n != INADDRSZ) {
2100                                 cp += n;
2101                                 continue;
2102                         }
2103                         if (type == T_AAAA && n != IN6ADDRSZ) {
2104                                 cp += n;
2105                                 continue;
2106                         }
2107 #ifdef FILTER_V4MAPPED
2108                         if (type == T_AAAA) {
2109                                 struct in6_addr in6;
2110                                 memcpy(&in6, cp, sizeof(in6));
2111                                 if (IN6_IS_ADDR_V4MAPPED(&in6)) {
2112                                         cp += n;
2113                                         continue;
2114                                 }
2115                         }
2116 #endif
2117                         if (!haveanswer) {
2118                                 int nn;
2119
2120                                 canonname = bp;
2121                                 nn = strlen(bp) + 1;    /* for the \0 */
2122                                 bp += nn;
2123                         }
2124
2125                         /* don't overwrite pai */
2126                         ai = *pai;
2127                         ai.ai_family = (type == T_A) ? AF_INET : AF_INET6;
2128                         afd = find_afd(ai.ai_family);
2129                         if (afd == NULL) {
2130                                 cp += n;
2131                                 continue;
2132                         }
2133                         cur->ai_next = get_ai(&ai, afd, (const char *)cp);
2134                         if (cur->ai_next == NULL)
2135                                 had_error++;
2136                         while (cur && cur->ai_next)
2137                                 cur = cur->ai_next;
2138                         cp += n;
2139                         break;
2140                 default:
2141                         abort();
2142                 }
2143                 if (!had_error)
2144                         haveanswer++;
2145         }
2146         if (haveanswer) {
2147 #if defined(RESOLVSORT)
2148                 /*
2149                  * We support only IPv4 address for backward
2150                  * compatibility against gethostbyname(3).
2151                  */
2152                 if (res->nsort && qtype == T_A) {
2153                         if (addr4sort(&sentinel, res) < 0) {
2154                                 freeaddrinfo(sentinel.ai_next);
2155                                 RES_SET_H_ERRNO(res, NO_RECOVERY);
2156                                 return NULL;
2157                         }
2158                 }
2159 #endif /*RESOLVSORT*/
2160                 if (!canonname)
2161                         (void)get_canonname(pai, sentinel.ai_next, qname);
2162                 else
2163                         (void)get_canonname(pai, sentinel.ai_next, canonname);
2164                 RES_SET_H_ERRNO(res, NETDB_SUCCESS);
2165                 return sentinel.ai_next;
2166         }
2167
2168         /*
2169          * We could have walked a CNAME chain, but the ultimate target
2170          * may not have what we looked for.
2171          */
2172         RES_SET_H_ERRNO(res, ntohs(hp->ancount) > 0 ? NO_DATA : NO_RECOVERY);
2173         return NULL;
2174 }
2175
2176 #ifdef RESOLVSORT
2177 struct addr_ptr {
2178         struct addrinfo *ai;
2179         int aval;
2180 };
2181
2182 static int
2183 addr4sort(struct addrinfo *sentinel, res_state res)
2184 {
2185         struct addrinfo *ai;
2186         struct addr_ptr *addrs, addr;
2187         struct sockaddr_in *sin;
2188         int naddrs, i, j;
2189         int needsort = 0;
2190
2191         if (!sentinel)
2192                 return -1;
2193         naddrs = 0;
2194         for (ai = sentinel->ai_next; ai; ai = ai->ai_next)
2195                 naddrs++;
2196         if (naddrs < 2)
2197                 return 0;               /* We don't need sorting. */
2198         if ((addrs = malloc(sizeof(struct addr_ptr) * naddrs)) == NULL)
2199                 return -1;
2200         i = 0;
2201         for (ai = sentinel->ai_next; ai; ai = ai->ai_next) {
2202                 sin = (struct sockaddr_in *)ai->ai_addr;
2203                 for (j = 0; (unsigned)j < res->nsort; j++) {
2204                         if (res->sort_list[j].addr.s_addr ==
2205                             (sin->sin_addr.s_addr & res->sort_list[j].mask))
2206                                 break;
2207                 }
2208                 addrs[i].ai = ai;
2209                 addrs[i].aval = j;
2210                 if (needsort == 0 && i > 0 && j < addrs[i - 1].aval)
2211                         needsort = i;
2212                 i++;
2213         }
2214         if (!needsort) {
2215                 free(addrs);
2216                 return 0;
2217         }
2218
2219         while (needsort < naddrs) {
2220                 for (j = needsort - 1; j >= 0; j--) {
2221                         if (addrs[j].aval > addrs[j+1].aval) {
2222                                 addr = addrs[j];
2223                                 addrs[j] = addrs[j + 1];
2224                                 addrs[j + 1] = addr;
2225                         } else
2226                                 break;
2227                 }
2228                 needsort++;
2229         }
2230
2231         ai = sentinel;
2232         for (i = 0; i < naddrs; ++i) {
2233                 ai->ai_next = addrs[i].ai;
2234                 ai = ai->ai_next;
2235         }
2236         ai->ai_next = NULL;
2237         free(addrs);
2238         return 0;
2239 }
2240 #endif /*RESOLVSORT*/
2241
2242 /*ARGSUSED*/
2243 static int
2244 _dns_getaddrinfo(void *rv, void *cb_data, va_list ap)
2245 {
2246         struct addrinfo *ai, ai0;
2247         querybuf *buf, *buf2;
2248         const char *hostname;
2249         const struct addrinfo *pai;
2250         struct addrinfo sentinel, *cur;
2251         struct res_target q, q2;
2252         res_state res;
2253
2254         hostname = va_arg(ap, char *);
2255         pai = va_arg(ap, const struct addrinfo *);
2256
2257         memset(&q, 0, sizeof(q));
2258         memset(&q2, 0, sizeof(q2));
2259         memset(&sentinel, 0, sizeof(sentinel));
2260         cur = &sentinel;
2261
2262         res = __res_state();
2263
2264         buf = malloc(sizeof(*buf));
2265         if (!buf) {
2266                 RES_SET_H_ERRNO(res, NETDB_INTERNAL);
2267                 return NS_NOTFOUND;
2268         }
2269         buf2 = malloc(sizeof(*buf2));
2270         if (!buf2) {
2271                 free(buf);
2272                 RES_SET_H_ERRNO(res, NETDB_INTERNAL);
2273                 return NS_NOTFOUND;
2274         }
2275
2276         if (pai->ai_family == AF_INET6 &&
2277             (pai->ai_flags & AI_V4MAPPED) == AI_V4MAPPED) {
2278                 ai0 = *pai;
2279                 ai0.ai_family = AF_UNSPEC;
2280                 pai = &ai0;
2281         }
2282
2283         switch (pai->ai_family) {
2284         case AF_UNSPEC:
2285                 q.name = hostname;
2286                 q.qclass = C_IN;
2287                 q.qtype = T_A;
2288                 q.answer = buf->buf;
2289                 q.anslen = sizeof(buf->buf);
2290                 q.next = &q2;
2291                 q2.name = hostname;
2292                 q2.qclass = C_IN;
2293                 q2.qtype = T_AAAA;
2294                 q2.answer = buf2->buf;
2295                 q2.anslen = sizeof(buf2->buf);
2296                 break;
2297         case AF_INET:
2298                 q.name = hostname;
2299                 q.qclass = C_IN;
2300                 q.qtype = T_A;
2301                 q.answer = buf->buf;
2302                 q.anslen = sizeof(buf->buf);
2303                 break;
2304         case AF_INET6:
2305                 q.name = hostname;
2306                 q.qclass = C_IN;
2307                 q.qtype = T_AAAA;
2308                 q.answer = buf->buf;
2309                 q.anslen = sizeof(buf->buf);
2310                 break;
2311         default:
2312                 free(buf);
2313                 free(buf2);
2314                 return NS_UNAVAIL;
2315         }
2316
2317         if ((res->options & RES_INIT) == 0 && res_ninit(res) == -1) {
2318                 RES_SET_H_ERRNO(res, NETDB_INTERNAL);
2319                 free(buf);
2320                 free(buf2);
2321                 return NS_NOTFOUND;
2322         }
2323
2324         if (res_searchN(hostname, &q, res) < 0) {
2325                 free(buf);
2326                 free(buf2);
2327                 return NS_NOTFOUND;
2328         }
2329         /* prefer IPv6 */
2330         if (q.next) {
2331                 ai = getanswer(buf2, q2.n, q2.name, q2.qtype, pai, res);
2332                 if (ai) {
2333                         cur->ai_next = ai;
2334                         while (cur && cur->ai_next)
2335                                 cur = cur->ai_next;
2336                 }
2337         }
2338         if (!ai || pai->ai_family != AF_UNSPEC ||
2339             (pai->ai_flags & (AI_ALL | AI_V4MAPPED)) != AI_V4MAPPED) {
2340                 ai = getanswer(buf, q.n, q.name, q.qtype, pai, res);
2341                 if (ai)
2342                         cur->ai_next = ai;
2343         }
2344         free(buf);
2345         free(buf2);
2346         if (sentinel.ai_next == NULL)
2347                 switch (res->res_h_errno) {
2348                 case HOST_NOT_FOUND:
2349                 case NO_DATA:
2350                         return NS_NOTFOUND;
2351                 case TRY_AGAIN:
2352                         return NS_TRYAGAIN;
2353                 default:
2354                         return NS_UNAVAIL;
2355                 }
2356         *((struct addrinfo **)rv) = sentinel.ai_next;
2357         return NS_SUCCESS;
2358 }
2359
2360 static void
2361 _sethtent(FILE **hostf)
2362 {
2363         if (!*hostf)
2364                 *hostf = fopen(_PATH_HOSTS, "re");
2365         else
2366                 rewind(*hostf);
2367 }
2368
2369 static void
2370 _endhtent(FILE **hostf)
2371 {
2372         if (*hostf) {
2373                 (void) fclose(*hostf);
2374                 *hostf = NULL;
2375         }
2376 }
2377
2378 static struct addrinfo *
2379 _gethtent(FILE **hostf, const char *name, const struct addrinfo *pai)
2380 {
2381         char *p;
2382         char *cp, *tname, *cname;
2383         struct addrinfo hints, *res0, *res;
2384         int error;
2385         const char *addr;
2386         char hostbuf[8*1024];
2387
2388         if (!*hostf && !(*hostf = fopen(_PATH_HOSTS, "re")))
2389                 return (NULL);
2390 again:
2391         if (!(p = fgets(hostbuf, sizeof hostbuf, *hostf)))
2392                 return (NULL);
2393         if (*p == '#')
2394                 goto again;
2395         cp = strpbrk(p, "#\n");
2396         if (cp != NULL)
2397                 *cp = '\0';
2398         if (!(cp = strpbrk(p, " \t")))
2399                 goto again;
2400         *cp++ = '\0';
2401         addr = p;
2402         cname = NULL;
2403         /* if this is not something we're looking for, skip it. */
2404         while (cp && *cp) {
2405                 if (*cp == ' ' || *cp == '\t') {
2406                         cp++;
2407                         continue;
2408                 }
2409                 tname = cp;
2410                 if (cname == NULL)
2411                         cname = cp;
2412                 if ((cp = strpbrk(cp, " \t")) != NULL)
2413                         *cp++ = '\0';
2414                 if (strcasecmp(name, tname) == 0)
2415                         goto found;
2416         }
2417         goto again;
2418
2419 found:
2420         /* we should not glob socktype/protocol here */
2421         memset(&hints, 0, sizeof(hints));
2422         hints.ai_family = pai->ai_family;
2423         hints.ai_socktype = SOCK_DGRAM;
2424         hints.ai_protocol = 0;
2425         hints.ai_flags = AI_NUMERICHOST;
2426         if (pai->ai_family == AF_INET6 &&
2427             (pai->ai_flags & AI_V4MAPPED) == AI_V4MAPPED)
2428                 hints.ai_flags |= AI_V4MAPPED;
2429         error = getaddrinfo(addr, "0", &hints, &res0);
2430         if (error)
2431                 goto again;
2432 #ifdef FILTER_V4MAPPED
2433         /* XXX should check all items in the chain */
2434         if (res0->ai_family == AF_INET6 &&
2435             IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)res0->ai_addr)->sin6_addr)) {
2436                 freeaddrinfo(res0);
2437                 goto again;
2438         }
2439 #endif
2440         for (res = res0; res; res = res->ai_next) {
2441                 /* cover it up */
2442                 res->ai_flags = pai->ai_flags;
2443                 res->ai_socktype = pai->ai_socktype;
2444                 res->ai_protocol = pai->ai_protocol;
2445
2446                 if (pai->ai_flags & AI_CANONNAME) {
2447                         if (get_canonname(pai, res, cname) != 0) {
2448                                 freeaddrinfo(res0);
2449                                 goto again;
2450                         }
2451                 }
2452         }
2453         return res0;
2454 }
2455
2456 static struct addrinfo *
2457 _getht(FILE **hostf, const char *name, const struct addrinfo *pai,
2458      struct addrinfo *cur)
2459 {
2460         struct addrinfo *p;
2461
2462         while ((p = _gethtent(hostf, name, pai)) != NULL) {
2463                 cur->ai_next = p;
2464                 while (cur && cur->ai_next)
2465                         cur = cur->ai_next;
2466         }
2467         return (cur);
2468 }
2469
2470 /*ARGSUSED*/
2471 static int
2472 _files_getaddrinfo(void *rv, void *cb_data, va_list ap)
2473 {
2474         const char *name;
2475         const struct addrinfo *pai;
2476         struct addrinfo sentinel, *cur;
2477         FILE *hostf = NULL;
2478
2479         name = va_arg(ap, char *);
2480         pai = va_arg(ap, struct addrinfo *);
2481
2482         memset(&sentinel, 0, sizeof(sentinel));
2483         cur = &sentinel;
2484
2485         _sethtent(&hostf);
2486         if (pai->ai_family == AF_INET6 &&
2487             (pai->ai_flags & (AI_ALL | AI_V4MAPPED)) == AI_V4MAPPED) {
2488                 struct addrinfo ai0 = *pai;
2489
2490                 ai0.ai_flags &= ~AI_V4MAPPED;
2491                 cur = _getht(&hostf, name, &ai0, cur);
2492                 if (sentinel.ai_next == NULL) {
2493                         _sethtent(&hostf);
2494                         ai0.ai_flags |= AI_V4MAPPED;
2495                         cur = _getht(&hostf, name, &ai0, cur);
2496                 }
2497         } else
2498                 cur = _getht(&hostf, name, pai, cur);
2499         _endhtent(&hostf);
2500
2501         *((struct addrinfo **)rv) = sentinel.ai_next;
2502         if (sentinel.ai_next == NULL)
2503                 return NS_NOTFOUND;
2504         return NS_SUCCESS;
2505 }
2506
2507 #ifdef YP
2508 /*ARGSUSED*/
2509 static struct addrinfo *
2510 _yphostent(char *line, const struct addrinfo *pai)
2511 {
2512         struct addrinfo sentinel, *cur;
2513         struct addrinfo hints, *res, *res0;
2514         int error;
2515         char *p = line;
2516         const char *addr, *canonname;
2517         char *nextline;
2518         char *cp;
2519
2520         addr = canonname = NULL;
2521
2522         memset(&sentinel, 0, sizeof(sentinel));
2523         cur = &sentinel;
2524
2525 nextline:
2526         /* terminate line */
2527         cp = strchr(p, '\n');
2528         if (cp) {
2529                 *cp++ = '\0';
2530                 nextline = cp;
2531         } else
2532                 nextline = NULL;
2533
2534         cp = strpbrk(p, " \t");
2535         if (cp == NULL) {
2536                 if (canonname == NULL)
2537                         return (NULL);
2538                 else
2539                         goto done;
2540         }
2541         *cp++ = '\0';
2542
2543         addr = p;
2544
2545         while (cp && *cp) {
2546                 if (*cp == ' ' || *cp == '\t') {
2547                         cp++;
2548                         continue;
2549                 }
2550                 if (!canonname)
2551                         canonname = cp;
2552                 if ((cp = strpbrk(cp, " \t")) != NULL)
2553                         *cp++ = '\0';
2554         }
2555
2556         hints = *pai;
2557         hints.ai_flags = AI_NUMERICHOST;
2558         if (pai->ai_family == AF_INET6 &&
2559             (pai->ai_flags & AI_V4MAPPED) == AI_V4MAPPED)
2560                 hints.ai_flags |= AI_V4MAPPED;
2561         error = getaddrinfo(addr, NULL, &hints, &res0);
2562         if (error == 0) {
2563                 for (res = res0; res; res = res->ai_next) {
2564                         /* cover it up */
2565                         res->ai_flags = pai->ai_flags;
2566
2567                         if (pai->ai_flags & AI_CANONNAME)
2568                                 (void)get_canonname(pai, res, canonname);
2569                 }
2570         } else
2571                 res0 = NULL;
2572         if (res0) {
2573                 cur->ai_next = res0;
2574                 while (cur && cur->ai_next)
2575                         cur = cur->ai_next;
2576         }
2577
2578         if (nextline) {
2579                 p = nextline;
2580                 goto nextline;
2581         }
2582
2583 done:
2584         return sentinel.ai_next;
2585 }
2586
2587 /*ARGSUSED*/
2588 static int
2589 _yp_getaddrinfo(void *rv, void *cb_data, va_list ap)
2590 {
2591         struct addrinfo sentinel, *cur;
2592         struct addrinfo *ai = NULL;
2593         char *ypbuf;
2594         int ypbuflen, r;
2595         const char *name;
2596         const struct addrinfo *pai;
2597         char *ypdomain;
2598
2599         if (_yp_check(&ypdomain) == 0)
2600                 return NS_UNAVAIL;
2601
2602         name = va_arg(ap, char *);
2603         pai = va_arg(ap, const struct addrinfo *);
2604
2605         memset(&sentinel, 0, sizeof(sentinel));
2606         cur = &sentinel;
2607
2608         /* ipnodes.byname can hold both IPv4/v6 */
2609         r = yp_match(ypdomain, "ipnodes.byname", name,
2610                 (int)strlen(name), &ypbuf, &ypbuflen);
2611         if (r == 0) {
2612                 ai = _yphostent(ypbuf, pai);
2613                 if (ai) {
2614                         cur->ai_next = ai;
2615                         while (cur && cur->ai_next)
2616                                 cur = cur->ai_next;
2617                 }
2618                 free(ypbuf);
2619         }
2620
2621         if (ai != NULL) {
2622                 struct sockaddr_in6 *sin6;
2623
2624                 switch (ai->ai_family) {
2625                 case AF_INET:
2626                         goto done;
2627                 case AF_INET6:
2628                         sin6 = (struct sockaddr_in6 *)ai->ai_addr;
2629                         if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr))
2630                                 goto done;
2631                         break;
2632                 }
2633         }
2634
2635         /* hosts.byname is only for IPv4 (Solaris8) */
2636         if (pai->ai_family == AF_UNSPEC || pai->ai_family == AF_INET ||
2637             ((pai->ai_family == AF_INET6 &&
2638              (pai->ai_flags & AI_V4MAPPED) == AI_V4MAPPED) &&
2639               (ai == NULL || (pai->ai_flags & AI_ALL) == AI_ALL))) {
2640                 r = yp_match(ypdomain, "hosts.byname", name,
2641                         (int)strlen(name), &ypbuf, &ypbuflen);
2642                 if (r == 0) {
2643                         struct addrinfo ai4;
2644
2645                         ai4 = *pai;
2646                         if (pai->ai_family == AF_UNSPEC)
2647                                 ai4.ai_family = AF_INET;
2648                         ai = _yphostent(ypbuf, &ai4);
2649                         if (ai) {
2650                                 cur->ai_next = ai;
2651                                 while (cur && cur->ai_next)
2652                                         cur = cur->ai_next;
2653                         }
2654                         free(ypbuf);
2655                 }
2656         }
2657
2658 done:
2659         if (sentinel.ai_next == NULL) {
2660                 RES_SET_H_ERRNO(__res_state(), HOST_NOT_FOUND);
2661                 return NS_NOTFOUND;
2662         }
2663         *((struct addrinfo **)rv) = sentinel.ai_next;
2664         return NS_SUCCESS;
2665 }
2666 #endif
2667
2668 /* resolver logic */
2669
2670 /*
2671  * Formulate a normal query, send, and await answer.
2672  * Returned answer is placed in supplied buffer "answer".
2673  * Perform preliminary check of answer, returning success only
2674  * if no error is indicated and the answer count is nonzero.
2675  * Return the size of the response on success, -1 on error.
2676  * Error number is left in h_errno.
2677  *
2678  * Caller must parse answer and determine whether it answers the question.
2679  */
2680 static int
2681 res_queryN(const char *name, struct res_target *target, res_state res)
2682 {
2683         u_char *buf;
2684         HEADER *hp;
2685         int n;
2686         u_int oflags;
2687         struct res_target *t;
2688         int rcode;
2689         int ancount;
2690
2691         rcode = NOERROR;
2692         ancount = 0;
2693
2694         buf = malloc(MAXPACKET);
2695         if (!buf) {
2696                 RES_SET_H_ERRNO(res, NETDB_INTERNAL);
2697                 return -1;
2698         }
2699
2700         for (t = target; t; t = t->next) {
2701                 int class, type;
2702                 u_char *answer;
2703                 int anslen;
2704
2705                 hp = (HEADER *)(void *)t->answer;
2706
2707                 /* make it easier... */
2708                 class = t->qclass;
2709                 type = t->qtype;
2710                 answer = t->answer;
2711                 anslen = t->anslen;
2712
2713                 oflags = res->_flags;
2714
2715 again:
2716                 hp->rcode = NOERROR;    /* default */
2717
2718 #ifdef DEBUG
2719                 if (res->options & RES_DEBUG)
2720                         printf(";; res_query(%s, %d, %d)\n", name, class, type);
2721 #endif
2722
2723                 n = res_nmkquery(res, QUERY, name, class, type, NULL, 0, NULL,
2724                     buf, MAXPACKET);
2725                 if (n > 0 && (res->_flags & RES_F_EDNS0ERR) == 0 &&
2726                     (res->options & (RES_USE_EDNS0|RES_USE_DNSSEC)) != 0U)
2727                         n = res_nopt(res, n, buf, MAXPACKET, anslen);
2728                 if (n <= 0) {
2729 #ifdef DEBUG
2730                         if (res->options & RES_DEBUG)
2731                                 printf(";; res_query: mkquery failed\n");
2732 #endif
2733                         free(buf);
2734                         RES_SET_H_ERRNO(res, NO_RECOVERY);
2735                         return (n);
2736                 }
2737                 n = res_nsend(res, buf, n, answer, anslen);
2738                 if (n < 0) {
2739                         /*
2740                          * if the query choked with EDNS0, retry
2741                          * without EDNS0
2742                          */
2743                         if ((res->options & (RES_USE_EDNS0|RES_USE_DNSSEC))
2744                             != 0U &&
2745                             ((oflags ^ res->_flags) & RES_F_EDNS0ERR) != 0) {
2746                                 res->_flags |= RES_F_EDNS0ERR;
2747                                 if (res->options & RES_DEBUG)
2748                                         printf(";; res_nquery: retry without EDNS0\n");
2749                                 goto again;
2750                         }
2751                         rcode = hp->rcode;      /* record most recent error */
2752 #ifdef DEBUG
2753                         if (res->options & RES_DEBUG)
2754                                 printf(";; res_query: send error\n");
2755 #endif
2756                         continue;
2757                 }
2758
2759                 if (n > anslen)
2760                         hp->rcode = FORMERR; /* XXX not very informative */
2761                 if (hp->rcode != NOERROR || ntohs(hp->ancount) == 0) {
2762                         rcode = hp->rcode;      /* record most recent error */
2763 #ifdef DEBUG
2764                         if (res->options & RES_DEBUG)
2765                                 printf(";; rcode = %u, ancount=%u\n", hp->rcode,
2766                                     ntohs(hp->ancount));
2767 #endif
2768                         continue;
2769                 }
2770
2771                 ancount += ntohs(hp->ancount);
2772
2773                 t->n = n;
2774         }
2775
2776         free(buf);
2777
2778         if (ancount == 0) {
2779                 switch (rcode) {
2780                 case NXDOMAIN:
2781                         RES_SET_H_ERRNO(res, HOST_NOT_FOUND);
2782                         break;
2783                 case SERVFAIL:
2784                         RES_SET_H_ERRNO(res, TRY_AGAIN);
2785                         break;
2786                 case NOERROR:
2787                         RES_SET_H_ERRNO(res, NO_DATA);
2788                         break;
2789                 case FORMERR:
2790                 case NOTIMP:
2791                 case REFUSED:
2792                 default:
2793                         RES_SET_H_ERRNO(res, NO_RECOVERY);
2794                         break;
2795                 }
2796                 return (-1);
2797         }
2798         return (ancount);
2799 }
2800
2801 /*
2802  * Formulate a normal query, send, and retrieve answer in supplied buffer.
2803  * Return the size of the response on success, -1 on error.
2804  * If enabled, implement search rules until answer or unrecoverable failure
2805  * is detected.  Error code, if any, is left in h_errno.
2806  */
2807 static int
2808 res_searchN(const char *name, struct res_target *target, res_state res)
2809 {
2810         const char *cp, * const *domain;
2811         HEADER *hp = (HEADER *)(void *)target->answer;  /*XXX*/
2812         u_int dots;
2813         int trailing_dot, ret, saved_herrno;
2814         int got_nodata = 0, got_servfail = 0, root_on_list = 0;
2815         int tried_as_is = 0;
2816         int searched = 0;
2817         char abuf[MAXDNAME];
2818
2819         errno = 0;
2820         RES_SET_H_ERRNO(res, HOST_NOT_FOUND); /* default, if we never query */
2821         dots = 0;
2822         for (cp = name; *cp; cp++)
2823                 dots += (*cp == '.');
2824         trailing_dot = 0;
2825         if (cp > name && *--cp == '.')
2826                 trailing_dot++;
2827
2828         /*
2829          * if there aren't any dots, it could be a user-level alias
2830          */
2831         if (!dots &&
2832             (cp = res_hostalias(res, name, abuf, sizeof(abuf))) != NULL)
2833                 return (res_queryN(cp, target, res));
2834
2835         /*
2836          * If there are enough dots in the name, let's just give it a
2837          * try 'as is'. The threshold can be set with the "ndots" option.
2838          * Also, query 'as is', if there is a trailing dot in the name.
2839          */
2840         saved_herrno = -1;
2841         if (dots >= res->ndots || trailing_dot) {
2842                 ret = res_querydomainN(name, NULL, target, res);
2843                 if (ret > 0 || trailing_dot)
2844                         return (ret);
2845                 if (errno == ECONNREFUSED) {
2846                         RES_SET_H_ERRNO(res, TRY_AGAIN);
2847                         return (-1);
2848                 }
2849                 switch (res->res_h_errno) {
2850                 case NO_DATA:
2851                 case HOST_NOT_FOUND:
2852                         break;
2853                 case TRY_AGAIN:
2854                         if (hp->rcode == SERVFAIL)
2855                                 break;
2856                         /* FALLTHROUGH */
2857                 default:
2858                         return (-1);
2859                 }
2860                 saved_herrno = res->res_h_errno;
2861                 tried_as_is++;
2862         }
2863
2864         /*
2865          * We do at least one level of search if
2866          *      - there is no dot and RES_DEFNAME is set, or
2867          *      - there is at least one dot, there is no trailing dot,
2868          *        and RES_DNSRCH is set.
2869          */
2870         if ((!dots && (res->options & RES_DEFNAMES)) ||
2871             (dots && !trailing_dot && (res->options & RES_DNSRCH))) {
2872                 int done = 0;
2873
2874                 for (domain = (const char * const *)res->dnsrch;
2875                    *domain && !done;
2876                    domain++) {
2877                         searched = 1;
2878
2879                         if (domain[0][0] == '\0' ||
2880                             (domain[0][0] == '.' && domain[0][1] == '\0'))
2881                                 root_on_list++;
2882
2883                         if (root_on_list && tried_as_is)
2884                                 continue;
2885
2886                         ret = res_querydomainN(name, *domain, target, res);
2887                         if (ret > 0)
2888                                 return (ret);
2889
2890                         /*
2891                          * If no server present, give up.
2892                          * If name isn't found in this domain,
2893                          * keep trying higher domains in the search list
2894                          * (if that's enabled).
2895                          * On a NO_DATA error, keep trying, otherwise
2896                          * a wildcard entry of another type could keep us
2897                          * from finding this entry higher in the domain.
2898                          * If we get some other error (negative answer or
2899                          * server failure), then stop searching up,
2900                          * but try the input name below in case it's
2901                          * fully-qualified.
2902                          */
2903                         if (errno == ECONNREFUSED) {
2904                                 RES_SET_H_ERRNO(res, TRY_AGAIN);
2905                                 return (-1);
2906                         }
2907
2908                         switch (res->res_h_errno) {
2909                         case NO_DATA:
2910                                 got_nodata++;
2911                                 /* FALLTHROUGH */
2912                         case HOST_NOT_FOUND:
2913                                 /* keep trying */
2914                                 break;
2915                         case TRY_AGAIN:
2916                                 got_servfail++;
2917                                 if (hp->rcode == SERVFAIL) {
2918                                         /* try next search element, if any */
2919                                         break;
2920                                 }
2921                                 /* FALLTHROUGH */
2922                         default:
2923                                 /* anything else implies that we're done */
2924                                 done++;
2925                         }
2926                         /*
2927                          * if we got here for some reason other than DNSRCH,
2928                          * we only wanted one iteration of the loop, so stop.
2929                          */
2930                         if (!(res->options & RES_DNSRCH))
2931                                 done++;
2932                 }
2933         }
2934
2935         switch (res->res_h_errno) {
2936         case NO_DATA:
2937         case HOST_NOT_FOUND:
2938                 break;
2939         case TRY_AGAIN:
2940                 if (hp->rcode == SERVFAIL)
2941                         break;
2942                 /* FALLTHROUGH */
2943         default:
2944                 goto giveup;
2945         }
2946
2947         /*
2948          * If the query has not already been tried as is then try it
2949          * unless RES_NOTLDQUERY is set and there were no dots.
2950          */
2951         if ((dots || !searched || !(res->options & RES_NOTLDQUERY)) &&
2952             !(tried_as_is || root_on_list)) {
2953                 ret = res_querydomainN(name, NULL, target, res);
2954                 if (ret > 0)
2955                         return (ret);
2956         }
2957
2958         /*
2959          * if we got here, we didn't satisfy the search.
2960          * if we did an initial full query, return that query's h_errno
2961          * (note that we wouldn't be here if that query had succeeded).
2962          * else if we ever got a nodata, send that back as the reason.
2963          * else send back meaningless h_errno, that being the one from
2964          * the last DNSRCH we did.
2965          */
2966 giveup:
2967         if (saved_herrno != -1)
2968                 RES_SET_H_ERRNO(res, saved_herrno);
2969         else if (got_nodata)
2970                 RES_SET_H_ERRNO(res, NO_DATA);
2971         else if (got_servfail)
2972                 RES_SET_H_ERRNO(res, TRY_AGAIN);
2973         return (-1);
2974 }
2975
2976 /*
2977  * Perform a call on res_query on the concatenation of name and domain,
2978  * removing a trailing dot from name if domain is NULL.
2979  */
2980 static int
2981 res_querydomainN(const char *name, const char *domain,
2982     struct res_target *target, res_state res)
2983 {
2984         char nbuf[MAXDNAME];
2985         const char *longname = nbuf;
2986         size_t n, d;
2987
2988 #ifdef DEBUG
2989         if (res->options & RES_DEBUG)
2990                 printf(";; res_querydomain(%s, %s)\n",
2991                         name, domain?domain:"<Nil>");
2992 #endif
2993         if (domain == NULL) {
2994                 /*
2995                  * Check for trailing '.';
2996                  * copy without '.' if present.
2997                  */
2998                 n = strlen(name);
2999                 if (n >= MAXDNAME) {
3000                         RES_SET_H_ERRNO(res, NO_RECOVERY);
3001                         return (-1);
3002                 }
3003                 if (n > 0 && name[--n] == '.') {
3004                         strncpy(nbuf, name, n);
3005                         nbuf[n] = '\0';
3006                 } else
3007                         longname = name;
3008         } else {
3009                 n = strlen(name);
3010                 d = strlen(domain);
3011                 if (n + d + 1 >= MAXDNAME) {
3012                         RES_SET_H_ERRNO(res, NO_RECOVERY);
3013                         return (-1);
3014                 }
3015                 snprintf(nbuf, sizeof(nbuf), "%s.%s", name, domain);
3016         }
3017         return (res_queryN(longname, target, res));
3018 }