lib/libc/net/gethostnamadr.c

   1 /*-
   2  * Copyright (c) 1994, Garrett Wollman
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  */
  25
  26 #include <sys/cdefs.h>
  27 __FBSDID("$FreeBSD$");
  28
  29 #include "namespace.h"
  30 #include "reentrant.h"
  31 #include <sys/param.h>
  32 #include <sys/socket.h>
  33 #include <netinet/in.h>
  34 #include <arpa/inet.h>
  35 #include <netdb.h>
  36 #include <stdio.h>
  37 #include <ctype.h>
  38 #include <errno.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <stdarg.h>
  42 #include <nsswitch.h>
  43 #include <arpa/nameser.h>               /* XXX hack for _res */
  44 #include <resolv.h>                     /* XXX hack for _res */
  45 #include "un-namespace.h"
  46 #include "netdb_private.h"
  47 #ifdef NS_CACHING
  48 #include "nscache.h"
  49 #endif
  50
  51 static int gethostbyname_internal(const char *, int, struct hostent *, char *,
  52     size_t, struct hostent **, int *, res_state);
  53
  54 /* Host lookup order if nsswitch.conf is broken or nonexistent */
  55 static const ns_src default_src[] = {
  56         { NSSRC_FILES, NS_SUCCESS },
  57         { NSSRC_DNS, NS_SUCCESS },
  58         { 0 }
  59 };
  60 #ifdef NS_CACHING
  61 static int host_id_func(char *, size_t *, va_list, void *);
  62 static int host_marshal_func(char *, size_t *, void *, va_list, void *);
  63 static int host_unmarshal_func(char *, size_t, void *, va_list, void *);
  64 #endif
  65
  66 NETDB_THREAD_ALLOC(hostent)
  67 NETDB_THREAD_ALLOC(hostent_data)
  68 NETDB_THREAD_ALLOC(hostdata)
  69
  70 static void
  71 hostent_free(void *ptr)
  72 {
  73         free(ptr);
  74 }
  75
  76 static void
  77 hostent_data_free(void *ptr)
  78 {
  79         struct hostent_data *hed = ptr;
  80
  81         if (hed == NULL)
  82                 return;
  83         hed->stayopen = 0;
  84         _endhosthtent(hed);
  85         free(hed);
  86 }
  87
  88 static void
  89 hostdata_free(void *ptr)
  90 {
  91         free(ptr);
  92 }
  93
  94 int
  95 __copy_hostent(struct hostent *he, struct hostent *hptr, char *buf,
  96     size_t buflen)
  97 {
  98         char *cp;
  99         char **ptr;
 100         int i, n;
 101         int nptr, len;
 102
 103         /* Find out the amount of space required to store the answer. */
 104         nptr = 2; /* NULL ptrs */
 105         len = (char *)ALIGN(buf) - buf;
 106         for (i = 0; he->h_addr_list[i]; i++, nptr++) {
 107                 len += he->h_length;
 108         }
 109         for (i = 0; he->h_aliases[i]; i++, nptr++) {
 110                 len += strlen(he->h_aliases[i]) + 1;
 111         }
 112         len += strlen(he->h_name) + 1;
 113         len += nptr * sizeof(char*);
 114
 115         if (len > buflen) {
 116                 errno = ERANGE;
 117                 return (-1);
 118         }
 119
 120         /* copy address size and type */
 121         hptr->h_addrtype = he->h_addrtype;
 122         n = hptr->h_length = he->h_length;
 123
 124         ptr = (char **)ALIGN(buf);
 125         cp = (char *)ALIGN(buf) + nptr * sizeof(char *);
 126
 127         /* copy address list */
 128         hptr->h_addr_list = ptr;
 129         for (i = 0; he->h_addr_list[i]; i++ , ptr++) {
 130                 memcpy(cp, he->h_addr_list[i], n);
 131                 hptr->h_addr_list[i] = cp;
 132                 cp += n;
 133         }
 134         hptr->h_addr_list[i] = NULL;
 135         ptr++;
 136
 137         /* copy official name */
 138         n = strlen(he->h_name) + 1;
 139         strcpy(cp, he->h_name);
 140         hptr->h_name = cp;
 141         cp += n;
 142
 143         /* copy aliases */
 144         hptr->h_aliases = ptr;
 145         for (i = 0 ; he->h_aliases[i]; i++) {
 146                 n = strlen(he->h_aliases[i]) + 1;
 147                 strcpy(cp, he->h_aliases[i]);
 148                 hptr->h_aliases[i] = cp;
 149                 cp += n;
 150         }
 151         hptr->h_aliases[i] = NULL;
 152
 153         return (0);
 154 }
 155
 156 #ifdef NS_CACHING
 157 static int
 158 host_id_func(char *buffer, size_t *buffer_size, va_list ap, void *cache_mdata)
 159 {
 160         res_state statp;
 161         u_long res_options;
 162
 163         const int op_id = 1;
 164         char *str;
 165         void *addr;
 166         socklen_t len;
 167         int type;
 168
 169         size_t desired_size, size;
 170         enum nss_lookup_type lookup_type;
 171         char *p;
 172         int res = NS_UNAVAIL;
 173
 174         statp = __res_state();
 175         res_options = statp->options & (RES_RECURSE | RES_DEFNAMES |
 176             RES_DNSRCH | RES_NOALIASES | RES_USE_INET6);
 177
 178         lookup_type = (enum nss_lookup_type)cache_mdata;
 179         switch (lookup_type) {
 180         case nss_lt_name:
 181                 str = va_arg(ap, char *);
 182                 type = va_arg(ap, int);
 183
 184                 size = strlen(str);
 185                 desired_size = sizeof(res_options) + sizeof(int) +
 186                     sizeof(enum nss_lookup_type) + sizeof(int) + size + 1;
 187
 188                 if (desired_size > *buffer_size) {
 189                         res = NS_RETURN;
 190                         goto fin;
 191                 }
 192
 193                 p = buffer;
 194
 195                 memcpy(p, &res_options, sizeof(res_options));
 196                 p += sizeof(res_options);
 197
 198                 memcpy(p, &op_id, sizeof(int));
 199                 p += sizeof(int);
 200
 201                 memcpy(p, &lookup_type, sizeof(enum nss_lookup_type));
 202                 p += sizeof(int);
 203
 204                 memcpy(p, &type, sizeof(int));
 205                 p += sizeof(int);
 206
 207                 memcpy(p, str, size + 1);
 208
 209                 res = NS_SUCCESS;
 210                 break;
 211         case nss_lt_id:
 212                 addr = va_arg(ap, void *);
 213                 len = va_arg(ap, socklen_t);
 214                 type = va_arg(ap, int);
 215
 216                 desired_size = sizeof(res_options) + sizeof(int) +
 217                     sizeof(enum nss_lookup_type) + sizeof(int) +
 218                     sizeof(socklen_t) + len;
 219
 220                 if (desired_size > *buffer_size) {
 221                         res = NS_RETURN;
 222                         goto fin;
 223                 }
 224
 225                 p = buffer;
 226                 memcpy(p, &res_options, sizeof(res_options));
 227                 p += sizeof(res_options);
 228
 229                 memcpy(p, &op_id, sizeof(int));
 230                 p += sizeof(int);
 231
 232                 memcpy(p, &lookup_type, sizeof(enum nss_lookup_type));
 233                 p += sizeof(int);
 234
 235                 memcpy(p, &type, sizeof(int));
 236                 p += sizeof(int);
 237
 238                 memcpy(p, &len, sizeof(socklen_t));
 239                 p += sizeof(socklen_t);
 240
 241                 memcpy(p, addr, len);
 242
 243                 res = NS_SUCCESS;
 244                 break;
 245         default:
 246                 /* should be unreachable */
 247                 return (NS_UNAVAIL);
 248         }
 249
 250 fin:
 251         *buffer_size = desired_size;
 252         return (res);
 253 }
 254
 255 static int
 256 host_marshal_func(char *buffer, size_t *buffer_size, void *retval, va_list ap,
 257     void *cache_mdata)
 258 {
 259         char *str;
 260         void *addr;
 261         socklen_t len;
 262         int type;
 263         struct hostent *ht;
 264
 265         struct hostent new_ht;
 266         size_t desired_size, aliases_size, addr_size, size;
 267         char *p, **iter;
 268
 269         switch ((enum nss_lookup_type)cache_mdata) {
 270         case nss_lt_name:
 271                 str = va_arg(ap, char *);
 272                 type = va_arg(ap, int);
 273                 break;
 274         case nss_lt_id:
 275                 addr = va_arg(ap, void *);
 276                 len = va_arg(ap, socklen_t);
 277                 type = va_arg(ap, int);
 278                 break;
 279         default:
 280                 /* should be unreachable */
 281                 return (NS_UNAVAIL);
 282         }
 283         ht = va_arg(ap, struct hostent *);
 284
 285         desired_size = _ALIGNBYTES + sizeof(struct hostent) + sizeof(char *);
 286         if (ht->h_name != NULL)
 287                 desired_size += strlen(ht->h_name) + 1;
 288
 289         if (ht->h_aliases != NULL) {
 290                 aliases_size = 0;
 291                 for (iter = ht->h_aliases; *iter; ++iter) {
 292                         desired_size += strlen(*iter) + 1;
 293                         ++aliases_size;
 294                 }
 295
 296                 desired_size += _ALIGNBYTES +
 297                     (aliases_size + 1) * sizeof(char *);
 298         }
 299
 300         if (ht->h_addr_list != NULL) {
 301                 addr_size = 0;
 302                 for (iter = ht->h_addr_list; *iter; ++iter)
 303                         ++addr_size;
 304
 305                 desired_size += addr_size * _ALIGN(ht->h_length);
 306                 desired_size += _ALIGNBYTES + (addr_size + 1) * sizeof(char *);
 307         }
 308
 309         if (desired_size > *buffer_size) {
 310                 /* this assignment is here for future use */
 311                 *buffer_size = desired_size;
 312                 return (NS_RETURN);
 313         }
 314
 315         memcpy(&new_ht, ht, sizeof(struct hostent));
 316         memset(buffer, 0, desired_size);
 317
 318         *buffer_size = desired_size;
 319         p = buffer + sizeof(struct hostent) + sizeof(char *);
 320         memcpy(buffer + sizeof(struct hostent), &p, sizeof(char *));
 321         p = (char *)_ALIGN(p);
 322
 323         if (new_ht.h_name != NULL) {
 324                 size = strlen(new_ht.h_name);
 325                 memcpy(p, new_ht.h_name, size);
 326                 new_ht.h_name = p;
 327                 p += size + 1;
 328         }
 329
 330         if (new_ht.h_aliases != NULL) {
 331                 p = (char *)_ALIGN(p);
 332                 memcpy(p, new_ht.h_aliases, sizeof(char *) * aliases_size);
 333                 new_ht.h_aliases = (char **)p;
 334                 p += sizeof(char *) * (aliases_size + 1);
 335
 336                 for (iter = new_ht.h_aliases; *iter; ++iter) {
 337                         size = strlen(*iter);
 338                         memcpy(p, *iter, size);
 339                         *iter = p;
 340                         p += size + 1;
 341                 }
 342         }
 343
 344         if (new_ht.h_addr_list != NULL) {
 345                 p = (char *)_ALIGN(p);
 346                 memcpy(p, new_ht.h_addr_list, sizeof(char *) * addr_size);
 347                 new_ht.h_addr_list = (char **)p;
 348                 p += sizeof(char *) * (addr_size + 1);
 349
 350                 size = _ALIGN(new_ht.h_length);
 351                 for (iter = new_ht.h_addr_list; *iter; ++iter) {
 352                         memcpy(p, *iter, size);
 353                         *iter = p;
 354                         p += size + 1;
 355                 }
 356         }
 357         memcpy(buffer, &new_ht, sizeof(struct hostent));
 358         return (NS_SUCCESS);
 359 }
 360
 361 static int
 362 host_unmarshal_func(char *buffer, size_t buffer_size, void *retval, va_list ap,
 363     void *cache_mdata)
 364 {
 365         char *str;
 366         void *addr;
 367         socklen_t len;
 368         int type;
 369         struct hostent *ht;
 370
 371         char *p;
 372         char **iter;
 373         char *orig_buf;
 374         size_t orig_buf_size;
 375
 376         switch ((enum nss_lookup_type)cache_mdata) {
 377         case nss_lt_name:
 378                 str = va_arg(ap, char *);
 379                 type = va_arg(ap, int);
 380                 break;
 381         case nss_lt_id:
 382                 addr = va_arg(ap, void *);
 383                 len = va_arg(ap, socklen_t);
 384                 type = va_arg(ap, int);
 385                 break;
 386         default:
 387                 /* should be unreachable */
 388                 return (NS_UNAVAIL);
 389         }
 390
 391         ht = va_arg(ap, struct hostent *);
 392         orig_buf = va_arg(ap, char *);
 393         orig_buf_size = va_arg(ap, size_t);
 394
 395         if (orig_buf_size <
 396             buffer_size - sizeof(struct hostent) - sizeof(char *)) {
 397                 errno = ERANGE;
 398                 return (NS_RETURN);
 399         }
 400
 401         memcpy(ht, buffer, sizeof(struct hostent));
 402         memcpy(&p, buffer + sizeof(struct hostent), sizeof(char *));
 403
 404         orig_buf = (char *)_ALIGN(orig_buf);
 405         memcpy(orig_buf, buffer + sizeof(struct hostent) + sizeof(char *) +
 406             _ALIGN(p) - (size_t)p,
 407             buffer_size - sizeof(struct hostent) - sizeof(char *) -
 408             _ALIGN(p) + (size_t)p);
 409         p = (char *)_ALIGN(p);
 410
 411         NS_APPLY_OFFSET(ht->h_name, orig_buf, p, char *);
 412         if (ht->h_aliases != NULL) {
 413                 NS_APPLY_OFFSET(ht->h_aliases, orig_buf, p, char **);
 414
 415                 for (iter = ht->h_aliases; *iter; ++iter)
 416                         NS_APPLY_OFFSET(*iter, orig_buf, p, char *);
 417         }
 418
 419         if (ht->h_addr_list != NULL) {
 420                 NS_APPLY_OFFSET(ht->h_addr_list, orig_buf, p, char **);
 421
 422                 for (iter = ht->h_addr_list; *iter; ++iter)
 423                         NS_APPLY_OFFSET(*iter, orig_buf, p, char *);
 424         }
 425
 426         *((struct hostent **)retval) = ht;
 427         return (NS_SUCCESS);
 428 }
 429 #endif /* NS_CACHING */
 430
 431 static int
 432 fakeaddr(const char *name, int af, struct hostent *hp, char *buf,
 433     size_t buflen, res_state statp)
 434 {
 435         struct hostent_data *hed;
 436         struct hostent he;
 437
 438         if ((hed = __hostent_data_init()) == NULL) {
 439                 errno = ENOMEM;
 440                 RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
 441                 return (-1);
 442         }
 443
 444         if ((af != AF_INET ||
 445             inet_aton(name, (struct in_addr *)hed->host_addr) != 1) &&
 446             inet_pton(af, name, hed->host_addr) != 1) {
 447                 RES_SET_H_ERRNO(statp, HOST_NOT_FOUND);
 448                 return (-1);
 449         }
 450         strncpy(hed->hostbuf, name, MAXDNAME);
 451         hed->hostbuf[MAXDNAME] = '\0';
 452         if (af == AF_INET && (statp->options & RES_USE_INET6) != 0U) {
 453                 _map_v4v6_address((char *)hed->host_addr,
 454                     (char *)hed->host_addr);
 455                 af = AF_INET6;
 456         }
 457         he.h_addrtype = af;
 458         switch(af) {
 459         case AF_INET:
 460                 he.h_length = NS_INADDRSZ;
 461                 break;
 462         case AF_INET6:
 463                 he.h_length = NS_IN6ADDRSZ;
 464                 break;
 465         default:
 466                 errno = EAFNOSUPPORT;
 467                 RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
 468                 return (-1);
 469         }
 470         he.h_name = hed->hostbuf;
 471         he.h_aliases = hed->host_aliases;
 472         hed->host_aliases[0] = NULL;
 473         hed->h_addr_ptrs[0] = (char *)hed->host_addr;
 474         hed->h_addr_ptrs[1] = NULL;
 475         he.h_addr_list = hed->h_addr_ptrs;
 476         if (__copy_hostent(&he, hp, buf, buflen) != 0) {
 477                 RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
 478                 return (-1);
 479         }
 480         RES_SET_H_ERRNO(statp, NETDB_SUCCESS);
 481         return (0);
 482 }
 483
 484 int
 485 gethostbyname_r(const char *name, struct hostent *he, char *buffer,
 486     size_t buflen, struct hostent **result, int *h_errnop)
 487 {
 488         res_state statp;
 489
 490         statp = __res_state();
 491         if ((statp->options & RES_INIT) == 0 && res_ninit(statp) == -1) {
 492                 RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
 493                 return (-1);
 494         }
 495         if (statp->options & RES_USE_INET6) {
 496                 if (fakeaddr(name, AF_INET, he, buffer, buflen, statp) == 0) {
 497                         *result = he;
 498                         return (0);
 499                 }
 500                 if (gethostbyname_internal(name, AF_INET6, he, buffer, buflen,
 501                     result, h_errnop, statp) == 0)
 502                         return (0);
 503         }
 504         return (gethostbyname_internal(name, AF_INET, he, buffer, buflen,
 505             result, h_errnop, statp));
 506 }
 507
 508 int
 509 gethostbyname2_r(const char *name, int af, struct hostent *he, char *buffer,
 510     size_t buflen, struct hostent **result, int *h_errnop)
 511 {
 512         res_state statp;
 513
 514         statp = __res_state();
 515         if ((statp->options & RES_INIT) == 0 && res_ninit(statp) == -1) {
 516                 RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
 517                 return (-1);
 518         }
 519         return (gethostbyname_internal(name, af, he, buffer, buflen, result,
 520             h_errnop, statp));
 521 }
 522
 523 int
 524 gethostbyname_internal(const char *name, int af, struct hostent *hp, char *buf,
 525     size_t buflen, struct hostent **result, int *h_errnop, res_state statp)
 526 {
 527         const char *cp;
 528         int rval, ret_errno = 0;
 529         char abuf[MAXDNAME];
 530
 531 #ifdef NS_CACHING
 532         static const nss_cache_info cache_info =
 533                 NS_COMMON_CACHE_INFO_INITIALIZER(
 534                 hosts, (void *)nss_lt_name,
 535                 host_id_func, host_marshal_func, host_unmarshal_func);
 536 #endif
 537         static const ns_dtab dtab[] = {
 538                 NS_FILES_CB(_ht_gethostbyname, NULL)
 539                 { NSSRC_DNS, _dns_gethostbyname, NULL },
 540                 NS_NIS_CB(_nis_gethostbyname, NULL) /* force -DHESIOD */
 541 #ifdef NS_CACHING
 542                 NS_CACHE_CB(&cache_info)
 543 #endif
 544                 { 0 }
 545         };
 546
 547         switch (af) {
 548         case AF_INET:
 549         case AF_INET6:
 550                 break;
 551         default:
 552                 RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
 553                 *h_errnop = statp->res_h_errno;
 554                 errno = EAFNOSUPPORT;
 555                 return (-1);
 556         }
 557
 558         /*
 559          * if there aren't any dots, it could be a user-level alias.
 560          * this is also done in res_query() since we are not the only
 561          * function that looks up host names.
 562          */
 563         if (!strchr(name, '.') &&
 564             (cp = res_hostalias(statp, name, abuf, sizeof abuf)))
 565                 name = cp;
 566
 567         if (fakeaddr(name, af, hp, buf, buflen, statp) == 0) {
 568                 *result = hp;
 569                 return (0);
 570         }
 571
 572         rval = _nsdispatch((void *)result, dtab, NSDB_HOSTS,
 573             "gethostbyname2_r", default_src, name, af, hp, buf, buflen,
 574             &ret_errno, h_errnop);
 575
 576         if (rval != NS_SUCCESS) {
 577                 errno = ret_errno;
 578                 return ((ret_errno != 0) ? ret_errno : -1);
 579         }
 580         return (0);
 581 }
 582
 583 int
 584 gethostbyaddr_r(const void *addr, socklen_t len, int af, struct hostent *hp,
 585     char *buf, size_t buflen, struct hostent **result, int *h_errnop)
 586 {
 587         const u_char *uaddr = (const u_char *)addr;
 588         const struct in6_addr *addr6;
 589         socklen_t size;
 590         int rval, ret_errno = 0;
 591         res_state statp;
 592
 593 #ifdef NS_CACHING
 594         static const nss_cache_info cache_info =
 595                 NS_COMMON_CACHE_INFO_INITIALIZER(
 596                 hosts, (void *)nss_lt_id,
 597                 host_id_func, host_marshal_func, host_unmarshal_func);
 598 #endif
 599         static const ns_dtab dtab[] = {
 600                 NS_FILES_CB(_ht_gethostbyaddr, NULL)
 601                 { NSSRC_DNS, _dns_gethostbyaddr, NULL },
 602                 NS_NIS_CB(_nis_gethostbyaddr, NULL) /* force -DHESIOD */
 603 #ifdef NS_CACHING
 604                 NS_CACHE_CB(&cache_info)
 605 #endif
 606                 { 0 }
 607         };
 608
 609         statp = __res_state();
 610         if ((statp->options & RES_INIT) == 0 && res_ninit(statp) == -1) {
 611                 RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
 612                 *h_errnop = statp->res_h_errno;
 613                 return (-1);
 614         }
 615
 616         if (af == AF_INET6 && len == NS_IN6ADDRSZ) {
 617                 addr6 = (const struct in6_addr *)addr;
 618                 if (IN6_IS_ADDR_LINKLOCAL(addr6)) {
 619                         RES_SET_H_ERRNO(statp, HOST_NOT_FOUND);
 620                         *h_errnop = statp->res_h_errno;
 621                         return (-1);
 622                 }
 623                 if (IN6_IS_ADDR_V4MAPPED(addr6) ||
 624                     IN6_IS_ADDR_V4COMPAT(addr6)) {
 625                         /* Unmap. */
 626                         uaddr += NS_IN6ADDRSZ - NS_INADDRSZ;
 627                         af = AF_INET;
 628                         len = NS_INADDRSZ;
 629                 }
 630         }
 631         switch (af) {
 632         case AF_INET:
 633                 size = NS_INADDRSZ;
 634                 break;
 635         case AF_INET6:
 636                 size = NS_IN6ADDRSZ;
 637                 break;
 638         default:
 639                 errno = EAFNOSUPPORT;
 640                 RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
 641                 *h_errnop = statp->res_h_errno;
 642                 return (-1);
 643         }
 644         if (size != len) {
 645                 errno = EINVAL;
 646                 RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
 647                 *h_errnop = statp->res_h_errno;
 648                 return (-1);
 649         }
 650
 651         rval = _nsdispatch((void *)result, dtab, NSDB_HOSTS,
 652             "gethostbyaddr_r", default_src, uaddr, len, af, hp, buf, buflen,
 653             &ret_errno, h_errnop);
 654
 655         if (rval != NS_SUCCESS) {
 656                 errno = ret_errno;
 657                 return ((ret_errno != 0) ? ret_errno : -1);
 658         }
 659         return (0);
 660 }
 661
 662 struct hostent *
 663 gethostbyname(const char *name)
 664 {
 665         struct hostdata *hd;
 666         struct hostent *rval;
 667         int ret_h_errno;
 668
 669         if ((hd = __hostdata_init()) == NULL)
 670                 return (NULL);
 671         if (gethostbyname_r(name, &hd->host, hd->data, sizeof(hd->data), &rval,
 672             &ret_h_errno) != 0)
 673                 return (NULL);
 674         return (rval);
 675 }
 676
 677 struct hostent *
 678 gethostbyname2(const char *name, int af)
 679 {
 680         struct hostdata *hd;
 681         struct hostent *rval;
 682         int ret_h_errno;
 683
 684         if ((hd = __hostdata_init()) == NULL)
 685                 return (NULL);
 686         if (gethostbyname2_r(name, af, &hd->host, hd->data, sizeof(hd->data),
 687             &rval, &ret_h_errno) != 0)
 688                 return (NULL);
 689         return (rval);
 690 }
 691
 692 struct hostent *
 693 gethostbyaddr(const void *addr, socklen_t len, int af)
 694 {
 695         struct hostdata *hd;
 696         struct hostent *rval;
 697         int ret_h_errno;
 698
 699         if ((hd = __hostdata_init()) == NULL)
 700                 return (NULL);
 701         if (gethostbyaddr_r(addr, len, af, &hd->host, hd->data,
 702             sizeof(hd->data), &rval, &ret_h_errno) != 0)
 703                 return (NULL);
 704         return (rval);
 705 }
 706
 707 void
 708 sethostent(int stayopen)
 709 {
 710         struct hostent_data *hed;
 711
 712         if ((hed = __hostent_data_init()) == NULL)
 713                 return;
 714         _sethosthtent(stayopen, hed);
 715         _sethostdnsent(stayopen);
 716 }
 717
 718 void
 719 endhostent(void)
 720 {
 721         struct hostent_data *hed;
 722
 723         if ((hed = __hostent_data_init()) == NULL)
 724                 return;
 725         _endhosthtent(hed);
 726         _endhostdnsent();
 727 }