external/bsd/bind/dist/lib/lwres/gethost.c

   1 /*      $NetBSD: gethost.c,v 1.7 2015/07/08 17:29:00 christos Exp $     */
   2
   3 /*
   4  * Copyright (C) 2004, 2005, 2007, 2013-2015  Internet Systems Consortium, Inc. ("ISC")
   5  * Copyright (C) 2000, 2001  Internet Software Consortium.
   6  *
   7  * Permission to use, copy, modify, and/or distribute this software for any
   8  * purpose with or without fee is hereby granted, provided that the above
   9  * copyright notice and this permission notice appear in all copies.
  10  *
  11  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  12  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  13  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  14  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  15  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  16  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  17  * PERFORMANCE OF THIS SOFTWARE.
  18  */
  19
  20 /* Id: gethost.c,v 1.34 2007/06/19 23:47:22 tbox Exp  */
  21
  22 /*! \file */
  23
  24 /**
  25  *    These functions provide hostname-to-address and address-to-hostname
  26  *    lookups by means of the lightweight resolver. They are similar to the
  27  *    standard gethostent(3) functions provided by most operating systems.
  28  *    They use a struct hostent which is usually defined in <namedb.h>.
  29  *
  30  * \code
  31  * struct  hostent {
  32  *         char    *h_name;        // official name of host
  33  *         char    **h_aliases;    // alias list
  34  *         int     h_addrtype;     // host address type
  35  *         int     h_length;       // length of address
  36  *         char    **h_addr_list;  // list of addresses from name server
  37  * };
  38  * #define h_addr  h_addr_list[0]  // address, for backward compatibility
  39  * \endcode
  40  *
  41  *    The members of this structure are:
  42  *
  43  * \li   h_name:
  44  *           The official (canonical) name of the host.
  45  *
  46  * \li   h_aliases:
  47  *           A NULL-terminated array of alternate names (nicknames) for the
  48  *           host.
  49  *
  50  * \li   h_addrtype:
  51  *           The type of address being returned -- PF_INET or PF_INET6.
  52  *
  53  * \li   h_length:
  54  *           The length of the address in bytes.
  55  *
  56  * \li   h_addr_list:
  57  *           A NULL terminated array of network addresses for the host. Host
  58  *           addresses are returned in network byte order.
  59  *
  60  *    For backward compatibility with very old software, h_addr is the first
  61  *    address in h_addr_list.
  62  *
  63  *    lwres_gethostent(), lwres_sethostent(), lwres_endhostent(),
  64  *    lwres_gethostent_r(), lwres_sethostent_r() and lwres_endhostent_r()
  65  *    provide iteration over the known host entries on systems that provide
  66  *    such functionality through facilities like /etc/hosts or NIS. The
  67  *    lightweight resolver does not currently implement these functions; it
  68  *    only provides them as stub functions that always return failure.
  69  *
  70  *    lwres_gethostbyname() and lwres_gethostbyname2() look up the hostname
  71  *    name. lwres_gethostbyname() always looks for an IPv4 address while
  72  *    lwres_gethostbyname2() looks for an address of protocol family af:
  73  *    either PF_INET or PF_INET6 -- IPv4 or IPV6 addresses respectively.
  74  *    Successful calls of the functions return a struct hostent for the name
  75  *    that was looked up. NULL is returned if the lookups by
  76  *    lwres_gethostbyname() or lwres_gethostbyname2() fail.
  77  *
  78  *    Reverse lookups of addresses are performed by lwres_gethostbyaddr().
  79  *    addr is an address of length len bytes and protocol family type --
  80  *    PF_INET or PF_INET6. lwres_gethostbyname_r() is a thread-safe function
  81  *    for forward lookups. If an error occurs, an error code is returned in
  82  *    *error. resbuf is a pointer to a struct hostent which is initialised
  83  *    by a successful call to lwres_gethostbyname_r() . buf is a buffer of
  84  *    length len bytes which is used to store the h_name, h_aliases, and
  85  *    h_addr_list elements of the struct hostent returned in resbuf.
  86  *    Successful calls to lwres_gethostbyname_r() return resbuf, which is a
  87  *    pointer to the struct hostent it created.
  88  *
  89  *    lwres_gethostbyaddr_r() is a thread-safe function that performs a
  90  *    reverse lookup of address addr which is len bytes long and is of
  91  *    protocol family type -- PF_INET or PF_INET6. If an error occurs, the
  92  *    error code is returned in *error. The other function parameters are
  93  *    identical to those in lwres_gethostbyname_r(). resbuf is a pointer to
  94  *    a struct hostent which is initialised by a successful call to
  95  *    lwres_gethostbyaddr_r(). buf is a buffer of length len bytes which is
  96  *    used to store the h_name, h_aliases, and h_addr_list elements of the
  97  *    struct hostent returned in resbuf. Successful calls to
  98  *    lwres_gethostbyaddr_r() return resbuf, which is a pointer to the
  99  *    struct hostent it created.
 100  *
 101  * \section gethost_return Return Values
 102  *
 103  *    The functions lwres_gethostbyname(), lwres_gethostbyname2(),
 104  *    lwres_gethostbyaddr(), and lwres_gethostent() return NULL to indicate
 105  *    an error. In this case the global variable lwres_h_errno will contain
 106  *    one of the following error codes defined in \link netdb.h <lwres/netdb.h>:\endlink
 107  *
 108  * \li #HOST_NOT_FOUND:
 109  *           The host or address was not found.
 110  *
 111  * \li #TRY_AGAIN:
 112  *           A recoverable error occurred, e.g., a timeout. Retrying the
 113  *           lookup may succeed.
 114  *
 115  * \li #NO_RECOVERY:
 116  *           A non-recoverable error occurred.
 117  *
 118  * \li #NO_DATA:
 119  *           The name exists, but has no address information associated with
 120  *           it (or vice versa in the case of a reverse lookup). The code
 121  *           NO_ADDRESS is accepted as a synonym for NO_DATA for backwards
 122  *           compatibility.
 123  *
 124  *    lwres_hstrerror() translates these error codes to suitable error
 125  *    messages.
 126  *
 127  *    lwres_gethostent() and lwres_gethostent_r() always return NULL.
 128  *
 129  *    Successful calls to lwres_gethostbyname_r() and
 130  *    lwres_gethostbyaddr_r() return resbuf, a pointer to the struct hostent
 131  *    that was initialised by these functions. They return NULL if the
 132  *    lookups fail or if buf was too small to hold the list of addresses and
 133  *    names referenced by the h_name, h_aliases, and h_addr_list elements of
 134  *    the struct hostent. If buf was too small, both lwres_gethostbyname_r()
 135  *    and lwres_gethostbyaddr_r() set the global variable errno to ERANGE.
 136  *
 137  * \section gethost_see See Also
 138  *
 139  *    gethostent(), \link getipnode.c getipnode\endlink, lwres_hstrerror()
 140  *
 141  * \section gethost_bugs Bugs
 142  *
 143  *    lwres_gethostbyname(), lwres_gethostbyname2(), lwres_gethostbyaddr()
 144  *    and lwres_endhostent() are not thread safe; they return pointers to
 145  *    static data and provide error codes through a global variable.
 146  *    Thread-safe versions for name and address lookup are provided by
 147  *    lwres_gethostbyname_r(), and lwres_gethostbyaddr_r() respectively.
 148  *
 149  *    The resolver daemon does not currently support any non-DNS name
 150  *    services such as /etc/hosts or NIS, consequently the above functions
 151  *    don't, either.
 152  */
 153
 154 #include <config.h>
 155
 156 #include <errno.h>
 157 #include <string.h>
 158 #ifdef HAVE_INTTYPES_H
 159 #include <inttypes.h> /* uintptr_t */
 160 #endif
 161
 162 #include <lwres/net.h>
 163 #include <lwres/netdb.h>
 164
 165 #include "assert_p.h"
 166
 167 #define LWRES_ALIGNBYTES (sizeof(char *) - 1)
 168 #define LWRES_ALIGN(p) \
 169         (((uintptr_t)(p) + LWRES_ALIGNBYTES) &~ LWRES_ALIGNBYTES)
 170
 171 static struct hostent *he = NULL;
 172 static int copytobuf(struct hostent *, struct hostent *, char *, int);
 173
 174 /*% Always looks for an IPv4 address. */
 175 struct hostent *
 176 lwres_gethostbyname(const char *name) {
 177
 178         if (he != NULL)
 179                 lwres_freehostent(he);
 180
 181         he = lwres_getipnodebyname(name, AF_INET, 0, &lwres_h_errno);
 182         return (he);
 183 }
 184
 185 /*% Looks for either an IPv4 or IPv6 address. */
 186 struct hostent *
 187 lwres_gethostbyname2(const char *name, int af) {
 188         if (he != NULL)
 189                 lwres_freehostent(he);
 190
 191         he = lwres_getipnodebyname(name, af, 0, &lwres_h_errno);
 192         return (he);
 193 }
 194
 195 /*% Reverse lookup of addresses. */
 196 struct hostent *
 197 lwres_gethostbyaddr(const char *addr, int len, int type) {
 198
 199         if (he != NULL)
 200                 lwres_freehostent(he);
 201
 202         he = lwres_getipnodebyaddr(addr, len, type, &lwres_h_errno);
 203         return (he);
 204 }
 205
 206 /*% Stub function.  Always returns failure. */
 207 struct hostent *
 208 lwres_gethostent(void) {
 209         if (he != NULL)
 210                 lwres_freehostent(he);
 211
 212         return (NULL);
 213 }
 214
 215 /*% Stub function.  Always returns failure. */
 216 void
 217 lwres_sethostent(int stayopen) {
 218         /*
 219          * Empty.
 220          */
 221         UNUSED(stayopen);
 222 }
 223
 224 /*% Stub function.  Always returns failure. */
 225 void
 226 lwres_endhostent(void) {
 227         /*
 228          * Empty.
 229          */
 230 }
 231
 232 /*% Thread-safe function for forward lookups. */
 233 struct hostent *
 234 lwres_gethostbyname_r(const char *name, struct hostent *resbuf,
 235                 char *buf, int buflen, int *error)
 236 {
 237         struct hostent *myhe;
 238         int res;
 239
 240         myhe = lwres_getipnodebyname(name, AF_INET, 0, error);
 241         if (myhe == NULL)
 242                 return (NULL);
 243         res = copytobuf(myhe, resbuf, buf, buflen);
 244         lwres_freehostent(myhe);
 245         if (res != 0) {
 246                 errno = ERANGE;
 247                 return (NULL);
 248         }
 249         return (resbuf);
 250 }
 251
 252 /*% Thread-safe reverse lookup. */
 253 struct hostent  *
 254 lwres_gethostbyaddr_r(const char *addr, int len, int type,
 255                       struct hostent *resbuf, char *buf, int buflen,
 256                       int *error)
 257 {
 258         struct hostent *myhe;
 259         int res;
 260
 261         myhe = lwres_getipnodebyaddr(addr, len, type, error);
 262         if (myhe == NULL)
 263                 return (NULL);
 264         res = copytobuf(myhe, resbuf, buf, buflen);
 265         lwres_freehostent(myhe);
 266         if (res != 0) {
 267                 errno = ERANGE;
 268                 return (NULL);
 269         }
 270         return (resbuf);
 271 }
 272
 273 /*% Stub function.  Always returns failure. */
 274 struct hostent  *
 275 lwres_gethostent_r(struct hostent *resbuf, char *buf, int buflen, int *error) {
 276         UNUSED(resbuf);
 277         UNUSED(buf);
 278         UNUSED(buflen);
 279         *error = 0;
 280         return (NULL);
 281 }
 282
 283 /*% Stub function.  Always returns failure. */
 284 void
 285 lwres_sethostent_r(int stayopen) {
 286         /*
 287          * Empty.
 288          */
 289         UNUSED(stayopen);
 290 }
 291
 292 /*% Stub function.  Always returns failure. */
 293 void
 294 lwres_endhostent_r(void) {
 295         /*
 296          * Empty.
 297          */
 298 }
 299
 300 static int
 301 copytobuf(struct hostent *src, struct hostent *hptr, char *buf, int buflen) {
 302         char *cp;
 303         char **ptr;
 304         int i, n;
 305         int nptr, len;
 306
 307         /*
 308          * Find out the amount of space required to store the answer.
 309          */
 310         nptr = 2; /* NULL ptrs */
 311         len = (int)((char *)LWRES_ALIGN(buf) - buf);
 312         for (i = 0; src->h_addr_list[i]; i++, nptr++) {
 313                 len += src->h_length;
 314         }
 315         for (i = 0; src->h_aliases[i]; i++, nptr++) {
 316                 len += strlen(src->h_aliases[i]) + 1;
 317         }
 318         len += strlen(src->h_name) + 1;
 319         len += nptr * sizeof(char*);
 320
 321         if (len > buflen) {
 322                 return (-1);
 323         }
 324
 325         /*
 326          * Copy address size and type.
 327          */
 328         hptr->h_addrtype = src->h_addrtype;
 329         n = hptr->h_length = src->h_length;
 330
 331         ptr = (char **)LWRES_ALIGN(buf);
 332         cp = (char *)LWRES_ALIGN(buf) + nptr * sizeof(char *);
 333
 334         /*
 335          * Copy address list.
 336          */
 337         hptr->h_addr_list = ptr;
 338         for (i = 0; src->h_addr_list[i]; i++, ptr++) {
 339                 memmove(cp, src->h_addr_list[i], n);
 340                 hptr->h_addr_list[i] = cp;
 341                 cp += n;
 342         }
 343         hptr->h_addr_list[i] = NULL;
 344         ptr++;
 345
 346         /*
 347          * Copy official name.
 348          */
 349         n = strlen(src->h_name) + 1;
 350         strcpy(cp, src->h_name);
 351         hptr->h_name = cp;
 352         cp += n;
 353
 354         /*
 355          * Copy aliases.
 356          */
 357         hptr->h_aliases = ptr;
 358         for (i = 0; src->h_aliases[i]; i++) {
 359                 n = strlen(src->h_aliases[i]) + 1;
 360                 strcpy(cp, src->h_aliases[i]);
 361                 hptr->h_aliases[i] = cp;
 362                 cp += n;
 363         }
 364         hptr->h_aliases[i] = NULL;
 365
 366         return (0);
 367 }