lib/libc/net/name6.c

   1 /*      $FreeBSD: src/lib/libc/net/name6.c,v 1.6.2.9 2002/11/02 18:54:57 ume Exp $      */
   2 /*      $KAME: name6.c,v 1.25 2000/06/26 16:44:40 itojun Exp $  */
   3
   4 /*
   5  * Copyright (C) 1995, 1996, 1997, 1998, and 1999 WIDE Project.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the project nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32 /*
  33  * ++Copyright++ 1985, 1988, 1993
  34  * -
  35  * Copyright (c) 1985, 1988, 1993
  36  *    The Regents of the University of California.  All rights reserved.
  37  *
  38  * Redistribution and use in source and binary forms, with or without
  39  * modification, are permitted provided that the following conditions
  40  * are met:
  41  * 1. Redistributions of source code must retain the above copyright
  42  *    notice, this list of conditions and the following disclaimer.
  43  * 2. Redistributions in binary form must reproduce the above copyright
  44  *    notice, this list of conditions and the following disclaimer in the
  45  *    documentation and/or other materials provided with the distribution.
  46  * 3. All advertising materials mentioning features or use of this software
  47  *    must display the following acknowledgement:
  48  *      This product includes software developed by the University of
  49  *      California, Berkeley and its contributors.
  50  * 4. Neither the name of the University nor the names of its contributors
  51  *    may be used to endorse or promote products derived from this software
  52  *    without specific prior written permission.
  53  *
  54  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  55  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  56  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  57  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  58  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  59  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  60  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  61  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  62  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  63  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  64  * SUCH DAMAGE.
  65  * -
  66  * Portions Copyright (c) 1993 by Digital Equipment Corporation.
  67  *
  68  * Permission to use, copy, modify, and distribute this software for any
  69  * purpose with or without fee is hereby granted, provided that the above
  70  * copyright notice and this permission notice appear in all copies, and that
  71  * the name of Digital Equipment Corporation not be used in advertising or
  72  * publicity pertaining to distribution of the document or software without
  73  * specific, written prior permission.
  74  *
  75  * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
  76  * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
  77  * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
  78  * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  79  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  80  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  81  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  82  * SOFTWARE.
  83  * -
  84  * --Copyright--
  85  */
  86
  87 /*
  88  *      Atsushi Onoe <onoe@sm.sony.co.jp>
  89  */
  90
  91 /*
  92  * TODO for thread safe
  93  *      use mutex for _hostconf, _hostconf_init.
  94  *      rewrite resolvers to be thread safe
  95  */
  96
  97 #include <sys/param.h>
  98 #include <sys/socket.h>
  99 #include <sys/time.h>
 100 #include <sys/queue.h>
 101 #include <netinet/in.h>
 102
 103 #include <arpa/inet.h>
 104 #include <arpa/nameser.h>
 105
 106 #include <errno.h>
 107 #include <netdb.h>
 108 #include <resolv.h>
 109 #include <stdio.h>
 110 #include <stdlib.h>
 111 #include <string.h>
 112 #include <unistd.h>
 113
 114 #ifndef _PATH_HOSTS
 115 #define _PATH_HOSTS     "/etc/hosts"
 116 #endif
 117
 118 #ifndef MAXALIASES
 119 #define MAXALIASES      10
 120 #endif
 121 #ifndef MAXADDRS
 122 #define MAXADDRS        20
 123 #endif
 124 #ifndef MAXDNAME
 125 #define MAXDNAME        1025
 126 #endif
 127
 128 #ifdef INET6
 129 #define ADDRLEN(af)     ((af) == AF_INET6 ? sizeof(struct in6_addr) : \
 130                                             sizeof(struct in_addr))
 131 #else
 132 #define ADDRLEN(af)     sizeof(struct in_addr)
 133 #endif
 134
 135 #define MAPADDR(ab, ina) \
 136 do {                                                                    \
 137         memcpy(&(ab)->map_inaddr, ina, sizeof(struct in_addr));         \
 138         memset((ab)->map_zero, 0, sizeof((ab)->map_zero));              \
 139         memset((ab)->map_one, 0xff, sizeof((ab)->map_one));             \
 140 } while (0)
 141 #define MAPADDRENABLED(flags) \
 142         (((flags) & AI_V4MAPPED) || \
 143          (((flags) & AI_V4MAPPED_CFG) && _mapped_addr_enabled()))
 144
 145 union inx_addr {
 146         struct in_addr  in_addr;
 147 #ifdef INET6
 148         struct in6_addr in6_addr;
 149 #endif
 150         struct {
 151                 u_char  mau_zero[10];
 152                 u_char  mau_one[2];
 153                 struct in_addr mau_inaddr;
 154         }               map_addr_un;
 155 #define map_zero        map_addr_un.mau_zero
 156 #define map_one         map_addr_un.mau_one
 157 #define map_inaddr      map_addr_un.mau_inaddr
 158 };
 159
 160 static struct    hostent *_hpcopy(struct hostent *hp, int *errp);
 161 static struct    hostent *_hpaddr(int af, const char *name, void *addr, int *errp);
 162 static struct    hostent *_hpmerge(struct hostent *hp1, struct hostent *hp2, int *errp);
 163 #ifdef INET6
 164 static struct    hostent *_hpmapv6(struct hostent *hp, int *errp);
 165 #endif
 166 static struct    hostent *_hpsort(struct hostent *hp);
 167 static struct    hostent *_ghbyname(const char *name, int af, int flags, int *errp);
 168 static char     *_hgetword(char **pp);
 169 static int       _mapped_addr_enabled(void);
 170
 171 static FILE     *_files_open(int *errp);
 172 static struct    hostent *_files_ghbyname(const char *name, int af, int *errp);
 173 static struct    hostent *_files_ghbyaddr(const void *addr, int addrlen, int af, int *errp);
 174 static void      _files_shent(int stayopen);
 175 static void      _files_ehent(void);
 176 #ifdef YP
 177 static struct    hostent *_nis_ghbyname(const char *name, int af, int *errp);
 178 static struct    hostent *_nis_ghbyaddr(const void *addr, int addrlen, int af, int *errp);
 179 #endif
 180 static struct    hostent *_dns_ghbyname(const char *name, int af, int *errp);
 181 static struct    hostent *_dns_ghbyaddr(const void *addr, int addrlen, int af, int *errp);
 182 static void      _dns_shent(int stayopen);
 183 static void      _dns_ehent(void);
 184 #ifdef ICMPNL
 185 static struct    hostent *_icmp_ghbyaddr(const void *addr, int addrlen, int af, int *errp);
 186 #endif /* ICMPNL */
 187
 188 /* Make getipnodeby*() thread-safe in libc for use with kernel threads. */
 189 #include "libc_private.h"
 190 #include "spinlock.h"
 191 /*
 192  * XXX: Our res_*() is not thread-safe.  So, we share lock between
 193  * getaddrinfo() and getipnodeby*().  Still, we cannot use
 194  * getaddrinfo() and getipnodeby*() in conjunction with other
 195  * functions which call res_*().
 196  */
 197 extern spinlock_t __getaddrinfo_thread_lock;
 198 #define THREAD_LOCK() \
 199         if (__isthreaded) _SPINLOCK(&__getaddrinfo_thread_lock);
 200 #define THREAD_UNLOCK() \
 201         if (__isthreaded) _SPINUNLOCK(&__getaddrinfo_thread_lock);
 202
 203 /*
 204  * Select order host function.
 205  */
 206 #define MAXHOSTCONF     4
 207
 208 #ifndef HOSTCONF
 209 #  define       HOSTCONF        "/etc/host.conf"
 210 #endif /* !HOSTCONF */
 211
 212 struct _hostconf {
 213         struct hostent *(*byname)(const char *name, int af, int *errp);
 214         struct hostent *(*byaddr)(const void *addr, int addrlen, int af, int *errp);
 215 };
 216
 217 /* default order */
 218 static struct _hostconf _hostconf[MAXHOSTCONF] = {
 219         { _dns_ghbyname,        _dns_ghbyaddr },
 220         { _files_ghbyname,      _files_ghbyaddr },
 221 #ifdef ICMPNL
 222         { NULL,                 _icmp_ghbyaddr },
 223 #endif /* ICMPNL */
 224 };
 225
 226 static int      _hostconf_init_done;
 227 static void     _hostconf_init(void);
 228
 229 /*
 230  * Initialize hostconf structure.
 231  */
 232
 233 static void
 234 _hostconf_init(void)
 235 {
 236         FILE *fp;
 237         int n;
 238         char *p, *line;
 239         char buf[BUFSIZ];
 240
 241         _hostconf_init_done = 1;
 242         n = 0;
 243         p = HOSTCONF;
 244         if ((fp = fopen(p, "r")) == NULL)
 245                 return;
 246         while (n < MAXHOSTCONF && fgets(buf, sizeof(buf), fp)) {
 247                 line = buf;
 248                 if ((p = _hgetword(&line)) == NULL)
 249                         continue;
 250                 do {
 251                         if (strcmp(p, "hosts") == 0
 252                         ||  strcmp(p, "local") == 0
 253                         ||  strcmp(p, "file") == 0
 254                         ||  strcmp(p, "files") == 0) {
 255                                 _hostconf[n].byname = _files_ghbyname;
 256                                 _hostconf[n].byaddr = _files_ghbyaddr;
 257                                 n++;
 258                         }
 259                         else if (strcmp(p, "dns") == 0
 260                              ||  strcmp(p, "bind") == 0) {
 261                                 _hostconf[n].byname = _dns_ghbyname;
 262                                 _hostconf[n].byaddr = _dns_ghbyaddr;
 263                                 n++;
 264                         }
 265 #ifdef YP
 266                         else if (strcmp(p, "nis") == 0) {
 267                                 _hostconf[n].byname = _nis_ghbyname;
 268                                 _hostconf[n].byaddr = _nis_ghbyaddr;
 269                                 n++;
 270                         }
 271 #endif
 272 #ifdef ICMPNL
 273                         else if (strcmp(p, "icmp") == 0) {
 274                                 _hostconf[n].byname = NULL;
 275                                 _hostconf[n].byaddr = _icmp_ghbyaddr;
 276                                 n++;
 277                         }
 278 #endif /* ICMPNL */
 279                 } while ((p = _hgetword(&line)) != NULL);
 280         }
 281         fclose(fp);
 282         if (n < 0) {
 283                 /* no keyword found. do not change default configuration */
 284                 return;
 285         }
 286         for (; n < MAXHOSTCONF; n++) {
 287                 _hostconf[n].byname = NULL;
 288                 _hostconf[n].byaddr = NULL;
 289         }
 290 }
 291
 292 /*
 293  * Check if kernel supports mapped address.
 294  *      implementation dependent
 295  */
 296 #ifdef __KAME__
 297 #include <sys/sysctl.h>
 298 #endif /* __KAME__ */
 299
 300 static int
 301 _mapped_addr_enabled(void)
 302 {
 303         /* implementation dependent check */
 304 #if defined(__KAME__) && defined(IPV6CTL_MAPPED_ADDR)
 305         int mib[4];
 306         size_t len;
 307         int val;
 308
 309         mib[0] = CTL_NET;
 310         mib[1] = PF_INET6;
 311         mib[2] = IPPROTO_IPV6;
 312         mib[3] = IPV6CTL_MAPPED_ADDR;
 313         len = sizeof(val);
 314         if (sysctl(mib, 4, &val, &len, 0, 0) == 0 && val != 0)
 315                 return 1;
 316 #endif /* __KAME__ && IPV6CTL_MAPPED_ADDR */
 317         return 0;
 318 }
 319
 320 /*
 321  * Functions defined in RFC2553
 322  *      getipnodebyname, getipnodebyaddr, freehostent
 323  */
 324
 325 static struct hostent *
 326 _ghbyname(const char *name, int af, int flags, int *errp)
 327 {
 328         struct hostent *hp;
 329         int i;
 330
 331         if (flags & AI_ADDRCONFIG) {
 332                 int s;
 333
 334                 /*
 335                  * TODO:
 336                  * Note that implementation dependent test for address
 337                  * configuration should be done everytime called
 338                  * (or apropriate interval),
 339                  * because addresses will be dynamically assigned or deleted.
 340                  */
 341                 if (af == AF_UNSPEC) {
 342                         if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
 343                                 af = AF_INET;
 344                         else {
 345                                 _close(s);
 346                                 if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
 347                                         af = AF_INET6;
 348                                 else
 349                                 _close(s);
 350                         }
 351
 352                 }
 353                 if (af != AF_UNSPEC) {
 354                         if ((s = socket(af, SOCK_DGRAM, 0)) < 0)
 355                                 return NULL;
 356                         _close(s);
 357                 }
 358         }
 359
 360         THREAD_LOCK();
 361         for (i = 0; i < MAXHOSTCONF; i++) {
 362                 if (_hostconf[i].byname
 363                     && (hp = (*_hostconf[i].byname)(name, af, errp)) != NULL) {
 364                         THREAD_UNLOCK();
 365                         return hp;
 366                 }
 367         }
 368         THREAD_UNLOCK();
 369
 370         return NULL;
 371 }
 372
 373 /* getipnodebyname() internal routine for multiple query(PF_UNSPEC) support. */
 374 struct hostent *
 375 _getipnodebyname_multi(const char *name, int af, int flags, int *errp)
 376 {
 377         struct hostent *hp;
 378         union inx_addr addrbuf;
 379
 380         /* XXX: PF_UNSPEC is only supposed to be passed from getaddrinfo() */
 381         if (af != AF_INET
 382 #ifdef INET6
 383             && af != AF_INET6
 384 #endif
 385             && af != PF_UNSPEC
 386                 )
 387         {
 388                 *errp = NO_RECOVERY;
 389                 return NULL;
 390         }
 391
 392 #ifdef INET6
 393         /* special case for literal address */
 394         if (inet_pton(AF_INET6, name, &addrbuf) == 1) {
 395                 if (af != AF_INET6) {
 396                         *errp = HOST_NOT_FOUND;
 397                         return NULL;
 398                 }
 399                 return _hpaddr(af, name, &addrbuf, errp);
 400         }
 401 #endif
 402         if (inet_aton(name, (struct in_addr *)&addrbuf) == 1) {
 403                 if (af != AF_INET) {
 404                         if (MAPADDRENABLED(flags)) {
 405                                 MAPADDR(&addrbuf, &addrbuf.in_addr);
 406                         } else {
 407                                 *errp = HOST_NOT_FOUND;
 408                                 return NULL;
 409                         }
 410                 }
 411                 return _hpaddr(af, name, &addrbuf, errp);
 412         }
 413
 414         if (!_hostconf_init_done)
 415                 _hostconf_init();
 416
 417         *errp = HOST_NOT_FOUND;
 418         hp = _ghbyname(name, af, flags, errp);
 419
 420 #ifdef INET6
 421         if (af == AF_INET6
 422         &&  ((flags & AI_ALL) || hp == NULL)
 423         &&  (MAPADDRENABLED(flags))) {
 424                 struct hostent *hp2 = _ghbyname(name, AF_INET, flags, errp);
 425                 if (hp == NULL)
 426                         hp = _hpmapv6(hp2, errp);
 427                 else {
 428                         if (hp2 && strcmp(hp->h_name, hp2->h_name) != 0) {
 429                                 freehostent(hp2);
 430                                 hp2 = NULL;
 431                         }
 432                         hp = _hpmerge(hp, hp2, errp);
 433                 }
 434         }
 435 #endif
 436         return _hpsort(hp);
 437 }
 438
 439 struct hostent *
 440 getipnodebyname(const char *name, int af, int flags, int *errp)
 441 {
 442         if (af != AF_INET
 443 #ifdef INET6
 444             && af != AF_INET6
 445 #endif
 446                 )
 447         {
 448                 *errp = NO_RECOVERY;
 449                 return NULL;
 450         }
 451         return(_getipnodebyname_multi(name, af ,flags, errp));
 452 }
 453
 454 struct hostent *
 455 getipnodebyaddr(const void *src, size_t len, int af, int *errp)
 456 {
 457         struct hostent *hp;
 458         int i;
 459 #ifdef INET6
 460         struct in6_addr addrbuf;
 461 #else
 462         struct in_addr addrbuf;
 463 #endif
 464
 465         *errp = HOST_NOT_FOUND;
 466
 467         switch (af) {
 468         case AF_INET:
 469                 if (len != sizeof(struct in_addr)) {
 470                         *errp = NO_RECOVERY;
 471                         return NULL;
 472                 }
 473                 if ((long)src & ~(sizeof(struct in_addr) - 1)) {
 474                         memcpy(&addrbuf, src, len);
 475                         src = &addrbuf;
 476                 }
 477                 if (((struct in_addr *)src)->s_addr == 0)
 478                         return NULL;
 479                 break;
 480 #ifdef INET6
 481         case AF_INET6:
 482                 if (len != sizeof(struct in6_addr)) {
 483                         *errp = NO_RECOVERY;
 484                         return NULL;
 485                 }
 486                 if ((long)src & ~(sizeof(struct in6_addr) / 2 - 1)) {   /*XXX*/
 487                         memcpy(&addrbuf, src, len);
 488                         src = &addrbuf;
 489                 }
 490                 if (IN6_IS_ADDR_UNSPECIFIED((struct in6_addr *)src))
 491                         return NULL;
 492                 if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)src)
 493                 ||  IN6_IS_ADDR_V4COMPAT((struct in6_addr *)src)) {
 494                         src = (char *)src +
 495                             (sizeof(struct in6_addr) - sizeof(struct in_addr));
 496                         af = AF_INET;
 497                         len = sizeof(struct in_addr);
 498                 }
 499                 break;
 500 #endif
 501         default:
 502                 *errp = NO_RECOVERY;
 503                 return NULL;
 504         }
 505
 506         if (!_hostconf_init_done)
 507                 _hostconf_init();
 508         THREAD_LOCK();
 509         for (i = 0; i < MAXHOSTCONF; i++) {
 510                 if (_hostconf[i].byaddr
 511                 && (hp = (*_hostconf[i].byaddr)(src, len, af, errp)) != NULL) {
 512                         THREAD_UNLOCK();
 513                         return hp;
 514                 }
 515         }
 516         THREAD_UNLOCK();
 517
 518         return NULL;
 519 }
 520
 521 void
 522 freehostent(struct hostent *ptr)
 523 {
 524         free(ptr);
 525 }
 526
 527 #if 0
 528
 529 /* XXX: should be deprecated */
 530 struct hostent *
 531 getnodebyname(const char *name, int af, int flags)
 532 {
 533         return getipnodebyname(name, af, flags, &h_errno);
 534 }
 535
 536 #ifdef __warn_references
 537 __warn_references(getnodebyname,
 538         "warning: getnodebyname() deprecated, "
 539         "should use getaddrinfo() or getipnodebyname()");
 540 #endif
 541
 542 struct hostent *
 543 getnodebyaddr(const void *src, size_t len, int af)
 544 {
 545         return getipnodebyaddr(src, len, af, &h_errno);
 546 }
 547
 548 #ifdef __warn_references
 549 __warn_references(getnodebyaddr,
 550         "warning: getnodebyaddr() deprecated, "
 551         "should use getnameinfo() or getipnodebyaddr()");
 552 #endif
 553
 554 #endif
 555
 556 /*
 557  * Private utility functions
 558  */
 559
 560 /*
 561  * _hpcopy: allocate and copy hostent structure
 562  */
 563 static struct hostent *
 564 _hpcopy(struct hostent *hp, int *errp)
 565 {
 566         struct hostent *nhp;
 567         char *cp, **pp;
 568         int size, addrsize;
 569         int nalias = 0, naddr = 0;
 570         int al_off;
 571         int i;
 572
 573         if (hp == NULL)
 574                 return hp;
 575
 576         /* count size to be allocated */
 577         size = sizeof(struct hostent);
 578         if (hp->h_name != NULL)
 579                 size += strlen(hp->h_name) + 1;
 580         if ((pp = hp->h_aliases) != NULL) {
 581                 for (i = 0; *pp != NULL; i++, pp++) {
 582                         if (**pp != '\0') {
 583                                 size += strlen(*pp) + 1;
 584                                 nalias++;
 585                         }
 586                 }
 587         }
 588         /* adjust alignment */
 589         size = ALIGN(size);
 590         al_off = size;
 591         size += sizeof(char *) * (nalias + 1);
 592         addrsize = ALIGN(hp->h_length);
 593         if ((pp = hp->h_addr_list) != NULL) {
 594                 while (*pp++ != NULL)
 595                         naddr++;
 596         }
 597         size += addrsize * naddr;
 598         size += sizeof(char *) * (naddr + 1);
 599
 600         /* copy */
 601         if ((nhp = (struct hostent *)malloc(size)) == NULL) {
 602                 *errp = TRY_AGAIN;
 603                 return NULL;
 604         }
 605         cp = (char *)&nhp[1];
 606         if (hp->h_name != NULL) {
 607                 nhp->h_name = cp;
 608                 strcpy(cp, hp->h_name);
 609                 cp += strlen(cp) + 1;
 610         } else
 611                 nhp->h_name = NULL;
 612         nhp->h_aliases = (char **)((char *)nhp + al_off);
 613         if ((pp = hp->h_aliases) != NULL) {
 614                 for (i = 0; *pp != NULL; pp++) {
 615                         if (**pp != '\0') {
 616                                 nhp->h_aliases[i++] = cp;
 617                                 strcpy(cp, *pp);
 618                                 cp += strlen(cp) + 1;
 619                         }
 620                 }
 621         }
 622         nhp->h_aliases[nalias] = NULL;
 623         cp = (char *)&nhp->h_aliases[nalias + 1];
 624         nhp->h_addrtype = hp->h_addrtype;
 625         nhp->h_length = hp->h_length;
 626         nhp->h_addr_list = (char **)cp;
 627         if ((pp = hp->h_addr_list) != NULL) {
 628                 cp = (char *)&nhp->h_addr_list[naddr + 1];
 629                 for (i = 0; *pp != NULL; pp++) {
 630                         nhp->h_addr_list[i++] = cp;
 631                         memcpy(cp, *pp, hp->h_length);
 632                         cp += addrsize;
 633                 }
 634         }
 635         nhp->h_addr_list[naddr] = NULL;
 636         return nhp;
 637 }
 638
 639 /*
 640  * _hpaddr: construct hostent structure with one address
 641  */
 642 static struct hostent *
 643 _hpaddr(int af, const char *name, void *addr, int *errp)
 644 {
 645         struct hostent *hp, hpbuf;
 646         char *addrs[2];
 647
 648         hp = &hpbuf;
 649         hp->h_name = (char *)name;
 650         hp->h_aliases = NULL;
 651         hp->h_addrtype = af;
 652         hp->h_length = ADDRLEN(af);
 653         hp->h_addr_list = addrs;
 654         addrs[0] = (char *)addr;
 655         addrs[1] = NULL;
 656         return _hpcopy(hp, errp);
 657 }
 658
 659 /*
 660  * _hpmerge: merge 2 hostent structure, arguments will be freed
 661  */
 662 static struct hostent *
 663 _hpmerge(struct hostent *hp1, struct hostent *hp2, int *errp)
 664 {
 665         int i, j;
 666         int naddr, nalias;
 667         char **pp;
 668         struct hostent *hp, hpbuf;
 669         char *aliases[MAXALIASES + 1], *addrs[MAXADDRS + 1];
 670         union inx_addr addrbuf[MAXADDRS];
 671
 672         if (hp1 == NULL)
 673                 return hp2;
 674         if (hp2 == NULL)
 675                 return hp1;
 676
 677 #define HP(i)   (i == 1 ? hp1 : hp2)
 678         hp = &hpbuf;
 679         hp->h_name = (hp1->h_name != NULL ? hp1->h_name : hp2->h_name);
 680         hp->h_aliases = aliases;
 681         nalias = 0;
 682         for (i = 1; i <= 2; i++) {
 683                 if ((pp = HP(i)->h_aliases) == NULL)
 684                         continue;
 685                 for (; nalias < MAXALIASES && *pp != NULL; pp++) {
 686                         /* check duplicates */
 687                         for (j = 0; j < nalias; j++)
 688                                 if (strcasecmp(*pp, aliases[j]) == 0)
 689                                         break;
 690                         if (j == nalias)
 691                                 aliases[nalias++] = *pp;
 692                 }
 693         }
 694         aliases[nalias] = NULL;
 695 #ifdef INET6
 696         if (hp1->h_length != hp2->h_length) {
 697                 hp->h_addrtype = AF_INET6;
 698                 hp->h_length = sizeof(struct in6_addr);
 699         } else {
 700 #endif
 701                 hp->h_addrtype = hp1->h_addrtype;
 702                 hp->h_length = hp1->h_length;
 703 #ifdef INET6
 704         }
 705 #endif
 706         hp->h_addr_list = addrs;
 707         naddr = 0;
 708         for (i = 1; i <= 2; i++) {
 709                 if ((pp = HP(i)->h_addr_list) == NULL)
 710                         continue;
 711                 if (HP(i)->h_length == hp->h_length) {
 712                         while (naddr < MAXADDRS && *pp != NULL)
 713                                 addrs[naddr++] = *pp++;
 714                 } else {
 715                         /* copy IPv4 addr as mapped IPv6 addr */
 716                         while (naddr < MAXADDRS && *pp != NULL) {
 717                                 MAPADDR(&addrbuf[naddr], *pp++);
 718                                 addrs[naddr] = (char *)&addrbuf[naddr];
 719                                 naddr++;
 720                         }
 721                 }
 722         }
 723         addrs[naddr] = NULL;
 724         hp = _hpcopy(hp, errp);
 725         freehostent(hp1);
 726         freehostent(hp2);
 727         return hp;
 728 }
 729
 730 /*
 731  * _hpmapv6: convert IPv4 hostent into IPv4-mapped IPv6 addresses
 732  */
 733 #ifdef INET6
 734 static struct hostent *
 735 _hpmapv6(struct hostent *hp, int *errp)
 736 {
 737         struct hostent *hp6;
 738
 739         if (hp == NULL)
 740                 return NULL;
 741         if (hp->h_addrtype == AF_INET6)
 742                 return hp;
 743
 744         /* make dummy hostent to convert IPv6 address */
 745         if ((hp6 = (struct hostent *)malloc(sizeof(struct hostent))) == NULL) {
 746                 *errp = TRY_AGAIN;
 747                 return NULL;
 748         }
 749         hp6->h_name = NULL;
 750         hp6->h_aliases = NULL;
 751         hp6->h_addrtype = AF_INET6;
 752         hp6->h_length = sizeof(struct in6_addr);
 753         hp6->h_addr_list = NULL;
 754         return _hpmerge(hp6, hp, errp);
 755 }
 756 #endif
 757
 758 /*
 759  * _hpsort: sort address by sortlist
 760  */
 761 static struct hostent *
 762 _hpsort(struct hostent *hp)
 763 {
 764         int i, j, n;
 765         u_char *ap, *sp, *mp, **pp;
 766         char t;
 767         char order[MAXADDRS];
 768         int nsort = _res.nsort;
 769
 770         if (hp == NULL || hp->h_addr_list[1] == NULL || nsort == 0)
 771                 return hp;
 772         for (i = 0; (ap = (u_char *)hp->h_addr_list[i]); i++) {
 773                 for (j = 0; j < nsort; j++) {
 774 #ifdef INET6
 775                         if (_res_ext.sort_list[j].af != hp->h_addrtype)
 776                                 continue;
 777                         sp = (u_char *)&_res_ext.sort_list[j].addr;
 778                         mp = (u_char *)&_res_ext.sort_list[j].mask;
 779 #else
 780                         sp = (u_char *)&_res.sort_list[j].addr;
 781                         mp = (u_char *)&_res.sort_list[j].mask;
 782 #endif
 783                         for (n = 0; n < hp->h_length; n++) {
 784                                 if ((ap[n] & mp[n]) != sp[n])
 785                                         break;
 786                         }
 787                         if (n == hp->h_length)
 788                                 break;
 789                 }
 790                 order[i] = j;
 791         }
 792         n = i;
 793         pp = (u_char **)hp->h_addr_list;
 794         for (i = 0; i < n - 1; i++) {
 795                 for (j = i + 1; j < n; j++) {
 796                         if (order[i] > order[j]) {
 797                                 ap = pp[i];
 798                                 pp[i] = pp[j];
 799                                 pp[j] = ap;
 800                                 t = order[i];
 801                                 order[i] = order[j];
 802                                 order[j] = t;
 803                         }
 804                 }
 805         }
 806         return hp;
 807 }
 808
 809 static char *
 810 _hgetword(char **pp)
 811 {
 812         char c, *p, *ret;
 813         const char *sp;
 814         static const char sep[] = "# \t\n";
 815
 816         ret = NULL;
 817         for (p = *pp; (c = *p) != '\0'; p++) {
 818                 for (sp = sep; *sp != '\0'; sp++) {
 819                         if (c == *sp)
 820                                 break;
 821                 }
 822                 if (c == '#')
 823                         p[1] = '\0';    /* ignore rest of line */
 824                 if (ret == NULL) {
 825                         if (*sp == '\0')
 826                                 ret = p;
 827                 } else {
 828                         if (*sp != '\0') {
 829                                 *p++ = '\0';
 830                                 break;
 831                         }
 832                 }
 833         }
 834         *pp = p;
 835         if (ret == NULL || *ret == '\0')
 836                 return NULL;
 837         return ret;
 838 }
 839
 840 /*
 841  * FILES (/etc/hosts)
 842  */
 843
 844 static FILE *
 845 _files_open(int *errp)
 846 {
 847         FILE *fp;
 848         fp = fopen(_PATH_HOSTS, "r");
 849         if (fp == NULL)
 850                 *errp = NO_RECOVERY;
 851         return fp;
 852 }
 853
 854 static struct hostent *
 855 _files_ghbyname(const char *name, int af, int *errp)
 856 {
 857         int match, nalias;
 858         char *p, *line, *addrstr, *cname;
 859         FILE *fp;
 860         struct hostent *rethp, *hp, hpbuf;
 861         char *aliases[MAXALIASES + 1], *addrs[2];
 862         union inx_addr addrbuf;
 863         char buf[BUFSIZ];
 864         int af0 = af;
 865
 866         if ((fp = _files_open(errp)) == NULL)
 867                 return NULL;
 868         rethp = hp = NULL;
 869
 870         while (fgets(buf, sizeof(buf), fp)) {
 871                 line = buf;
 872                 if ((addrstr = _hgetword(&line)) == NULL
 873                 ||  (cname = _hgetword(&line)) == NULL)
 874                         continue;
 875                 match = (strcasecmp(cname, name) == 0);
 876                 nalias = 0;
 877                 while ((p = _hgetword(&line)) != NULL) {
 878                         if (!match)
 879                                 match = (strcasecmp(p, name) == 0);
 880                         if (nalias < MAXALIASES)
 881                                 aliases[nalias++] = p;
 882                 }
 883                 if (!match)
 884                         continue;
 885                 switch (af0) {
 886                 case AF_INET:
 887                         if (inet_aton(addrstr, (struct in_addr *)&addrbuf)
 888                             != 1) {
 889                                 *errp = NO_DATA;        /* name found */
 890                                 continue;
 891                         }
 892                         af = af0;
 893                         break;
 894 #ifdef INET6
 895                 case AF_INET6:
 896                         if (inet_pton(af, addrstr, &addrbuf) != 1) {
 897                                 *errp = NO_DATA;        /* name found */
 898                                 continue;
 899                         }
 900                         af = af0;
 901                         break;
 902 #endif
 903                 case AF_UNSPEC:
 904                         if (inet_aton(addrstr, (struct in_addr *)&addrbuf)
 905                             == 1) {
 906                                 af = AF_INET;
 907                                 break;
 908                         }
 909 #ifdef INET6
 910                         if (inet_pton(AF_INET6, addrstr, &addrbuf) == 1) {
 911                                 af = AF_INET6;
 912                                 break;
 913                         }
 914 #endif
 915                         *errp = NO_DATA;        /* name found */
 916                         continue;
 917                         /* NOTREACHED */
 918                 }
 919                 hp = &hpbuf;
 920                 hp->h_name = cname;
 921                 hp->h_aliases = aliases;
 922                 aliases[nalias] = NULL;
 923                 hp->h_addrtype = af;
 924                 hp->h_length = ADDRLEN(af);
 925                 hp->h_addr_list = addrs;
 926                 addrs[0] = (char *)&addrbuf;
 927                 addrs[1] = NULL;
 928                 hp = _hpcopy(hp, errp);
 929                 rethp = _hpmerge(rethp, hp, errp);
 930         }
 931         fclose(fp);
 932         return rethp;
 933 }
 934
 935 static struct hostent *
 936 _files_ghbyaddr(const void *addr, int addrlen, int af, int *errp)
 937 {
 938         int nalias;
 939         char *p, *line;
 940         FILE *fp;
 941         struct hostent *hp, hpbuf;
 942         char *aliases[MAXALIASES + 1], *addrs[2];
 943         union inx_addr addrbuf;
 944         char buf[BUFSIZ];
 945
 946         if ((fp = _files_open(errp)) == NULL)
 947                 return NULL;
 948         hp = NULL;
 949         while (fgets(buf, sizeof(buf), fp)) {
 950                 line = buf;
 951                 if ((p = _hgetword(&line)) == NULL
 952                 ||  (af == AF_INET
 953                      ? inet_aton(p, (struct in_addr *)&addrbuf)
 954                      : inet_pton(af, p, &addrbuf)) != 1
 955                 ||  memcmp(addr, &addrbuf, addrlen) != 0
 956                 ||  (p = _hgetword(&line)) == NULL)
 957                         continue;
 958                 hp = &hpbuf;
 959                 hp->h_name = p;
 960                 hp->h_aliases = aliases;
 961                 nalias = 0;
 962                 while ((p = _hgetword(&line)) != NULL) {
 963                         if (nalias < MAXALIASES)
 964                                 aliases[nalias++] = p;
 965                 }
 966                 aliases[nalias] = NULL;
 967                 hp->h_addrtype = af;
 968                 hp->h_length = addrlen;
 969                 hp->h_addr_list = addrs;
 970                 addrs[0] = (char *)&addrbuf;
 971                 addrs[1] = NULL;
 972                 hp = _hpcopy(hp, errp);
 973                 break;
 974         }
 975         fclose(fp);
 976         return hp;
 977 }
 978
 979 #ifdef YP
 980 /*
 981  * NIS
 982  *
 983  * XXX actually a hack, these are INET4 specific.
 984  */
 985 static struct hostent *
 986 _nis_ghbyname(const char *name, int af, int *errp)
 987 {
 988         struct hostent *hp = NULL;
 989
 990         if (af == AF_UNSPEC)
 991                 af = AF_INET;
 992         if (af == AF_INET) {
 993                 hp = _gethostbynisname(name, af);
 994                 if (hp != NULL)
 995                         hp = _hpcopy(hp, errp);
 996         }
 997         return (hp);
 998
 999 }
