usr/src/lib/nsswitch/dns/common/gethostent.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 /*
  30  * gethostent.c
  31  *
  32  * In order to avoid duplicating libresolv code here, and since libresolv.so.2
  33  * provides res_-equivalents of the getXbyY and {set,get}Xent, lets call
  34  * re_gethostbyaddr() and so on from this file. Among other things, this
  35  * should help us avoid problems like the one described in bug 1264386,
  36  * where the internal getanswer() acquired new functionality in BIND 4.9.3,
  37  * but the local copy of getanswer() in this file wasn't updated, so that new
  38  * functionality wasn't available to the name service switch.
  39  */
  40
  41 #define gethostbyaddr   res_gethostbyaddr
  42 #define gethostbyname   res_gethostbyname
  43 #define gethostbyname2  res_gethostbyname2
  44 #define sethostent      res_sethostent
  45 #define endhostent      res_endhostent
  46
  47 #include "dns_common.h"
  48
  49 extern char *inet_ntoa(struct in_addr in);
  50
  51 struct hostent *_gethostbyname(int *h_errnop, const char *name);
  52 static struct hostent *_gethostbyaddr(int *h_errnop, const char *addr,
  53     int len, int type);
  54 struct hostent *_nss_dns_gethostbyname2(int *h_errnop, const char *name);
  55
  56 #pragma weak    res_gethostbyname
  57 #pragma weak    res_gethostbyname2
  58 #pragma weak    res_gethostbyaddr
  59 #pragma weak    res_sethostent
  60 #pragma weak    res_endhostent
  61
  62 nss_backend_t *_nss_dns_constr(dns_backend_op_t ops[], int n_ops);
  63 nss_status_t __nss_dns_getbyaddr(dns_backend_ptr_t, void *);
  64
  65 typedef union {
  66         long al;
  67         char ac;
  68 } align;
  69
  70 /*
  71  * Internet Name Domain Server (DNS) only implementation.
  72  */
  73 static struct hostent *
  74 _gethostbyaddr(int *h_errnop, const char *addr, int len, int type)
  75 {
  76         struct hostent  *hp;
  77
  78         hp = gethostbyaddr(addr, len, type);
  79         *h_errnop = *get_h_errno();
  80         return (hp);
  81 }
  82
  83 struct hostent *
  84 _nss_dns_gethostbyname2(int *h_errnop, const char *name)
  85 {
  86         struct hostent *hp;
  87
  88         hp = gethostbyname2(name, AF_INET6);
  89         *h_errnop = *get_h_errno();
  90         return (hp);
  91 }
  92
  93 struct hostent *
  94 _gethostbyname(int *h_errnop, const char *name)
  95 {
  96         struct hostent *hp;
  97
  98         hp = gethostbyname(name);
  99         *h_errnop = *get_h_errno();
 100         return (hp);
 101 }
 102
 103 static void
 104 _sethostent(errp, stayopen)
 105         nss_status_t    *errp;
 106         int             stayopen;
 107 {
 108         int     ret;
 109
 110         ret = sethostent(stayopen);
 111         if (ret == 0)
 112                 *errp = NSS_SUCCESS;
 113         else
 114                 *errp = NSS_UNAVAIL;
 115 }
 116
 117 static void
 118 _endhostent(errp)
 119         nss_status_t    *errp;
 120 {
 121         int     ret;
 122
 123         ret = endhostent();
 124         if (ret == 0)
 125                 *errp = NSS_SUCCESS;
 126         else
 127                 *errp = NSS_UNAVAIL;
 128 }
 129
 130
 131 /*ARGSUSED*/
 132 static nss_status_t
 133 getbyname(be, a)
 134         dns_backend_ptr_t       be;
 135         void                    *a;
 136 {
 137         struct hostent  *he;
 138         nss_XbyY_args_t *argp = (nss_XbyY_args_t *)a;
 139         int             ret, mt_disabled;
 140         int             old_retry;
 141         sigset_t        oldmask;
 142
 143         switch_resolver_setup(&mt_disabled, &oldmask, &old_retry);
 144
 145         he = _gethostbyname(&argp->h_errno, argp->key.name);
 146         if (he != NULL) {
 147                 if (argp->buf.result == NULL) {
 148                         /*
 149                          * if asked to return data in string,
 150                          * convert the hostent structure into
 151                          * string data
 152                          */
 153                         ret = ent2str(he, a, AF_INET);
 154                         if (ret == NSS_STR_PARSE_SUCCESS)
 155                                 argp->returnval = argp->buf.buffer;
 156                 } else {
 157                         ret = ent2result(he, a, AF_INET);
 158                         if (ret == NSS_STR_PARSE_SUCCESS)
 159                                 argp->returnval = argp->buf.result;
 160                 }
 161
 162                 if (ret != NSS_STR_PARSE_SUCCESS) {
 163                         argp->h_errno = HOST_NOT_FOUND;
 164                         if (ret == NSS_STR_PARSE_ERANGE) {
 165                                 argp->erange = 1;
 166                         }
 167                 }
 168         }
 169
 170         switch_resolver_reset(mt_disabled, oldmask, old_retry);
 171
 172         return (_herrno2nss(argp->h_errno));
 173 }
 174
 175
 176
 177 /*ARGSUSED*/
 178 static nss_status_t
 179 getbyaddr(be, a)
 180         dns_backend_ptr_t       be;
 181         void                    *a;
 182 {
 183         return (__nss_dns_getbyaddr(be, a));
 184 }
 185
 186
 187 /*
 188  * Exposing a DNS backend specific interface so that it doesn't conflict
 189  * with other getbyaddr() routines from other switch backends.
 190  */
 191 /*ARGSUSED*/
 192 nss_status_t
 193 __nss_dns_getbyaddr(be, a)
 194         dns_backend_ptr_t       be;
 195         void                    *a;
 196 {
 197         struct hostent  *he;
 198         nss_XbyY_args_t *argp = (nss_XbyY_args_t *)a;
 199         int             ret, mt_disabled;
 200         struct in_addr  unmapv4;
 201         sigset_t        oldmask;
 202         int             af, addrlen;
 203         void            *addrp;
 204         int             old_retry;
 205
 206         switch_resolver_setup(&mt_disabled, &oldmask, &old_retry);
 207
 208         /* LINTED: E_BAD_PTR_CAST_ALIGN */
 209         if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)argp->key.hostaddr.addr)) {
 210                 addrp = &unmapv4;
 211                 addrlen = sizeof (unmapv4);
 212                 af = AF_INET;
 213                 (void) memcpy(addrp, &argp->key.hostaddr.addr[12], addrlen);
 214         } else {
 215                 addrp = (void *)argp->key.hostaddr.addr;
 216                 addrlen = argp->key.hostaddr.len;
 217                 af = argp->key.hostaddr.type;
 218         }
 219         he = _gethostbyaddr(&argp->h_errno, addrp, addrlen, af);
 220
 221         if (he != NULL) {
 222                 /*
 223                  * if asked to return data in string, convert
 224                  * the hostent structure into string data
 225                  */
 226                 if (argp->buf.result == NULL)
 227                         ret = ent2str(he, a, argp->key.hostaddr.type);
 228                 else
 229                         ret = ent2result(he, a, argp->key.hostaddr.type);
 230
 231                 if (ret == NSS_STR_PARSE_SUCCESS) {
 232                         if (argp->buf.result == NULL)
 233                                 argp->returnval = argp->buf.buffer;
 234                         else
 235                                 argp->returnval = argp->buf.result;
 236                 } else {
 237                         argp->h_errno = HOST_NOT_FOUND;
 238                         if (ret == NSS_STR_PARSE_ERANGE)
 239                                 argp->erange = 1;
 240                 }
 241         }
 242
 243         switch_resolver_reset(mt_disabled, oldmask, old_retry);
 244
 245         return (_herrno2nss(argp->h_errno));
 246 }
 247
 248
 249 /*ARGSUSED*/
 250 static nss_status_t
 251 _nss_dns_getent(be, args)
 252         dns_backend_ptr_t       be;
 253         void                    *args;
 254 {
 255         return (NSS_UNAVAIL);
 256 }
 257
 258
 259 /*ARGSUSED*/
 260 static nss_status_t
 261 _nss_dns_setent(be, dummy)
 262         dns_backend_ptr_t       be;
 263         void                    *dummy;
 264 {
 265         nss_status_t    errp;
 266
 267         sigset_t        oldmask, newmask;
 268         int             mt_disabled = 1;
 269
 270         /*
 271          * Try to enable MT; if not, we have to single-thread libresolv
 272          * access
 273          */
 274         if (enable_mt == 0 || (mt_disabled = (*enable_mt)()) != 0) {
 275                 (void) sigfillset(&newmask);
 276                 (void) thr_sigsetmask(SIG_SETMASK, &newmask, &oldmask);
 277                 (void) mutex_lock(&one_lane);
 278         }
 279
 280         _sethostent(&errp, 1);
 281
 282         if (mt_disabled) {
 283                 (void) mutex_unlock(&one_lane);
 284                 (void) thr_sigsetmask(SIG_SETMASK, &oldmask, NULL);
 285         } else {
 286                 (void) (*disable_mt)();
 287         }
 288
 289         return (errp);
 290 }
 291
 292
 293 /*ARGSUSED*/
 294 static nss_status_t
 295 _nss_dns_endent(be, dummy)
 296         dns_backend_ptr_t       be;
 297         void                    *dummy;
 298 {
 299         nss_status_t    errp;
 300
 301         sigset_t        oldmask, newmask;
 302         int             mt_disabled = 1;
 303
 304         /*
 305          * Try to enable MT; if not, we have to single-thread libresolv
 306          * access
 307          */
 308         if (enable_mt == 0 || (mt_disabled = (*enable_mt)()) != 0) {
 309                 (void) sigfillset(&newmask);
 310                 (void) thr_sigsetmask(SIG_SETMASK, &newmask, &oldmask);
 311                 (void) mutex_lock(&one_lane);
 312         }
 313
 314         _endhostent(&errp);
 315
 316         if (mt_disabled) {
 317                 (void) mutex_unlock(&one_lane);
 318                 (void) thr_sigsetmask(SIG_SETMASK, &oldmask, NULL);
 319         } else {
 320                 (void) (*disable_mt)();
 321         }
 322
 323         return (errp);
 324 }
 325
 326
 327 /*ARGSUSED*/
 328 static nss_status_t
 329 _nss_dns_destr(be, dummy)
 330         dns_backend_ptr_t       be;
 331         void                    *dummy;
 332 {
 333         nss_status_t    errp;
 334
 335         if (be != 0) {
 336                 /* === Should change to invoke ops[ENDENT] ? */
 337                 sigset_t        oldmask, newmask;
 338                 int             mt_disabled = 1;
 339
 340                 if (enable_mt == 0 || (mt_disabled = (*enable_mt)()) != 0) {
 341                         (void) sigfillset(&newmask);
 342                         (void) thr_sigsetmask(SIG_SETMASK, &newmask, &oldmask);
 343                         (void) mutex_lock(&one_lane);
 344                 }
 345
 346                 _endhostent(&errp);
 347
 348                 if (mt_disabled) {
 349                         (void) mutex_unlock(&one_lane);
 350                         (void) thr_sigsetmask(SIG_SETMASK, &oldmask, NULL);
 351                 } else {
 352                         (void) (*disable_mt)();
 353                 }
 354
 355                 free(be);
 356         }
 357         return (NSS_SUCCESS);   /* In case anyone is dumb enough to check */
 358 }
 359
 360
 361 static dns_backend_op_t host_ops[] = {
 362         _nss_dns_destr,
 363         _nss_dns_endent,
 364         _nss_dns_setent,
 365         _nss_dns_getent,
 366         getbyname,
 367         getbyaddr,
 368 };
 369
 370 /*ARGSUSED*/
 371 nss_backend_t *
 372 _nss_dns_hosts_constr(dummy1, dummy2, dummy3)
 373         const char      *dummy1, *dummy2, *dummy3;
 374 {
 375         return (_nss_dns_constr(host_ops,
 376                 sizeof (host_ops) / sizeof (host_ops[0])));
 377 }
 378
 379 /*
 380  * optional NSS2 packed backend gethostsbyname with ttl
 381  * entry point.
 382  *
 383  * Returns:
 384  *      NSS_SUCCESS - successful
 385  *      NSS_NOTFOUND - successful but nothing found
 386  *      NSS_ERROR - fallback to NSS backend lookup mode
 387  * If successful, buffer will be filled with valid data
 388  *
 389  */
 390
 391 /*ARGSUSED*/
 392 nss_status_t
 393 _nss_get_dns_hosts_name(dns_backend_ptr_t *be, void **bufp, size_t *sizep)
 394 {
 395         return (_nss_dns_gethost_withttl(*bufp, *sizep, 0));
 396 }