lib/libc/net/gethnamaddr.c

   1 /*      $NetBSD: gethnamaddr.c,v 1.92 2015/09/22 16:16:02 christos Exp $        */
   2
   3 /*
   4  * ++Copyright++ 1985, 1988, 1993
   5  * -
   6  * Copyright (c) 1985, 1988, 1993
   7  *    The Regents of the University of California.  All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  * -
  33  * Portions Copyright (c) 1993 by Digital Equipment Corporation.
  34  *
  35  * Permission to use, copy, modify, and distribute this software for any
  36  * purpose with or without fee is hereby granted, provided that the above
  37  * copyright notice and this permission notice appear in all copies, and that
  38  * the name of Digital Equipment Corporation not be used in advertising or
  39  * publicity pertaining to distribution of the document or software without
  40  * specific, written prior permission.
  41  *
  42  * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
  43  * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
  44  * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
  45  * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  46  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  47  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  48  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  49  * SOFTWARE.
  50  * -
  51  * --Copyright--
  52  */
  53
  54 #include <sys/cdefs.h>
  55 #if defined(LIBC_SCCS) && !defined(lint)
  56 #if 0
  57 static char sccsid[] = "@(#)gethostnamadr.c     8.1 (Berkeley) 6/4/93";
  58 static char rcsid[] = "Id: gethnamaddr.c,v 8.21 1997/06/01 20:34:37 vixie Exp ";
  59 #else
  60 __RCSID("$NetBSD: gethnamaddr.c,v 1.92 2015/09/22 16:16:02 christos Exp $");
  61 #endif
  62 #endif /* LIBC_SCCS and not lint */
  63
  64 #if defined(_LIBC)
  65 #include "namespace.h"
  66 #endif
  67 #include <sys/param.h>
  68 #include <sys/socket.h>
  69 #include <netinet/in.h>
  70 #include <arpa/inet.h>
  71 #include <arpa/nameser.h>
  72
  73 #include <assert.h>
  74 #include <ctype.h>
  75 #include <errno.h>
  76 #include <netdb.h>
  77 #include <resolv.h>
  78 #include <stdarg.h>
  79 #include <stdio.h>
  80 #include <syslog.h>
  81
  82 #ifndef LOG_AUTH
  83 # define LOG_AUTH 0
  84 #endif
  85
  86 #define MULTI_PTRS_ARE_ALIASES 1        /* XXX - experimental */
  87
  88 #include <nsswitch.h>
  89 #include <stdlib.h>
  90 #include <string.h>
  91
  92 #ifdef YP
  93 #include <rpc/rpc.h>
  94 #include <rpcsvc/yp_prot.h>
  95 #include <rpcsvc/ypclnt.h>
  96 #endif
  97
  98 #include "hostent.h"
  99
 100 #if defined(_LIBC) && defined(__weak_alias)
 101 __weak_alias(gethostbyaddr,_gethostbyaddr)
 102 __weak_alias(gethostbyname,_gethostbyname)
 103 __weak_alias(gethostent,_gethostent)
 104 #endif
 105
 106 #define maybe_ok(res, nm, ok) (((res)->options & RES_NOCHECKNAME) != 0U || \
 107                                (ok)(nm) != 0)
 108 #define maybe_hnok(res, hn) maybe_ok((res), (hn), res_hnok)
 109 #define maybe_dnok(res, dn) maybe_ok((res), (dn), res_dnok)
 110
 111 #define addalias(d, s, arr, siz) do {                   \
 112         if (d >= &arr[siz]) {                           \
 113                 char **xptr = realloc(arr, (siz + 10) * sizeof(*arr)); \
 114                 if (xptr == NULL)                       \
 115                         goto nospc;                     \
 116                 d = xptr + (d - arr);                   \
 117                 arr = xptr;                             \
 118                 siz += 10;                              \
 119         }                                               \
 120         *d++ = s;                                       \
 121 } while (/*CONSTCOND*/0)
 122
 123 #define setup(arr, siz) do {                            \
 124         arr = malloc((siz = 10) * sizeof(*arr));        \
 125         if (arr == NULL)                                \
 126                 goto nospc;                             \
 127 } while (/*CONSTCOND*/0)
 128
 129
 130 static const char AskedForGot[] =
 131     "gethostby*.getanswer: asked for \"%s\", got \"%s\"";
 132
 133
 134 #ifdef YP
 135 static char *__ypdomain;
 136 #endif
 137
 138 #define MAXPACKET       (64*1024)
 139
 140 typedef union {
 141         HEADER hdr;
 142         u_char buf[MAXPACKET];
 143 } querybuf;
 144
 145 typedef union {
 146         int32_t al;
 147         char ac;
 148 } align;
 149
 150 #ifdef DEBUG
 151 static void debugprintf(const char *, res_state, ...)
 152         __attribute__((__format__(__printf__, 1, 3)));
 153 #endif
 154 static struct hostent *getanswer(const querybuf *, int, const char *, int,
 155     res_state, struct hostent *, char *, size_t, int *);
 156 static void map_v4v6_address(const char *, char *);
 157 static void map_v4v6_hostent(struct hostent *, char **, char *);
 158 static void addrsort(char **, int, res_state);
 159
 160 void dns_service(void);
 161 #undef dn_skipname
 162 int dn_skipname(const u_char *, const u_char *);
 163
 164 #ifdef YP
 165 static struct hostent *_yp_hostent(char *, int, struct getnamaddr *);
 166 #endif
 167
 168 static struct hostent *gethostbyname_internal(const char *, int, res_state,
 169     struct hostent *, char *, size_t, int *);
 170
 171 static const ns_src default_dns_files[] = {
 172         { NSSRC_FILES,  NS_SUCCESS },
 173         { NSSRC_DNS,    NS_SUCCESS },
 174         { 0, 0 }
 175 };
 176
 177
 178 #ifdef DEBUG
 179 static void
 180 debugprintf(const char *msg, res_state res, ...)
 181 {
 182         _DIAGASSERT(msg != NULL);
 183
 184         if (res->options & RES_DEBUG) {
 185                 int save = errno;
 186                 va_list ap;
 187
 188                 va_start (ap, res);
 189                 vprintf(msg, ap);
 190                 va_end (ap);
 191
 192                 errno = save;
 193         }
 194 }
 195 #else
 196 # define debugprintf(msg, res, num) /*nada*/
 197 #endif
 198
 199 #define BOUNDED_INCR(x) \
 200         do { \
 201                 cp += (x); \
 202                 if (cp > eom) \
 203                         goto no_recovery; \
 204         } while (/*CONSTCOND*/0)
 205
 206 #define BOUNDS_CHECK(ptr, count) \
 207         do { \
 208                 if ((ptr) + (count) > eom) \
 209                         goto no_recovery; \
 210         } while (/*CONSTCOND*/0)
 211
 212 static struct hostent *
 213 getanswer(const querybuf *answer, int anslen, const char *qname, int qtype,
 214     res_state res, struct hostent *hent, char *buf, size_t buflen, int *he)
 215 {
 216         const HEADER *hp;
 217         const u_char *cp;
 218         int n;
 219         size_t qlen;
 220         const u_char *eom, *erdata;
 221         char *bp, **ap, **hap, *ep;
 222         int type, class, ancount, qdcount;
 223         int haveanswer, had_error;
 224         int toobig = 0;
 225         char tbuf[MAXDNAME];
 226         char **aliases;
 227         size_t maxaliases;
 228         char *addr_ptrs[MAXADDRS];
 229         const char *tname;
 230         int (*name_ok)(const char *);
 231
 232         _DIAGASSERT(answer != NULL);
 233         _DIAGASSERT(qname != NULL);
 234
 235         tname = qname;
 236         hent->h_name = NULL;
 237         eom = answer->buf + anslen;
 238         switch (qtype) {
 239         case T_A:
 240         case T_AAAA:
 241                 name_ok = res_hnok;
 242                 break;
 243         case T_PTR:
 244                 name_ok = res_dnok;
 245                 break;
 246         default:
 247                 *he = NO_RECOVERY;
 248                 return NULL;    /* XXX should be abort(); */
 249         }
 250
 251         setup(aliases, maxaliases);
 252         /*
 253          * find first satisfactory answer
 254          */
 255         hp = &answer->hdr;
 256         ancount = ntohs(hp->ancount);
 257         qdcount = ntohs(hp->qdcount);
 258         bp = buf;
 259         ep = buf + buflen;
 260         cp = answer->buf;
 261         BOUNDED_INCR(HFIXEDSZ);
 262         if (qdcount != 1)
 263                 goto no_recovery;
 264
 265         n = dn_expand(answer->buf, eom, cp, bp, (int)(ep - bp));
 266         if ((n < 0) || !maybe_ok(res, bp, name_ok))
 267                 goto no_recovery;
 268
 269         BOUNDED_INCR(n + QFIXEDSZ);
 270         if (qtype == T_A || qtype == T_AAAA) {
 271                 /* res_send() has already verified that the query name is the
 272                  * same as the one we sent; this just gets the expanded name
 273                  * (i.e., with the succeeding search-domain tacked on).
 274                  */
 275                 n = (int)strlen(bp) + 1;                /* for the \0 */
 276                 if (n >= MAXHOSTNAMELEN)
 277                         goto no_recovery;
 278                 hent->h_name = bp;
 279                 bp += n;
 280                 /* The qname can be abbreviated, but h_name is now absolute. */
 281                 qname = hent->h_name;
 282         }
 283         hent->h_aliases = ap = aliases;
 284         hent->h_addr_list = hap = addr_ptrs;
 285         *ap = NULL;
 286         *hap = NULL;
 287         haveanswer = 0;
 288         had_error = 0;
 289         while (ancount-- > 0 && cp < eom && !had_error) {
 290                 n = dn_expand(answer->buf, eom, cp, bp, (int)(ep - bp));
 291                 if ((n < 0) || !maybe_ok(res, bp, name_ok)) {
 292                         had_error++;
 293                         continue;
 294                 }
 295                 cp += n;                        /* name */
 296                 BOUNDS_CHECK(cp, 3 * INT16SZ + INT32SZ);
 297                 type = _getshort(cp);
 298                 cp += INT16SZ;                  /* type */
 299                 class = _getshort(cp);
 300                 cp += INT16SZ + INT32SZ;        /* class, TTL */
 301                 n = _getshort(cp);
 302                 cp += INT16SZ;                  /* len */
 303                 BOUNDS_CHECK(cp, n);
 304                 erdata = cp + n;
 305                 if (class != C_IN) {
 306                         /* XXX - debug? syslog? */
 307                         cp += n;
 308                         continue;               /* XXX - had_error++ ? */
 309                 }
 310                 if ((qtype == T_A || qtype == T_AAAA) && type == T_CNAME) {
 311                         n = dn_expand(answer->buf, eom, cp, tbuf,
 312                             (int)sizeof tbuf);
 313                         if ((n < 0) || !maybe_ok(res, tbuf, name_ok)) {
 314                                 had_error++;
 315                                 continue;
 316                         }
 317                         cp += n;
 318                         if (cp != erdata)
 319                                 goto no_recovery;
 320                         /* Store alias. */
 321                         addalias(ap, bp, aliases, maxaliases);
 322                         n = (int)strlen(bp) + 1;        /* for the \0 */
 323                         if (n >= MAXHOSTNAMELEN) {
 324                                 had_error++;
 325                                 continue;
 326                         }
 327                         bp += n;
 328                         /* Get canonical name. */
 329                         n = (int)strlen(tbuf) + 1;      /* for the \0 */
 330                         if (n > ep - bp || n >= MAXHOSTNAMELEN) {
 331                                 had_error++;
 332                                 continue;
 333                         }
 334                         strlcpy(bp, tbuf, (size_t)(ep - bp));
 335                         hent->h_name = bp;
 336                         bp += n;
 337                         continue;
 338                 }
 339                 if (qtype == T_PTR && type == T_CNAME) {
 340                         n = dn_expand(answer->buf, eom, cp, tbuf,
 341                             (int)sizeof tbuf);
 342                         if (n < 0 || !maybe_dnok(res, tbuf)) {
 343                                 had_error++;
 344                                 continue;
 345                         }
 346                         cp += n;
 347                         if (cp != erdata)
 348                                 goto no_recovery;
 349                         /* Get canonical name. */
 350                         n = (int)strlen(tbuf) + 1;      /* for the \0 */
 351                         if (n > ep - bp || n >= MAXHOSTNAMELEN) {
 352                                 had_error++;
 353                                 continue;
 354                         }
 355                         strlcpy(bp, tbuf, (size_t)(ep - bp));
 356                         tname = bp;
 357                         bp += n;
 358                         continue;
 359                 }
 360                 if (type != qtype) {
 361                         if (type != T_KEY && type != T_SIG)
 362                                 syslog(LOG_NOTICE|LOG_AUTH,
 363                "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
 364                                        qname, p_class(C_IN), p_type(qtype),
 365                                        p_type(type));
 366                         cp += n;
 367                         continue;               /* XXX - had_error++ ? */
 368                 }
 369                 switch (type) {
 370                 case T_PTR:
 371                         if (strcasecmp(tname, bp) != 0) {
 372                                 syslog(LOG_NOTICE|LOG_AUTH,
 373                                        AskedForGot, qname, bp);
 374                                 cp += n;
 375                                 continue;       /* XXX - had_error++ ? */
 376                         }
 377                         n = dn_expand(answer->buf, eom, cp, bp, (int)(ep - bp));
 378                         if ((n < 0) || !maybe_hnok(res, bp)) {
 379                                 had_error++;
 380                                 break;
 381                         }
 382 #if MULTI_PTRS_ARE_ALIASES
 383                         cp += n;
 384                         if (cp != erdata)
 385                                 goto no_recovery;
 386                         if (!haveanswer)
 387                                 hent->h_name = bp;
 388                         else
 389                                 addalias(ap, bp, aliases, maxaliases);
 390                         if (n != -1) {
 391                                 n = (int)strlen(bp) + 1;        /* for the \0 */
 392                                 if (n >= MAXHOSTNAMELEN) {
 393                                         had_error++;
 394                                         break;
 395                                 }
 396                                 bp += n;
 397                         }
 398                         break;
 399 #else
 400                         hent->h_name = bp;
 401                         if (res->options & RES_USE_INET6) {
 402                                 n = strlen(bp) + 1;     /* for the \0 */
 403                                 if (n >= MAXHOSTNAMELEN) {
 404                                         had_error++;
 405                                         break;
 406                                 }
 407                                 bp += n;
 408                                 map_v4v6_hostent(hent, &bp, ep);
 409                         }
 410                         goto success;
 411 #endif
 412                 case T_A:
 413                 case T_AAAA:
 414                         if (strcasecmp(hent->h_name, bp) != 0) {
 415                                 syslog(LOG_NOTICE|LOG_AUTH,
 416                                        AskedForGot, hent->h_name, bp);
 417                                 cp += n;
 418                                 continue;       /* XXX - had_error++ ? */
 419                         }
 420                         if (n != hent->h_length) {
 421                                 cp += n;
 422                                 continue;
 423                         }
 424                         if (type == T_AAAA) {
 425                                 struct in6_addr in6;
 426                                 memcpy(&in6, cp, NS_IN6ADDRSZ);
 427                                 if (IN6_IS_ADDR_V4MAPPED(&in6)) {
 428                                         cp += n;
 429                                         continue;
 430                                 }
 431                         }
 432                         if (!haveanswer) {
 433                                 int nn;
 434
 435                                 hent->h_name = bp;
 436                                 nn = (int)strlen(bp) + 1;       /* for the \0 */
 437                                 bp += nn;
 438                         }
 439
 440                         bp += sizeof(align) -
 441                             (size_t)((u_long)bp % sizeof(align));
 442
 443                         if (bp + n >= ep) {
 444                                 debugprintf("size (%d) too big\n", res, n);
 445                                 had_error++;
 446                                 continue;
 447                         }
 448                         if (hap >= &addr_ptrs[MAXADDRS - 1]) {
 449                                 if (!toobig++) {
 450                                         debugprintf("Too many addresses (%d)\n",
 451                                                 res, MAXADDRS);
 452                                 }
 453                                 cp += n;
 454                                 continue;
 455                         }
 456                         (void)memcpy(*hap++ = bp, cp, (size_t)n);
 457                         bp += n;
 458                         cp += n;
 459                         if (cp != erdata)
 460                                 goto no_recovery;
 461                         break;
 462                 default:
 463                         abort();
 464                 }
 465                 if (!had_error)
 466                         haveanswer++;
 467         }
 468         if (haveanswer) {
 469                 *ap = NULL;
 470                 *hap = NULL;
 471                 /*
 472                  * Note: we sort even if host can take only one address
 473                  * in its return structures - should give it the "best"
 474                  * address in that case, not some random one
 475                  */
 476                 if (res->nsort && haveanswer > 1 && qtype == T_A)
 477                         addrsort(addr_ptrs, haveanswer, res);
 478                 if (!hent->h_name) {
 479                         n = (int)strlen(qname) + 1;     /* for the \0 */
 480                         if (n > ep - bp || n >= MAXHOSTNAMELEN)
 481                                 goto no_recovery;
 482                         strlcpy(bp, qname, (size_t)(ep - bp));
 483                         hent->h_name = bp;
 484                         bp += n;
 485                 }
 486                 if (res->options & RES_USE_INET6)
 487                         map_v4v6_hostent(hent, &bp, ep);
 488                 goto success;
 489         }
 490 no_recovery:
 491         free(aliases);
 492         *he = NO_RECOVERY;
 493         return NULL;
 494 success:
 495         bp = (char *)ALIGN(bp);
 496         n = (int)(ap - aliases);
 497         qlen = (n + 1) * sizeof(*hent->h_aliases);
 498         if ((size_t)(ep - bp) < qlen)
 499                 goto nospc;
 500         hent->h_aliases = (void *)bp;
 501         memcpy(bp, aliases, qlen);
 502         free(aliases);
 503         aliases = NULL;
 504
 505         bp += qlen;
 506         n = (int)(hap - addr_ptrs);
 507         qlen = (n + 1) * sizeof(*hent->h_addr_list);
 508         if ((size_t)(ep - bp) < qlen)
 509                 goto nospc;
 510         hent->h_addr_list = (void *)bp;
 511         memcpy(bp, addr_ptrs, qlen);
 512         *he = NETDB_SUCCESS;
 513         return hent;
 514 nospc:
 515         free(aliases);
 516         errno = ENOSPC;
 517         *he = NETDB_INTERNAL;
 518         return NULL;
 519 }
 520
 521 struct hostent *
 522 gethostbyname_r(const char *name, struct hostent *hp, char *buf, size_t buflen,
 523     int *he)
 524 {
 525         res_state res = __res_get_state();
 526
 527         if (res == NULL) {
 528                 *he = NETDB_INTERNAL;
 529                 return NULL;
 530         }
 531
 532         _DIAGASSERT(name != NULL);
 533
 534         if (res->options & RES_USE_INET6) {
 535                 struct hostent *nhp = gethostbyname_internal(name, AF_INET6,
 536                     res, hp, buf, buflen, he);
 537                 if (nhp) {
 538                         __res_put_state(res);
 539                         return nhp;
 540                 }
 541         }
 542         hp = gethostbyname_internal(name, AF_INET, res, hp, buf, buflen, he);
 543         __res_put_state(res);
 544         return hp;
 545 }
 546
 547 struct hostent *
 548 gethostbyname2_r(const char *name, int af, struct hostent *hp, char *buf,
 549     size_t buflen, int *he)
 550 {
 551         res_state res = __res_get_state();
 552
 553         if (res == NULL) {
 554                 *he = NETDB_INTERNAL;
 555                 return NULL;
 556         }
 557         hp = gethostbyname_internal(name, af, res, hp, buf, buflen, he);
 558         __res_put_state(res);
 559         return hp;
 560 }
 561
 562 static struct hostent *
 563 gethostbyname_internal(const char *name, int af, res_state res,
 564     struct hostent *hp, char *buf, size_t buflen, int *he)
 565 {
 566         const char *cp;
 567         struct getnamaddr info;
 568         char hbuf[MAXHOSTNAMELEN];
 569         size_t size;
 570         static const ns_dtab dtab[] = {
 571                 NS_FILES_CB(_hf_gethtbyname, NULL)
 572                 { NSSRC_DNS, _dns_gethtbyname, NULL },  /* force -DHESIOD */
 573                 NS_NIS_CB(_yp_gethtbyname, NULL)
 574                 NS_NULL_CB
 575         };
 576
 577         _DIAGASSERT(name != NULL);
 578
 579         switch (af) {
 580         case AF_INET:
 581                 size = NS_INADDRSZ;
 582                 break;
 583         case AF_INET6:
 584                 size = NS_IN6ADDRSZ;
 585                 break;
 586         default:
 587                 *he = NETDB_INTERNAL;
 588                 errno = EAFNOSUPPORT;
 589                 return NULL;
 590         }
 591         if (buflen < size)
 592                 goto nospc;
 593
 594         hp->h_addrtype = af;
 595         hp->h_length = (int)size;
 596
 597         /*
 598          * if there aren't any dots, it could be a user-level alias.
 599          * this is also done in res_nquery() since we are not the only
 600          * function that looks up host names.
 601          */
 602         if (!strchr(name, '.') && (cp = res_hostalias(res, name,
 603             hbuf, sizeof(hbuf))))
 604                 name = cp;
 605
 606         /*
 607          * disallow names consisting only of digits/dots, unless
 608          * they end in a dot.
 609          */
 610         if (isdigit((u_char) name[0]))
 611                 for (cp = name;; ++cp) {
 612                         if (!*cp) {
 613                                 if (*--cp == '.')
 614                                         break;
 615                                 /*
 616                                  * All-numeric, no dot at the end.
 617                                  * Fake up a hostent as if we'd actually
 618                                  * done a lookup.
 619                                  */
 620                                 goto fake;
 621                         }
 622                         if (!isdigit((u_char) *cp) && *cp != '.')
 623                                 break;
 624                 }
 625         if ((isxdigit((u_char) name[0]) && strchr(name, ':') != NULL) ||
 626             name[0] == ':')
 627                 for (cp = name;; ++cp) {
 628                         if (!*cp) {
 629                                 if (*--cp == '.')
 630                                         break;
 631                                 /*
 632                                  * All-IPv6-legal, no dot at the end.
 633                                  * Fake up a hostent as if we'd actually
 634                                  * done a lookup.
 635                                  */
 636                                 goto fake;
 637                         }
 638                         if (!isxdigit((u_char) *cp) && *cp != ':' && *cp != '.')
 639                                 break;
 640                 }
 641
 642         *he = NETDB_INTERNAL;
 643         info.hp = hp;
 644         info.buf = buf;
 645         info.buflen = buflen;
 646         info.he = he;
 647         if (nsdispatch(&info, dtab, NSDB_HOSTS, "gethostbyname",
 648             default_dns_files, name, strlen(name), af) != NS_SUCCESS)
 649                 return NULL;
 650         *he = NETDB_SUCCESS;
 651         return hp;
 652 nospc:
 653         *he = NETDB_INTERNAL;
 654         errno = ENOSPC;
 655         return NULL;
 656 fake:
 657         HENT_ARRAY(hp->h_addr_list, 1, buf, buflen);
 658         HENT_ARRAY(hp->h_aliases, 0, buf, buflen);
 659
 660         hp->h_aliases[0] = NULL;
 661         if (size > buflen)
 662                 goto nospc;
 663
 664         if (inet_pton(af, name, buf) <= 0) {
 665                 *he = HOST_NOT_FOUND;
 666                 return NULL;
 667         }
 668         hp->h_addr_list[0] = buf;
 669         hp->h_addr_list[1] = NULL;
 670         buf += size;
 671         buflen -= size;
 672         HENT_SCOPY(hp->h_name, name, buf, buflen);
 673         if (res->options & RES_USE_INET6)
 674                 map_v4v6_hostent(hp, &buf, buf + buflen);
 675         *he = NETDB_SUCCESS;
 676         return hp;
 677 }
 678
 679 struct hostent *
 680 gethostbyaddr_r(const void *addr, socklen_t len, int af, struct hostent *hp,
 681     char *buf, size_t buflen, int *he)
 682 {
 683         const u_char *uaddr = (const u_char *)addr;
 684         socklen_t size;
 685         struct getnamaddr info;
 686         static const ns_dtab dtab[] = {
 687                 NS_FILES_CB(_hf_gethtbyaddr, NULL)
 688                 { NSSRC_DNS, _dns_gethtbyaddr, NULL },  /* force -DHESIOD */
 689                 NS_NIS_CB(_yp_gethtbyaddr, NULL)
 690                 NS_NULL_CB
 691         };
 692
 693         _DIAGASSERT(addr != NULL);
 694
 695         if (af == AF_INET6 && len == NS_IN6ADDRSZ &&
 696             (IN6_IS_ADDR_LINKLOCAL((const struct in6_addr *)addr) ||
 697              IN6_IS_ADDR_SITELOCAL((const struct in6_addr *)addr))) {
 698                 *he = HOST_NOT_FOUND;
 699                 return NULL;
 700         }
 701         if (af == AF_INET6 && len == NS_IN6ADDRSZ &&
 702             (IN6_IS_ADDR_V4MAPPED((const struct in6_addr *)addr) ||
 703              IN6_IS_ADDR_V4COMPAT((const struct in6_addr *)addr))) {
 704                 /* Unmap. */
 705                 uaddr += NS_IN6ADDRSZ - NS_INADDRSZ;
 706                 addr = uaddr;
 707                 af = AF_INET;
 708                 len = NS_INADDRSZ;
 709         }
 710         switch (af) {
 711         case AF_INET:
 712                 size = NS_INADDRSZ;
 713                 break;
 714         case AF_INET6:
 715                 size = NS_IN6ADDRSZ;
 716                 break;
 717         default:
 718                 errno = EAFNOSUPPORT;
 719                 *he = NETDB_INTERNAL;
 720                 return NULL;
 721         }
 722         if (size != len) {
 723                 errno = EINVAL;
 724                 *he = NETDB_INTERNAL;
 725                 return NULL;
 726         }
 727         info.hp = hp;
 728         info.buf = buf;
 729         info.buflen = buflen;
 730         info.he = he;
 731         *he = NETDB_INTERNAL;
 732         if (nsdispatch(&info, dtab, NSDB_HOSTS, "gethostbyaddr",
 733             default_dns_files, uaddr, len, af) != NS_SUCCESS)
 734                 return NULL;
 735         *he = NETDB_SUCCESS;
 736         return hp;
 737 }
 738
 739 struct hostent *
 740 gethostent_r(FILE *hf, struct hostent *hent, char *buf, size_t buflen, int *he)
 741 {
 742         char *p, *name;
 743         char *cp, **q;
 744         int af, len;
 745         size_t anum;
 746         char **aliases;
 747         size_t maxaliases;
 748         struct in6_addr host_addr;
 749
 750         if (hf == NULL) {
 751                 *he = NETDB_INTERNAL;
 752                 errno = EINVAL;
 753                 return NULL;
 754         }
 755         p = NULL;
 756         setup(aliases, maxaliases);
 757         for (;;) {
 758                 free(p);
 759                 p = fparseln(hf, NULL, NULL, NULL, FPARSELN_UNESCALL);
 760                 if (p == NULL) {
 761                         free(aliases);
 762                         *he = HOST_NOT_FOUND;
 763                         return NULL;
 764                 }
 765                 if (!(cp = strpbrk(p, " \t")))
 766                         continue;
 767                 *cp++ = '\0';
 768                 if (inet_pton(AF_INET6, p, &host_addr) > 0) {
 769                         af = AF_INET6;
 770                         len = NS_IN6ADDRSZ;
 771                 } else {
 772                         if (inet_pton(AF_INET, p, &host_addr) <= 0)
 773                                 continue;
 774
 775                         res_state res = __res_get_state();
 776                         if (res == NULL)
 777                                 goto nospc;
 778                         if (res->options & RES_USE_INET6) {
 779                                 map_v4v6_address(buf, buf);
 780                                 af = AF_INET6;
 781                                 len = NS_IN6ADDRSZ;
 782                         } else {
 783                                 af = AF_INET;
 784                                 len = NS_INADDRSZ;
 785                         }
 786                         __res_put_state(res);
 787                 }
 788
 789                 /* if this is not something we're looking for, skip it. */
 790                 if (hent->h_addrtype != 0 && hent->h_addrtype != af)
 791                         continue;
 792                 if (hent->h_length != 0 && hent->h_length != len)
 793                         continue;
 794
 795                 while (*cp == ' ' || *cp == '\t')
 796                         cp++;
 797                 if ((cp = strpbrk(name = cp, " \t")) != NULL)
 798                         *cp++ = '\0';
 799                 q = aliases;
 800                 while (cp && *cp) {
 801                         if (*cp == ' ' || *cp == '\t') {
 802                                 cp++;
 803                                 continue;
 804                         }
 805                         addalias(q, cp, aliases, maxaliases);
 806                         if ((cp = strpbrk(cp, " \t")) != NULL)
 807                                 *cp++ = '\0';
 808                 }
 809                 break;
 810         }
 811         hent->h_length = len;
 812         hent->h_addrtype = af;
 813         HENT_ARRAY(hent->h_addr_list, 1, buf, buflen);
 814         anum = (size_t)(q - aliases);
 815         HENT_ARRAY(hent->h_aliases, anum, buf, buflen);
 816         HENT_COPY(hent->h_addr_list[0], &host_addr, hent->h_length, buf,
 817             buflen);
 818         hent->h_addr_list[1] = NULL;
 819
 820         HENT_SCOPY(hent->h_name, name, buf, buflen);
 821         for (size_t i = 0; i < anum; i++)
 822                 HENT_SCOPY(hent->h_aliases[i], aliases[i], buf, buflen);
 823         hent->h_aliases[anum] = NULL;
 824
 825         *he = NETDB_SUCCESS;
 826         free(p);
 827         free(aliases);
 828         return hent;
 829 nospc:
 830         free(p);
 831         free(aliases);
 832         errno = ENOSPC;
 833         *he = NETDB_INTERNAL;
 834         return NULL;
 835 }
 836
 837 static void
 838 map_v4v6_address(const char *src, char *dst)
 839 {
 840         u_char *p = (u_char *)dst;
 841         char tmp[NS_INADDRSZ];
 842         int i;
 843
 844         _DIAGASSERT(src != NULL);
 845         _DIAGASSERT(dst != NULL);
 846
 847         /* Stash a temporary copy so our caller can update in place. */
 848         (void)memcpy(tmp, src, NS_INADDRSZ);
 849         /* Mark this ipv6 addr as a mapped ipv4. */
 850         for (i = 0; i < 10; i++)
 851                 *p++ = 0x00;
 852         *p++ = 0xff;
 853         *p++ = 0xff;
 854         /* Retrieve the saved copy and we're done. */
 855         (void)memcpy(p, tmp, NS_INADDRSZ);
 856 }
 857
 858 static void
 859 map_v4v6_hostent(struct hostent *hp, char **bpp, char *ep)
 860 {
 861         char **ap;
 862
 863         _DIAGASSERT(hp != NULL);
 864         _DIAGASSERT(bpp != NULL);
 865         _DIAGASSERT(ep != NULL);
 866
 867         if (hp->h_addrtype != AF_INET || hp->h_length != NS_INADDRSZ)
 868                 return;
 869         hp->h_addrtype = AF_INET6;
 870         hp->h_length = NS_IN6ADDRSZ;
 871         for (ap = hp->h_addr_list; *ap; ap++) {
 872                 int i = (int)(sizeof(align) -
 873                     (size_t)((u_long)*bpp % sizeof(align)));
 874
 875                 if (ep - *bpp < (i + NS_IN6ADDRSZ)) {
 876                         /* Out of memory.  Truncate address list here.  XXX */
 877                         *ap = NULL;
 878                         return;
 879                 }
 880                 *bpp += i;
 881                 map_v4v6_address(*ap, *bpp);
 882                 *ap = *bpp;
 883                 *bpp += NS_IN6ADDRSZ;
 884         }
 885 }
 886
 887 static void
 888 addrsort(char **ap, int num, res_state res)
 889 {
 890         int i, j;
 891         char **p;
 892         short aval[MAXADDRS];
 893         int needsort = 0;
 894
 895         _DIAGASSERT(ap != NULL);
 896
 897         p = ap;
 898         for (i = 0; i < num; i++, p++) {
 899             for (j = 0 ; (unsigned)j < res->nsort; j++)
 900                 if (res->sort_list[j].addr.s_addr ==
 901                     (((struct in_addr *)(void *)(*p))->s_addr &
 902                     res->sort_list[j].mask))
 903                         break;
 904             aval[i] = j;
 905             if (needsort == 0 && i > 0 && j < aval[i-1])
 906                 needsort = i;
 907         }
 908         if (!needsort)
 909             return;
 910
 911         while (needsort < num) {
 912             for (j = needsort - 1; j >= 0; j--) {
 913                 if (aval[j] > aval[j+1]) {
 914                     char *hp;
 915
 916                     i = aval[j];
 917                     aval[j] = aval[j+1];
 918                     aval[j+1] = i;
 919
 920                     hp = ap[j];
 921                     ap[j] = ap[j+1];
 922                     ap[j+1] = hp;
 923                 } else
 924                     break;
 925             }
 926             needsort++;
 927         }
 928 }
 929
 930
 931 /*ARGSUSED*/
 932 int
 933 _dns_gethtbyname(void *rv, void *cb_data, va_list ap)
 934 {
 935         querybuf *buf;
 936         int n, type;
 937         struct hostent *hp;
 938         const char *name;
 939         res_state res;
 940         struct getnamaddr *info = rv;
 941
 942         _DIAGASSERT(rv != NULL);
 943
 944         name = va_arg(ap, char *);
 945         /* NOSTRICT skip string len */(void)va_arg(ap, int);
 946         info->hp->h_addrtype = va_arg(ap, int);
 947
 948         switch (info->hp->h_addrtype) {
 949         case AF_INET:
 950                 info->hp->h_length = NS_INADDRSZ;
 951                 type = T_A;
 952                 break;
 953         case AF_INET6:
 954                 info->hp->h_length = NS_IN6ADDRSZ;
 955                 type = T_AAAA;
 956                 break;
 957         default:
 958                 return NS_UNAVAIL;
 959         }
 960         buf = malloc(sizeof(*buf));
 961         if (buf == NULL) {
 962                 *info->he = NETDB_INTERNAL;
 963                 return NS_NOTFOUND;
 964         }
 965         res = __res_get_state();
 966         if (res == NULL) {
 967                 free(buf);
 968                 *info->he = NETDB_INTERNAL;
 969                 return NS_NOTFOUND;
 970         }
 971         n = res_nsearch(res, name, C_IN, type, buf->buf, (int)sizeof(buf->buf));
 972         if (n < 0) {
 973                 free(buf);
 974                 debugprintf("res_nsearch failed (%d)\n", res, n);
 975                 __res_put_state(res);
 976                 return NS_NOTFOUND;
 977         }
 978         hp = getanswer(buf, n, name, type, res, info->hp, info->buf,
 979             info->buflen, info->he);
 980         free(buf);
 981         __res_put_state(res);
 982         if (hp == NULL)
 983                 switch (*info->he) {
 984                 case HOST_NOT_FOUND:
 985                         return NS_NOTFOUND;
 986                 case TRY_AGAIN:
 987                         return NS_TRYAGAIN;
 988                 default:
 989                         return NS_UNAVAIL;
 990                 }
 991         return NS_SUCCESS;
 992 }
 993
 994 /*ARGSUSED*/
 995 int
 996 _dns_gethtbyaddr(void *rv, void *cb_data, va_list ap)
 997 {
 998         char qbuf[MAXDNAME + 1], *qp, *ep;
 999         int n;
1000         querybuf *buf;
1001         struct hostent *hp;
1002         const unsigned char *uaddr;
1003         int advance;
1004         res_state res;
1005         char *bf;
1006         size_t blen;
1007         struct getnamaddr *info = rv;
1008
1009         _DIAGASSERT(rv != NULL);
1010
1011         uaddr = va_arg(ap, unsigned char *);
1012         info->hp->h_length = va_arg(ap, int);
1013         info->hp->h_addrtype = va_arg(ap, int);
1014
1015         switch (info->hp->h_addrtype) {
1016         case AF_INET:
1017                 (void)snprintf(qbuf, sizeof(qbuf), "%u.%u.%u.%u.in-addr.arpa",
1018                     (uaddr[3] & 0xff), (uaddr[2] & 0xff),
1019                     (uaddr[1] & 0xff), (uaddr[0] & 0xff));
1020                 break;
1021
1022         case AF_INET6:
1023                 qp = qbuf;
1024                 ep = qbuf + sizeof(qbuf) - 1;
1025                 for (n = NS_IN6ADDRSZ - 1; n >= 0; n--) {
1026                         advance = snprintf(qp, (size_t)(ep - qp), "%x.%x.",
1027                             uaddr[n] & 0xf,
1028                             ((unsigned int)uaddr[n] >> 4) & 0xf);
1029                         if (advance > 0 && qp + advance < ep)
1030                                 qp += advance;
1031                         else
1032                                 goto norecovery;
1033                 }
1034                 if (strlcat(qbuf, "ip6.arpa", sizeof(qbuf)) >= sizeof(qbuf))
1035                         goto norecovery;
1036                 break;
1037         default:
1038                 goto norecovery;
1039         }
1040
1041         buf = malloc(sizeof(*buf));
1042         if (buf == NULL) {
1043                 goto nospc;
1044         }
1045         res = __res_get_state();
1046         if (res == NULL) {
1047                 free(buf);
1048                 goto nospc;
1049         }
1050         n = res_nquery(res, qbuf, C_IN, T_PTR, buf->buf, (int)sizeof(buf->buf));
1051         if (n < 0) {
1052                 free(buf);
1053                 debugprintf("res_nquery failed (%d)\n", res, n);
1054                 __res_put_state(res);
1055                 *info->he = HOST_NOT_FOUND;
1056                 return NS_NOTFOUND;
1057         }
1058         hp = getanswer(buf, n, qbuf, T_PTR, res, info->hp, info->buf,
1059             info->buflen, info->he);
1060         free(buf);
1061         if (hp == NULL) {
1062                 __res_put_state(res);
1063                 switch (*info->he) {
1064                 case HOST_NOT_FOUND:
1065                         return NS_NOTFOUND;
1066                 case TRY_AGAIN:
1067                         return NS_TRYAGAIN;
1068                 default:
1069                         return NS_UNAVAIL;
1070                 }
1071         }
1072
1073         bf = (void *)(hp->h_addr_list + 2);
1074         blen = (size_t)(bf - info->buf);
1075         if (blen + info->hp->h_length > info->buflen)
1076                 goto nospc;
1077         hp->h_addr_list[0] = bf;
1078         hp->h_addr_list[1] = NULL;
1079         (void)memcpy(bf, uaddr, (size_t)info->hp->h_length);
1080         if (info->hp->h_addrtype == AF_INET && (res->options & RES_USE_INET6)) {
1081                 if (blen + NS_IN6ADDRSZ > info->buflen) {
1082                         __res_put_state(res);
1083                         goto nospc;
1084                 }
1085                 map_v4v6_address(bf, bf);
1086                 hp->h_addrtype = AF_INET6;
1087                 hp->h_length = NS_IN6ADDRSZ;
1088         }
1089
1090         __res_put_state(res);
1091         *info->he = NETDB_SUCCESS;
1092         return NS_SUCCESS;
1093 nospc:
1094         *info->he = NETDB_INTERNAL;
1095         return NS_UNAVAIL;
1096 norecovery:
1097         *info->he = NO_RECOVERY;
1098         return NS_UNAVAIL;
1099 }
1100
1101 #ifdef YP
1102 /*ARGSUSED*/
1103 static struct hostent *
1104 _yp_hostent(char *line, int af, struct getnamaddr *info)
1105 {
1106         struct in6_addr host_addrs[MAXADDRS];
1107         char **aliases;
1108         size_t maxaliases;
1109         char *p = line;
1110         char *cp, **q, *ptr;
1111         size_t len, anum, i;
1112         int addrok;
1113         int more;
1114         size_t naddrs;
1115         struct hostent *hp = info->hp;
1116
1117         _DIAGASSERT(line != NULL);
1118
1119         hp->h_name = NULL;
1120         hp->h_addrtype = af;
1121         switch (af) {
1122         case AF_INET:
1123                 hp->h_length = NS_INADDRSZ;
1124                 break;
1125         case AF_INET6:
1126                 hp->h_length = NS_IN6ADDRSZ;
1127                 break;
1128         default:
1129                 return NULL;
1130         }
1131         setup(aliases, maxaliases);
1132         naddrs = 0;
1133         q = aliases;
1134
1135 nextline:
1136         /* check for host_addrs overflow */
1137         if (naddrs >= __arraycount(host_addrs))
1138                 goto done;
1139
1140         more = 0;
1141         cp = strpbrk(p, " \t");
1142         if (cp == NULL)
1143                 goto done;
1144         *cp++ = '\0';
1145
1146         /* p has should have an address */
1147         addrok = inet_pton(af, p, &host_addrs[naddrs]);
1148         if (addrok != 1) {
1149                 /* skip to the next line */
1150                 while (cp && *cp) {
1151                         if (*cp == '\n') {
1152                                 cp++;
1153                                 goto nextline;
1154                         }
1155                         cp++;
1156                 }
1157                 goto done;
1158         }
1159         naddrs++;
1160
1161         while (*cp == ' ' || *cp == '\t')
1162                 cp++;
1163         p = cp;
1164         cp = strpbrk(p, " \t\n");
1165         if (cp != NULL) {
1166                 if (*cp == '\n')
1167                         more = 1;
1168                 *cp++ = '\0';
1169         }
1170         if (!hp->h_name)
1171                 hp->h_name = p;
1172         else if (strcmp(hp->h_name, p) == 0)
1173                 ;
1174         else
1175                 addalias(q, p, aliases, maxaliases);
1176         p = cp;
1177         if (more)
1178                 goto nextline;
1179
1180         while (cp && *cp) {
1181                 if (*cp == ' ' || *cp == '\t') {
1182                         cp++;
1183                         continue;
1184                 }
1185                 if (*cp == '\n') {
1186                         cp++;
1187                         goto nextline;
1188                 }
1189                 addalias(q, cp, aliases, maxaliases);
1190                 cp = strpbrk(cp, " \t");
1191                 if (cp != NULL)
1192                         *cp++ = '\0';
1193         }
1194
1195 done:
1196         if (hp->h_name == NULL) {
1197                 free(aliases);
1198                 return NULL;
1199         }
1200
1201         ptr = info->buf;
1202         len = info->buflen;
1203
1204         anum = (size_t)(q - aliases);
1205         HENT_ARRAY(hp->h_addr_list, naddrs, ptr, len);
1206         HENT_ARRAY(hp->h_aliases, anum, ptr, len);
1207
1208         for (i = 0; i < naddrs; i++)
1209                 HENT_COPY(hp->h_addr_list[i], &host_addrs[i], hp->h_length,
1210                     ptr, len);
1211         hp->h_addr_list[naddrs] = NULL;
1212
1213         HENT_SCOPY(hp->h_name, hp->h_name, ptr, len);
1214
1215         for (i = 0; i < anum; i++)
1216                 HENT_SCOPY(hp->h_aliases[i], aliases[i], ptr, len);
1217         hp->h_aliases[anum] = NULL;
1218         free(aliases);
1219
1220         return hp;
1221 nospc:
1222         free(aliases);
1223         *info->he = NETDB_INTERNAL;
1224         errno = ENOSPC;
1225         return NULL;
1226 }
1227
1228 /*ARGSUSED*/
1229 int
1230 _yp_gethtbyaddr(void *rv, void *cb_data, va_list ap)
1231 {
1232         struct hostent *hp = NULL;
1233         char *ypcurrent;
1234         int ypcurrentlen, r;
1235         char name[INET6_ADDRSTRLEN];    /* XXX enough? */
1236         const unsigned char *uaddr;
1237         int af;
1238         const char *map;
1239         struct getnamaddr *info = rv;
1240
1241         _DIAGASSERT(rv != NULL);
1242
1243         uaddr = va_arg(ap, unsigned char *);
1244         /* NOSTRICT skip len */(void)va_arg(ap, int);
1245         af = va_arg(ap, int);
1246
1247         if (!__ypdomain) {
1248                 if (_yp_check(&__ypdomain) == 0)
1249                         return NS_UNAVAIL;
1250         }
1251         /*
1252          * XXX unfortunately, we cannot support IPv6 extended scoped address
1253          * notation here.  gethostbyaddr() is not scope-aware.  too bad.
1254          */
1255         if (inet_ntop(af, uaddr, name, (socklen_t)sizeof(name)) == NULL)
1256                 return NS_UNAVAIL;
1257         switch (af) {
1258         case AF_INET:
1259                 map = "hosts.byaddr";
1260                 break;
1261         default:
1262                 map = "ipnodes.byaddr";
1263                 break;
1264         }
1265         ypcurrent = NULL;
1266         r = yp_match(__ypdomain, map, name,
1267                 (int)strlen(name), &ypcurrent, &ypcurrentlen);
1268         if (r == 0)
1269                 hp = _yp_hostent(ypcurrent, af, info);
1270         else
1271                 hp = NULL;
1272         free(ypcurrent);
1273         if (hp == NULL) {
1274                 *info->he = HOST_NOT_FOUND;
1275                 return NS_NOTFOUND;
1276         }
1277         return NS_SUCCESS;
1278 }
1279
1280 /*ARGSUSED*/
1281 int
1282 _yp_gethtbyname(void *rv, void *cb_data, va_list ap)
1283 {
1284         struct hostent *hp;
1285         char *ypcurrent;
1286         int ypcurrentlen, r;
1287         const char *name;
1288         int af;
1289         const char *map;
1290         struct getnamaddr *info = rv;
1291
1292         _DIAGASSERT(rv != NULL);
1293
1294         name = va_arg(ap, char *);
1295         /* NOSTRICT skip string len */(void)va_arg(ap, int);
1296         af = va_arg(ap, int);
1297
1298         if (!__ypdomain) {
1299                 if (_yp_check(&__ypdomain) == 0)
1300                         return NS_UNAVAIL;
1301         }
1302         switch (af) {
1303         case AF_INET:
1304                 map = "hosts.byname";
1305                 break;
1306         default:
1307                 map = "ipnodes.byname";
1308                 break;
1309         }
1310         ypcurrent = NULL;
1311         r = yp_match(__ypdomain, map, name,
1312                 (int)strlen(name), &ypcurrent, &ypcurrentlen);
1313         if (r == 0)
1314                 hp = _yp_hostent(ypcurrent, af, info);
1315         else
1316                 hp = NULL;
1317         free(ypcurrent);
1318         if (hp == NULL) {
1319                 *info->he = HOST_NOT_FOUND;
1320                 return NS_NOTFOUND;
1321         }
1322         return NS_SUCCESS;
1323 }
1324 #endif
1325
1326 /*
1327  * Non-reentrant versions.
1328  */
1329 FILE *_h_file;
1330 static struct hostent h_ent;
1331 static char h_buf[16384];
1332
1333 struct hostent *
1334 gethostbyaddr(const void *addr, socklen_t len, int af) {
1335         return gethostbyaddr_r(addr, len, af, &h_ent, h_buf, sizeof(h_buf),
1336             &h_errno);
1337 }
1338
1339 struct hostent *
1340 gethostbyname(const char *name) {
1341         return gethostbyname_r(name, &h_ent, h_buf, sizeof(h_buf), &h_errno);
1342 }
1343
1344 struct hostent *
1345 gethostbyname2(const char *name, int af) {
1346         return gethostbyname2_r(name, af, &h_ent, h_buf, sizeof(h_buf),
1347             &h_errno);
1348 }
1349
1350 struct hostent *
1351 gethostent(void)
1352 {
1353         if (_h_file == NULL) {
1354                 sethostent_r(&_h_file);
1355                 if (_h_file == NULL) {
1356                         h_errno = NETDB_INTERNAL;
1357                         return NULL;
1358                 }
1359         }
1360         memset(&h_ent, 0, sizeof(h_ent));
1361         return gethostent_r(_h_file, &h_ent, h_buf, sizeof(h_buf), &h_errno);
1362 }
1363