1000
1001 static struct hostent *
1002 _nis_ghbyaddr(const void *addr, int addrlen, int af, int *errp)
1003 {
1004         struct hostent *hp = NULL;
1005
1006         if (af == AF_INET) {
1007                 hp = _gethostbynisaddr(addr, addrlen, af);
1008                 if (hp != NULL)
1009                         hp = _hpcopy(hp, errp);
1010         }
1011         return (hp);
1012 }
1013 #endif
1014
1015 struct __res_type_list {
1016         SLIST_ENTRY(__res_type_list) rtl_entry;
1017         int     rtl_type;
1018 };
1019
1020 #define MAXPACKET       (64*1024)
1021
1022 typedef union {
1023         HEADER hdr;
1024         u_char buf[MAXPACKET];
1025 } querybuf;
1026
1027 static struct hostent *getanswer __P((const querybuf *, int, const char *,
1028         int, struct hostent *, int *));
1029
1030 /*
1031  * we don't need to take care about sorting, nor IPv4 mapped address here.
1032  */
1033 static struct hostent *
1034 getanswer(answer, anslen, qname, qtype, template, errp)
1035         const querybuf *answer;
1036         int anslen;
1037         const char *qname;
1038         int qtype;
1039         struct hostent *template;
1040         int *errp;
1041 {
1042         register const HEADER *hp;
1043         register const u_char *cp;
1044         register int n;
1045         const u_char *eom, *erdata;
1046         char *bp, **ap, **hap, *obp;
1047         int type, class, buflen, ancount, qdcount;
1048         int haveanswer, had_error;
1049         char tbuf[MAXDNAME];
1050         const char *tname;
1051         int (*name_ok) __P((const char *));
1052         static char *h_addr_ptrs[MAXADDRS + 1];
1053         static char *host_aliases[MAXALIASES];
1054         static char hostbuf[8*1024];
1055
1056 #define BOUNDED_INCR(x) \
1057         do { \
1058                 cp += x; \
1059                 if (cp > eom) { \
1060                         *errp = NO_RECOVERY; \
1061                         return (NULL); \
1062                 } \
1063         } while (0)
1064
1065 #define BOUNDS_CHECK(ptr, count) \
1066         do { \
1067                 if ((ptr) + (count) > eom) { \
1068                         *errp = NO_RECOVERY; \
1069                         return (NULL); \
1070                 } \
1071         } while (0)
1072
1073 /* XXX do {} while (0) cannot be put here */
1074 #define DNS_ASSERT(x) \
1075         {                               \
1076                 if (!(x)) {             \
1077                         cp += n;        \
1078                         continue;       \
1079                 }                       \
1080         }
1081
1082 /* XXX do {} while (0) cannot be put here */
1083 #define DNS_FATAL(x) \
1084         {                               \
1085                 if (!(x)) {             \
1086                         had_error++;    \
1087                         continue;       \
1088                 }                       \
1089         }
1090
1091         tname = qname;
1092         template->h_name = NULL;
1093         eom = answer->buf + anslen;
1094         switch (qtype) {
1095         case T_A:
1096         case T_AAAA:
1097                 name_ok = res_hnok;
1098                 break;
1099         case T_PTR:
1100                 name_ok = res_dnok;
1101                 break;
1102         default:
1103                 return (NULL);  /* XXX should be abort(); */
1104         }
1105         /*
1106          * find first satisfactory answer
1107          */
1108         hp = &answer->hdr;
1109         ancount = ntohs(hp->ancount);
1110         qdcount = ntohs(hp->qdcount);
1111         bp = hostbuf;
1112         buflen = sizeof hostbuf;
1113         cp = answer->buf;
1114         BOUNDED_INCR(HFIXEDSZ);
1115         if (qdcount != 1) {
1116                 *errp = NO_RECOVERY;
1117                 return (NULL);
1118         }
1119         n = dn_expand(answer->buf, eom, cp, bp, buflen);
1120         if ((n < 0) || !(*name_ok)(bp)) {
1121                 *errp = NO_RECOVERY;
1122                 return (NULL);
1123         }
1124         BOUNDED_INCR(n + QFIXEDSZ);
1125         if (qtype == T_A || qtype == T_AAAA) {
1126                 /* res_send() has already verified that the query name is the
1127                  * same as the one we sent; this just gets the expanded name
1128                  * (i.e., with the succeeding search-domain tacked on).
1129                  */
1130                 n = strlen(bp) + 1;             /* for the \0 */
1131                 if (n >= MAXHOSTNAMELEN) {
1132                         *errp = NO_RECOVERY;
1133                         return (NULL);
1134                 }
1135                 template->h_name = bp;
1136                 bp += n;
1137                 buflen -= n;
1138                 /* The qname can be abbreviated, but h_name is now absolute. */
1139                 qname = template->h_name;
1140         }
1141         ap = host_aliases;
1142         *ap = NULL;
1143         template->h_aliases = host_aliases;
1144         hap = h_addr_ptrs;
1145         *hap = NULL;
1146         template->h_addr_list = h_addr_ptrs;
1147         haveanswer = 0;
1148         had_error = 0;
1149         while (ancount-- > 0 && cp < eom && !had_error) {
1150                 n = dn_expand(answer->buf, eom, cp, bp, buflen);
1151                 DNS_FATAL(n >= 0);
1152                 DNS_FATAL((*name_ok)(bp));
1153                 cp += n;                        /* name */
1154                 BOUNDS_CHECK(cp, 3 * INT16SZ + INT32SZ);
1155                 type = _getshort(cp);
1156                 cp += INT16SZ;                  /* type */
1157                 class = _getshort(cp);
1158                 cp += INT16SZ + INT32SZ;        /* class, TTL */
1159                 n = _getshort(cp);
1160                 cp += INT16SZ;                  /* len */
1161                 BOUNDS_CHECK(cp, n);
1162                 erdata = cp + n;
1163                 DNS_ASSERT(class == C_IN);
1164                 if ((qtype == T_A || qtype == T_AAAA) && type == T_CNAME) {
1165                         if (ap >= &host_aliases[MAXALIASES-1])
1166                                 continue;
1167                         n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
1168                         DNS_FATAL(n >= 0);
1169                         DNS_FATAL((*name_ok)(tbuf));
1170                         cp += n;
1171                         if (cp != erdata) {
1172                                 *errp = NO_RECOVERY;
1173                                 return (NULL);
1174                         }
1175                         /* Store alias. */
1176                         *ap++ = bp;
1177                         n = strlen(bp) + 1;     /* for the \0 */
1178                         DNS_FATAL(n < MAXHOSTNAMELEN);
1179                         bp += n;
1180                         buflen -= n;
1181                         /* Get canonical name. */
1182                         n = strlen(tbuf) + 1;   /* for the \0 */
1183                         DNS_FATAL(n <= buflen);
1184                         DNS_FATAL(n < MAXHOSTNAMELEN);
1185                         strcpy(bp, tbuf);
1186                         template->h_name = bp;
1187                         bp += n;
1188                         buflen -= n;
1189                         continue;
1190                 }
1191                 if (qtype == T_PTR && type == T_CNAME) {
1192                         n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
1193                         if (n < 0 || !res_dnok(tbuf)) {
1194                                 had_error++;
1195                                 continue;
1196                         }
1197                         cp += n;
1198                         if (cp != erdata) {
1199                                 *errp = NO_RECOVERY;
1200                                 return (NULL);
1201                         }
1202                         /* Get canonical name. */
1203                         n = strlen(tbuf) + 1;   /* for the \0 */
1204                         if (n > buflen || n >= MAXHOSTNAMELEN) {
1205                                 had_error++;
1206                                 continue;
1207                         }
1208                         strcpy(bp, tbuf);
1209                         tname = bp;
1210                         bp += n;
1211                         buflen -= n;
1212                         continue;
1213                 }
1214                 DNS_ASSERT(type == qtype);
1215                 switch (type) {
1216                 case T_PTR:
1217                         DNS_ASSERT(strcasecmp(tname, bp) == 0);
1218                         n = dn_expand(answer->buf, eom, cp, bp, buflen);
1219                         DNS_FATAL(n >= 0);
1220                         DNS_FATAL(res_hnok(bp));
1221 #if MULTI_PTRS_ARE_ALIASES
1222                         cp += n;
1223                         if (cp != erdata) {
1224                                 *errp = NO_RECOVERY;
1225                                 return (NULL);
1226                         }
1227                         if (!haveanswer)
1228                                 template->h_name = bp;
1229                         else if (ap < &host_aliases[MAXALIASES-1])
1230                                 *ap++ = bp;
1231                         else
1232                                 n = -1;
1233                         if (n != -1) {
1234                                 n = strlen(bp) + 1;     /* for the \0 */
1235                                 if (n >= MAXHOSTNAMELEN) {
1236                                         had_error++;
1237                                         break;
1238                                 }
1239                                 bp += n;
1240                                 buflen -= n;
1241                         }
1242                         break;
1243 #else
1244                         template->h_name = bp;
1245                         *errp = NETDB_SUCCESS;
1246                         return (template);
1247 #endif
1248                 case T_A:
1249                 case T_AAAA:
1250                         DNS_ASSERT(strcasecmp(template->h_name, bp) == 0);
1251                         DNS_ASSERT(n == template->h_length);
1252                         if (!haveanswer) {
1253                                 register int nn;
1254
1255                                 template->h_name = bp;
1256                                 nn = strlen(bp) + 1;    /* for the \0 */
1257                                 bp += nn;
1258                                 buflen -= nn;
1259                         }
1260                         obp = bp; /* ALIGN rounds up */
1261                         bp = (char *)ALIGN(bp);
1262                         buflen -= (bp - obp);
1263
1264                         DNS_FATAL(bp + n < &hostbuf[sizeof hostbuf]);
1265                         DNS_ASSERT(hap < &h_addr_ptrs[MAXADDRS-1]);
1266 #ifdef FILTER_V4MAPPED
1267                         if (type == T_AAAA) {
1268                                 struct in6_addr in6;
1269                                 memcpy(&in6, cp, sizeof(in6));
1270                                 DNS_ASSERT(IN6_IS_ADDR_V4MAPPED(&in6) == 0);
1271                         }
1272 #endif
1273                         bcopy(cp, *hap++ = bp, n);
1274                         bp += n;
1275                         buflen -= n;
1276                         cp += n;
1277                         if (cp != erdata) {
1278                                 *errp = NO_RECOVERY;
1279                                 return (NULL);
1280                         }
1281                         break;
1282                 default:
1283                         abort();
1284                 }
1285                 if (!had_error)
1286                         haveanswer++;
1287         }
1288         if (haveanswer) {
1289                 *ap = NULL;
1290                 *hap = NULL;
1291                 if (!template->h_name) {
1292                         n = strlen(qname) + 1;  /* for the \0 */
1293                         if (n > buflen || n >= MAXHOSTNAMELEN)
1294                                 goto no_recovery;
1295                         strcpy(bp, qname);
1296                         template->h_name = bp;
1297                         bp += n;
1298                         buflen -= n;
1299                 }
1300                 *errp = NETDB_SUCCESS;
1301                 return (template);
1302         }
1303  no_recovery:
1304         *errp = NO_RECOVERY;
1305         return (NULL);
1306
1307 #undef BOUNDED_INCR
1308 #undef BOUNDS_CHECK
1309 #undef DNS_ASSERT
1310 #undef DNS_FATAL
1311 }
1312
1313 /* res_search() variant with multiple query support. */
1314 static struct hostent *
1315 _res_search_multi(name, rtl, errp)
1316         const char *name;       /* domain name */
1317         struct  __res_type_list *rtl; /* list of query types */
1318         int *errp;
1319 {
1320         const char *cp, * const *domain;
1321         struct hostent *hp0 = NULL, *hp;
1322         struct hostent hpbuf;
1323         u_int dots;
1324         int trailing_dot, ret, saved_herrno;
1325         int got_nodata = 0, got_servfail = 0, tried_as_is = 0;
1326         struct __res_type_list *rtl0 = rtl;
1327         querybuf *buf;
1328
1329         if ((_res.options & RES_INIT) == 0 && res_init() == -1) {
1330                 *errp = NETDB_INTERNAL;
1331                 return (NULL);
1332         }
1333         dots = 0;
1334         for (cp = name; *cp; cp++)
1335                 dots += (*cp == '.');
1336         trailing_dot = 0;
1337         if (cp > name && *--cp == '.')
1338                 trailing_dot++;
1339
1340         buf = malloc(sizeof(*buf));
1341         if (buf == NULL) {
1342                 *errp = NETDB_INTERNAL;
1343                 return NULL;
1344         }
1345
1346         /* If there aren't any dots, it could be a user-level alias */
1347         if (!dots && (cp = hostalias(name)) != NULL) {
1348                 for(rtl = rtl0; rtl != NULL;
1349                     rtl = SLIST_NEXT(rtl, rtl_entry)) {
1350                         ret = res_query(cp, C_IN, rtl->rtl_type, buf->buf,
1351                                              sizeof(buf->buf));
1352                         if (ret > 0 && ret < sizeof(buf->buf)) {
1353                                 hpbuf.h_addrtype = (rtl->rtl_type == T_AAAA)
1354                                     ? AF_INET6 : AF_INET;
1355                                 hpbuf.h_length = ADDRLEN(hpbuf.h_addrtype);
1356                                 hp = getanswer(buf, ret, name, rtl->rtl_type,
1357                                                     &hpbuf, errp);
1358                                 if (!hp)
1359                                         continue;
1360                                 hp = _hpcopy(&hpbuf, errp);
1361                                 hp0 = _hpmerge(hp0, hp, errp);
1362                         }
1363                 }
1364                 free(buf);
1365                 return (hp0);
1366         }
1367
1368         /*
1369          * If there are dots in the name already, let's just give it a try
1370          * 'as is'.  The threshold can be set with the "ndots" option.
1371          */
1372         saved_herrno = -1;
1373         if (dots >= _res.ndots) {
1374                 for(rtl = rtl0; rtl != NULL;
1375                     rtl = SLIST_NEXT(rtl, rtl_entry)) {
1376                         ret = res_querydomain(name, NULL, C_IN, rtl->rtl_type,
1377                                               buf->buf, sizeof(buf->buf));
1378                         if (ret > 0 && ret < sizeof(buf->buf)) {
1379                                 hpbuf.h_addrtype = (rtl->rtl_type == T_AAAA)
1380                                     ? AF_INET6 : AF_INET;
1381                                 hpbuf.h_length = ADDRLEN(hpbuf.h_addrtype);
1382                                 hp = getanswer(buf, ret, name, rtl->rtl_type,
1383                                                     &hpbuf, errp);
1384                                 if (!hp)
1385                                         continue;
1386                                 hp = _hpcopy(&hpbuf, errp);
1387                                 hp0 = _hpmerge(hp0, hp, errp);
1388                         }
1389                 }
1390                 if (hp0 != NULL) {
1391                         free(buf);
1392                         return (hp0);
1393                 }
1394                 saved_herrno = *errp;
1395                 tried_as_is++;
1396         }
1397
1398         /*
1399          * We do at least one level of search if
1400          *      - there is no dot and RES_DEFNAME is set, or
1401          *      - there is at least one dot, there is no trailing dot,
1402          *        and RES_DNSRCH is set.
1403          */
1404         if ((!dots && (_res.options & RES_DEFNAMES)) ||
1405             (dots && !trailing_dot && (_res.options & RES_DNSRCH))) {
1406                 int done = 0;
1407
1408                 for (domain = (const char * const *)_res.dnsrch;
1409                      *domain && !done;
1410                      domain++) {
1411
1412                         for(rtl = rtl0; rtl != NULL;
1413                             rtl = SLIST_NEXT(rtl, rtl_entry)) {
1414                                 ret = res_querydomain(name, *domain, C_IN,
1415                                                       rtl->rtl_type,
1416                                                       buf->buf, sizeof(buf->buf));
1417                                 if (ret > 0 && ret < sizeof(buf->buf)) {
1418                                         hpbuf.h_addrtype = (rtl->rtl_type == T_AAAA)
1419                                             ? AF_INET6 : AF_INET;
1420                                         hpbuf.h_length = ADDRLEN(hpbuf.h_addrtype);
1421                                         hp = getanswer(buf, ret, name,
1422                                             rtl->rtl_type, &hpbuf, errp);
1423                                         if (!hp)
1424                                                 continue;
1425                                         hp = _hpcopy(&hpbuf, errp);
1426                                         hp0 = _hpmerge(hp0, hp, errp);
1427                                 }
1428                         }
1429                         if (hp0 != NULL) {
1430                                 free(buf);
1431                                 return (hp0);
1432                         }
1433
1434                         /*
1435                          * If no server present, give up.
1436                          * If name isn't found in this domain,
1437                          * keep trying higher domains in the search list
1438                          * (if that's enabled).
1439                          * On a NO_DATA error, keep trying, otherwise
1440                          * a wildcard entry of another type could keep us
1441                          * from finding this entry higher in the domain.
1442                          * If we get some other error (negative answer or
1443                          * server failure), then stop searching up,
1444                          * but try the input name below in case it's
1445                          * fully-qualified.
1446                          */
1447                         if (errno == ECONNREFUSED) {
1448                                 free(buf);
1449                                 *errp = TRY_AGAIN;
1450                                 return (NULL);
1451                         }
1452
1453                         switch (*errp) {
1454                         case NO_DATA:
1455                                 got_nodata++;
1456                                 /* FALLTHROUGH */
1457                         case HOST_NOT_FOUND:
1458                                 /* keep trying */
1459                                 break;
1460                         case TRY_AGAIN:
1461                                 if (buf->hdr.rcode == SERVFAIL) {
1462                                         /* try next search element, if any */
1463                                         got_servfail++;
1464                                         break;
1465                                 }
1466                                 /* FALLTHROUGH */
1467                         default:
1468                                 /* anything else implies that we're done */
1469                                 done++;
1470                         }
1471
1472                         /* if we got here for some reason other than DNSRCH,
1473                          * we only wanted one iteration of the loop, so stop.
1474                          */
1475                         if (!(_res.options & RES_DNSRCH))
1476                                 done++;
1477                 }
1478         }
1479
1480         /*
1481          * If we have not already tried the name "as is", do that now.
1482          * note that we do this regardless of how many dots were in the
1483          * name or whether it ends with a dot unless NOTLDQUERY is set.
1484          */
1485         if (!tried_as_is && (dots || !(_res.options & RES_NOTLDQUERY))) {
1486                 for(rtl = rtl0; rtl != NULL;
1487                     rtl = SLIST_NEXT(rtl, rtl_entry)) {
1488                         ret = res_querydomain(name, NULL, C_IN, rtl->rtl_type,
1489                                               buf->buf, sizeof(buf->buf));
1490                         if (ret > 0 && ret < sizeof(buf->buf)) {
1491                                 hpbuf.h_addrtype = (rtl->rtl_type == T_AAAA)
1492                                     ? AF_INET6 : AF_INET;
1493                                 hpbuf.h_length = ADDRLEN(hpbuf.h_addrtype);
1494                                 hp = getanswer(buf, ret, name, rtl->rtl_type,
1495                                     &hpbuf, errp);
1496                                 if (!hp)
1497                                         continue;
1498                                 hp = _hpcopy(&hpbuf, errp);
1499                                 hp0 = _hpmerge(hp0, hp, errp);
1500                         }
1501                 }
1502                 if (hp0 != NULL) {
1503                         free(buf);
1504                         return (hp0);
1505                 }
1506         }
1507
1508         free(buf);
1509
1510         /* if we got here, we didn't satisfy the search.
1511          * if we did an initial full query, return that query's h_errno
1512          * (note that we wouldn't be here if that query had succeeded).
1513          * else if we ever got a nodata, send that back as the reason.
1514          * else send back meaningless h_errno, that being the one from
1515          * the last DNSRCH we did.
1516          */
1517         if (saved_herrno != -1)
1518                 *errp = saved_herrno;
1519         else if (got_nodata)
1520                 *errp = NO_DATA;
1521         else if (got_servfail)
1522                 *errp = TRY_AGAIN;
1523         return (NULL);
1524 }
1525
1526 static struct hostent *
1527 _dns_ghbyname(const char *name, int af, int *errp)
1528 {
1529         struct __res_type_list *rtl, rtl4;
1530 #ifdef INET6
1531         struct __res_type_list rtl6;
1532 #endif
1533
1534 #ifdef INET6
1535         switch (af) {
1536         case AF_UNSPEC:
1537                 SLIST_NEXT(&rtl4, rtl_entry) = NULL; rtl4.rtl_type = T_A;
1538                 SLIST_NEXT(&rtl6, rtl_entry) = &rtl4; rtl6.rtl_type = T_AAAA;
1539                 rtl = &rtl6;
1540                 break;
1541         case AF_INET6:
1542                 SLIST_NEXT(&rtl6, rtl_entry) = NULL; rtl6.rtl_type = T_AAAA;
1543                 rtl = &rtl6;
1544                 break;
1545         case AF_INET:
1546                 SLIST_NEXT(&rtl4, rtl_entry) = NULL; rtl4.rtl_type = T_A;
1547                 rtl = &rtl4;
1548                 break;
1549         }
1550 #else
1551         SLIST_NEXT(&rtl4, rtl_entry) = NULL; rtl4.rtl_type = T_A;
1552         rtl = &rtl4;
1553 #endif
1554         return(_res_search_multi(name, rtl, errp));
1555 }
1556
1557 static struct hostent *
1558 _dns_ghbyaddr(const void *addr, int addrlen, int af, int *errp)
1559 {
1560         int n;
1561         struct hostent *hp;
1562         u_char c, *cp;
1563         char *bp;
1564         struct hostent hbuf;
1565         int na;
1566 #ifdef INET6
1567         static const char hex[] = "0123456789abcdef";
1568 #endif
1569         querybuf *buf;
1570         char qbuf[MAXDNAME+1];
1571         char *hlist[2];
1572         char *tld6[] = { "ip6.arpa", "ip6.int", NULL };
1573         char *tld4[] = { "in-addr.arpa", NULL };
1574         char **tld;
1575
1576 #ifdef INET6
1577         /* XXX */
1578         if (af == AF_INET6 && IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)addr))
1579                 return NULL;
1580 #endif
1581
1582         switch (af) {
1583 #ifdef INET6
1584         case AF_INET6:
1585                 tld = tld6;
1586                 break;
1587 #endif
1588         case AF_INET:
1589                 tld = tld4;
1590                 break;
1591         default:
1592                 return NULL;
1593         }
1594
1595         if ((_res.options & RES_INIT) == 0) {
1596                 if (res_init() < 0) {
1597                         *errp = h_errno;
1598                         return NULL;
1599                 }
1600         }
1601         memset(&hbuf, 0, sizeof(hbuf));
1602         hbuf.h_name = NULL;
1603         hbuf.h_addrtype = af;
1604         hbuf.h_length = addrlen;
1605         na = 0;
1606
1607         buf = malloc(sizeof(*buf));
1608         if (buf == NULL) {
1609                 *errp = NETDB_INTERNAL;
1610                 return NULL;
1611         }
1612         for (/* nothing */; *tld; tld++) {
1613                 /*
1614                  * XXX assumes that MAXDNAME is big enough - error checks
1615                  * has been made by callers
1616                  */
1617                 n = 0;
1618                 bp = qbuf;
1619                 cp = (u_char *)addr+addrlen-1;
1620                 switch (af) {
1621 #ifdef INET6
1622                 case AF_INET6:
1623                         for (; n < addrlen; n++, cp--) {
1624                                 c = *cp;
1625                                 *bp++ = hex[c & 0xf];
1626                                 *bp++ = '.';
1627                                 *bp++ = hex[c >> 4];
1628                                 *bp++ = '.';
1629                         }
1630                         strcpy(bp, *tld);
1631                         break;
1632 #endif
1633                 case AF_INET:
1634                         for (; n < addrlen; n++, cp--) {
1635                                 c = *cp;
1636                                 if (c >= 100)
1637                                         *bp++ = '0' + c / 100;
1638                                 if (c >= 10)
1639                                         *bp++ = '0' + (c % 100) / 10;
1640                                 *bp++ = '0' + c % 10;
1641                                 *bp++ = '.';
1642                         }
1643                         strcpy(bp, *tld);
1644                         break;
1645                 }
1646
1647                 n = res_query(qbuf, C_IN, T_PTR, buf->buf, sizeof buf->buf);
1648                 if (n < 0) {
1649                         *errp = h_errno;
1650                         continue;
1651                 } else if (n > sizeof(buf->buf)) {
1652                         *errp = NETDB_INTERNAL;
1653 #if 0
1654                         errno = ERANGE; /* XXX is it OK to set errno here? */
1655 #endif
1656                         continue;
1657                 }
1658                 hp = getanswer(buf, n, qbuf, T_PTR, &hbuf, errp);
1659                 if (!hp)
1660                         continue;
1661                 free(buf);
1662                 hbuf.h_addrtype = af;
1663                 hbuf.h_length = addrlen;
1664                 hbuf.h_addr_list = hlist;
1665                 hlist[0] = (char *)addr;
1666                 hlist[1] = NULL;
1667                 return _hpcopy(&hbuf, errp);
1668         }
1669         free(buf);
1670         return NULL;
1671 }
1672
1673 static void
1674 _dns_shent(int stayopen)
1675 {
1676         if ((_res.options & RES_INIT) == 0) {
1677                 if (res_init() < 0)
1678                         return;
1679         }
1680         if (stayopen)
1681                 _res.options |= RES_STAYOPEN | RES_USEVC;
1682 }
1683
1684 static void
1685 _dns_ehent(void)
1686 {
1687         _res.options &= ~(RES_STAYOPEN | RES_USEVC);
1688         res_close();
1689 }
1690
1691 #ifdef ICMPNL
1692
1693 /*
1694  * experimental:
1695  *      draft-ietf-ipngwg-icmp-namelookups-02.txt
1696  *      ifindex is assumed to be encoded in addr.
1697  */
1698 #include <sys/uio.h>
1699 #include <netinet/ip6.h>
1700 #include <netinet/icmp6.h>
1701
1702 struct _icmp_host_cache {
1703         struct _icmp_host_cache *hc_next;
1704         int hc_ifindex;
1705         struct in6_addr hc_addr;
1706         char *hc_name;
1707 };
1708
1709 static char *
1710 _icmp_fqdn_query(const struct in6_addr *addr, int ifindex)
1711 {
1712         int s;
1713         struct icmp6_filter filter;
1714         struct msghdr msg;
1715         struct cmsghdr *cmsg;
1716         struct in6_pktinfo *pkt;
1717         char cbuf[256];
1718         char buf[1024];
1719         int cc;
1720         struct icmp6_fqdn_query *fq;
1721         struct icmp6_fqdn_reply *fr;
1722         struct _icmp_host_cache *hc;
1723         struct sockaddr_in6 sin6;
1724         struct iovec iov;
1725         fd_set s_fds, fds;
1726         struct timeval tout;
1727         int len;
1728         char *name;
1729         static int pid;
1730         static struct _icmp_host_cache *hc_head;
1731
1732         for (hc = hc_head; hc; hc = hc->hc_next) {
1733                 if (hc->hc_ifindex == ifindex
1734                 &&  IN6_ARE_ADDR_EQUAL(&hc->hc_addr, addr))
1735                         return hc->hc_name;
1736         }
1737
1738         if (pid == 0)
1739                 pid = getpid();
1740
1741         ICMP6_FILTER_SETBLOCKALL(&filter);
1742         ICMP6_FILTER_SETPASS(ICMP6_FQDN_REPLY, &filter);
1743
1744         FD_ZERO(&s_fds);
1745         tout.tv_sec = 0;
1746         tout.tv_usec = 200000;  /*XXX: 200ms*/
1747
1748         fq = (struct icmp6_fqdn_query *)buf;
1749         fq->icmp6_fqdn_type = ICMP6_FQDN_QUERY;
1750         fq->icmp6_fqdn_code = 0;
1751         fq->icmp6_fqdn_cksum = 0;
1752         fq->icmp6_fqdn_id = (u_short)pid;
1753         fq->icmp6_fqdn_unused = 0;
1754         fq->icmp6_fqdn_cookie[0] = 0;
1755         fq->icmp6_fqdn_cookie[1] = 0;
1756
1757         memset(&sin6, 0, sizeof(sin6));
1758         sin6.sin6_family = AF_INET6;
1759         sin6.sin6_addr = *addr;
1760
1761         memset(&msg, 0, sizeof(msg));
1762         msg.msg_name = (caddr_t)&sin6;
1763         msg.msg_namelen = sizeof(sin6);
1764         msg.msg_iov = &iov;
1765         msg.msg_iovlen = 1;
1766         msg.msg_control = NULL;
1767         msg.msg_controllen = 0;
1768         iov.iov_base = (caddr_t)buf;
1769         iov.iov_len = sizeof(struct icmp6_fqdn_query);
1770
1771         if (ifindex) {
1772                 msg.msg_control = cbuf;
1773                 msg.msg_controllen = sizeof(cbuf);
1774                 cmsg = CMSG_FIRSTHDR(&msg);
1775                 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo));
1776                 cmsg->cmsg_level = IPPROTO_IPV6;
1777                 cmsg->cmsg_type = IPV6_PKTINFO;
1778                 pkt = (struct in6_pktinfo *)&cmsg[1];
1779                 memset(&pkt->ipi6_addr, 0, sizeof(struct in6_addr));
1780                 pkt->ipi6_ifindex = ifindex;
1781                 cmsg = CMSG_NXTHDR(&msg, cmsg);
1782                 msg.msg_controllen = (char *)cmsg - cbuf;
1783         }
1784
1785         if ((s = socket(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6)) < 0)
1786                 return NULL;
1787         (void)setsockopt(s, IPPROTO_ICMPV6, ICMP6_FILTER,
1788                          (char *)&filter, sizeof(filter));
1789         cc = sendmsg(s, &msg, 0);
1790         if (cc < 0) {
1791                 _close(s);
1792                 return NULL;
1793         }
1794         FD_SET(s, &s_fds);
1795         for (;;) {
1796                 fds = s_fds;
1797                 if (select(s + 1, &fds, NULL, NULL, &tout) <= 0) {
1798                         _close(s);
1799                         return NULL;
1800                 }
1801                 len = sizeof(sin6);
1802                 cc = recvfrom(s, buf, sizeof(buf), 0,
1803                               (struct sockaddr *)&sin6, &len);
1804                 if (cc <= 0) {
1805                         _close(s);
1806                         return NULL;
1807                 }
1808                 if (cc < sizeof(struct ip6_hdr) + sizeof(struct icmp6_hdr))
1809                         continue;
1810                 if (!IN6_ARE_ADDR_EQUAL(addr, &sin6.sin6_addr))
1811                         continue;
1812                 fr = (struct icmp6_fqdn_reply *)(buf + sizeof(struct ip6_hdr));
1813                 if (fr->icmp6_fqdn_type == ICMP6_FQDN_REPLY)
1814                         break;
1815         }
1816         _close(s);
1817         if (fr->icmp6_fqdn_cookie[1] != 0) {
1818                 /* rfc1788 type */
1819                 name = buf + sizeof(struct ip6_hdr) + sizeof(struct icmp6_hdr) + 4;
1820                 len = (buf + cc) - name;
1821         } else {
1822                 len = fr->icmp6_fqdn_namelen;
1823                 name = fr->icmp6_fqdn_name;
1824         }
1825         if (len <= 0)
1826                 return NULL;
1827         name[len] = 0;
1828
1829         if ((hc = (struct _icmp_host_cache *)malloc(sizeof(*hc))) == NULL)
1830                 return NULL;
1831         /* XXX: limit number of cached entries */
1832         hc->hc_ifindex = ifindex;
1833         hc->hc_addr = *addr;
1834         hc->hc_name = strdup(name);
1835         hc->hc_next = hc_head;
1836         hc_head = hc;
1837         return hc->hc_name;
1838 }
1839
1840 static struct hostent *
1841 _icmp_ghbyaddr(const void *addr, int addrlen, int af, int *errp)
1842 {
1843         char *hname;
1844         int ifindex;
1845         struct in6_addr addr6;
1846
1847         if (af != AF_INET6) {
1848                 /*
1849                  * Note: rfc1788 defines Who Are You for IPv4,
1850                  * but no one implements it.
1851                  */
1852                 return NULL;
1853         }
1854
1855         memcpy(&addr6, addr, addrlen);
1856         ifindex = (addr6.s6_addr[2] << 8) | addr6.s6_addr[3];
1857         addr6.s6_addr[2] = addr6.s6_addr[3] = 0;
1858
1859         if (!IN6_IS_ADDR_LINKLOCAL(&addr6))
1860                 return NULL;    /*XXX*/
1861
1862         if ((hname = _icmp_fqdn_query(&addr6, ifindex)) == NULL)
1863                 return NULL;
1864         return _hpaddr(af, hname, &addr6, errp);
1865 }
1866 #endif /* ICMPNL */