nis/nss_nis/nis-hosts.c

   1 /* Copyright (C) 1996-2000, 2002, 2003, 2006, 2007, 2008
   2    Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Thorsten Kukuk <kukuk@suse.de>, 1996.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include <assert.h>
  21 #include <nss.h>
  22 #include <ctype.h>
  23 /* The following is an ugly trick to avoid a prototype declaration for
  24    _nss_nis_endgrent.  */
  25 #define _nss_nis_endhostent _nss_nis_endhostent_XXX
  26 #include <netdb.h>
  27 #undef _nss_nis_endhostent
  28 #include <string.h>
  29 #include <netinet/in.h>
  30 #include <arpa/inet.h>
  31 #include <resolv.h>
  32 #include <bits/libc-lock.h>
  33 #include <rpcsvc/yp.h>
  34 #include <rpcsvc/ypclnt.h>
  35
  36 #include "nss-nis.h"
  37
  38 /* Get implementation for some internal functions. */
  39 #include <resolv/mapv4v6addr.h>
  40
  41 #define ENTNAME         hostent
  42 #define DATABASE        "hosts"
  43 #define NEED_H_ERRNO
  44
  45 #define EXTRA_ARGS      , af, flags
  46 #define EXTRA_ARGS_DECL , int af, int flags
  47
  48 #define ENTDATA hostent_data
  49 struct hostent_data
  50   {
  51     unsigned char host_addr[16];        /* IPv4 or IPv6 address.  */
  52     char *h_addr_ptrs[2];       /* Points to that and null terminator.  */
  53   };
  54
  55 #define TRAILING_LIST_MEMBER            h_aliases
  56 #define TRAILING_LIST_SEPARATOR_P       isspace
  57 #include <nss/nss_files/files-parse.c>
  58 LINE_PARSER
  59 ("#",
  60  {
  61    char *addr;
  62
  63    STRING_FIELD (addr, isspace, 1);
  64
  65    assert (af == AF_INET || af == AF_INET6 || af == AF_UNSPEC);
  66
  67    /* Parse address.  */
  68    if (af != AF_INET6 && inet_pton (AF_INET, addr, entdata->host_addr) > 0)
  69      {
  70        assert ((flags & AI_V4MAPPED) == 0 || af != AF_UNSPEC);
  71        if (flags & AI_V4MAPPED)
  72          {
  73            map_v4v6_address ((char *) entdata->host_addr,
  74                              (char *) entdata->host_addr);
  75            result->h_addrtype = AF_INET6;
  76            result->h_length = IN6ADDRSZ;
  77          }
  78        else
  79          {
  80            result->h_addrtype = AF_INET;
  81            result->h_length = INADDRSZ;
  82          }
  83      }
  84    else if (af != AF_INET
  85             && inet_pton (AF_INET6, addr, entdata->host_addr) > 0)
  86      {
  87        result->h_addrtype = AF_INET6;
  88        result->h_length = IN6ADDRSZ;
  89      }
  90    else
  91      /* Illegal address: ignore line.  */
  92      return 0;
  93
  94    /* Store a pointer to the address in the expected form.  */
  95    entdata->h_addr_ptrs[0] = (char *) entdata->host_addr;
  96    entdata->h_addr_ptrs[1] = NULL;
  97    result->h_addr_list = entdata->h_addr_ptrs;
  98
  99    STRING_FIELD (result->h_name, isspace, 1);
 100  })
 101
 102
 103 __libc_lock_define_initialized (static, lock)
 104
 105 static bool_t new_start = 1;
 106 static char *oldkey = NULL;
 107 static int oldkeylen = 0;
 108
 109
 110 enum nss_status
 111 _nss_nis_sethostent (int stayopen)
 112 {
 113   __libc_lock_lock (lock);
 114
 115   new_start = 1;
 116   if (oldkey != NULL)
 117     {
 118       free (oldkey);
 119       oldkey = NULL;
 120       oldkeylen = 0;
 121     }
 122
 123   __libc_lock_unlock (lock);
 124
 125   return NSS_STATUS_SUCCESS;
 126 }
 127 /* Make _nss_nis_endhostent an alias of _nss_nis_sethostent.  We do this
 128    even though the prototypes don't match.  The argument of sethostent
 129    is used so this makes no difference.  */
 130 strong_alias (_nss_nis_sethostent, _nss_nis_endhostent)
 131
 132
 133 /* The calling function always need to get a lock first. */
 134 static enum nss_status
 135 internal_nis_gethostent_r (struct hostent *host, char *buffer,
 136                            size_t buflen, int *errnop, int *h_errnop,
 137                            int af, int flags)
 138 {
 139   char *domain;
 140   if (__builtin_expect (yp_get_default_domain (&domain), 0))
 141     return NSS_STATUS_UNAVAIL;
 142
 143   uintptr_t pad = -(uintptr_t) buffer % __alignof__ (struct parser_data);
 144   buffer += pad;
 145
 146   struct parser_data *data = (void *) buffer;
 147   if (__builtin_expect (buflen < sizeof *data + 1 + pad, 0))
 148     {
 149       *errnop = ERANGE;
 150       *h_errnop = NETDB_INTERNAL;
 151       return NSS_STATUS_TRYAGAIN;
 152     }
 153   buflen -= pad;
 154
 155   /* Get the next entry until we found a correct one. */
 156   const size_t linebuflen = buffer + buflen - data->linebuffer;
 157   int parse_res;
 158   do
 159     {
 160       char *result;
 161       int len;
 162       char *outkey;
 163       int keylen;
 164       int yperr;
 165       if (new_start)
 166         yperr = yp_first (domain, "hosts.byname", &outkey, &keylen, &result,
 167                           &len);
 168       else
 169         yperr = yp_next (domain, "hosts.byname", oldkey, oldkeylen, &outkey,
 170                          &keylen, &result, &len);
 171
 172       if (__builtin_expect (yperr != YPERR_SUCCESS, 0))
 173         {
 174           enum nss_status retval = yperr2nss (yperr);
 175
 176           switch (retval)
 177             {
 178             case NSS_STATUS_TRYAGAIN:
 179               *errnop = errno;
 180               *h_errnop = TRY_AGAIN;
 181               break;
 182             case NSS_STATUS_NOTFOUND:
 183               *h_errnop = HOST_NOT_FOUND;
 184               break;
 185             default:
 186               *h_errnop = NO_RECOVERY;
 187               break;
 188             }
 189           return retval;
 190         }
 191
 192       if (__builtin_expect ((size_t) (len + 1) > linebuflen, 0))
 193         {
 194           free (result);
 195           *h_errnop = NETDB_INTERNAL;
 196           *errnop = ERANGE;
 197           return NSS_STATUS_TRYAGAIN;
 198         }
 199
 200       char *p = strncpy (data->linebuffer, result, len);
 201       data->linebuffer[len] = '\0';
 202       while (isspace (*p))
 203         ++p;
 204       free (result);
 205
 206       parse_res = parse_line (p, host, data, buflen, errnop, af, flags);
 207       if (__builtin_expect (parse_res == -1, 0))
 208         {
 209           free (outkey);
 210           *h_errnop = NETDB_INTERNAL;
 211           *errnop = ERANGE;
 212           return NSS_STATUS_TRYAGAIN;
 213         }
 214       free (oldkey);
 215       oldkey = outkey;
 216       oldkeylen = keylen;
 217       new_start = 0;
 218     }
 219   while (!parse_res);
 220
 221   *h_errnop = NETDB_SUCCESS;
 222   return NSS_STATUS_SUCCESS;
 223 }
 224
 225
 226 enum nss_status
 227 _nss_nis_gethostent_r (struct hostent *host, char *buffer, size_t buflen,
 228                        int *errnop, int *h_errnop)
 229 {
 230   enum nss_status status;
 231
 232   __libc_lock_lock (lock);
 233
 234   status = internal_nis_gethostent_r (host, buffer, buflen, errnop, h_errnop,
 235                         ((_res.options & RES_USE_INET6) ? AF_INET6 : AF_INET),
 236                         ((_res.options & RES_USE_INET6) ? AI_V4MAPPED : 0 ));
 237
 238   __libc_lock_unlock (lock);
 239
 240   return status;
 241 }
 242
 243
 244 static enum nss_status
 245 internal_gethostbyname2_r (const char *name, int af, struct hostent *host,
 246                            char *buffer, size_t buflen, int *errnop,
 247                            int *h_errnop, int flags)
 248 {
 249   uintptr_t pad = -(uintptr_t) buffer % __alignof__ (struct parser_data);
 250   buffer += pad;
 251
 252   struct parser_data *data = (void *) buffer;
 253
 254   if (name == NULL)
 255     {
 256       *errnop = EINVAL;
 257       return NSS_STATUS_UNAVAIL;
 258     }
 259
 260   char *domain;
 261   if (yp_get_default_domain (&domain))
 262     return NSS_STATUS_UNAVAIL;
 263
 264   if (buflen < sizeof *data + 1 + pad)
 265     {
 266       *h_errnop = NETDB_INTERNAL;
 267       *errnop = ERANGE;
 268       return NSS_STATUS_TRYAGAIN;
 269     }
 270   buflen -= pad;
 271
 272   /* Convert name to lowercase.  */
 273   size_t namlen = strlen (name);
 274   char name2[namlen + 1];
 275   size_t i;
 276
 277   for (i = 0; i < namlen; ++i)
 278     name2[i] = tolower (name[i]);
 279   name2[i] = '\0';
 280
 281   char *result;
 282   int len;
 283   int yperr = yp_match (domain, "hosts.byname", name2, namlen, &result, &len);
 284
 285   if (__builtin_expect (yperr != YPERR_SUCCESS, 0))
 286     {
 287       enum nss_status retval = yperr2nss (yperr);
 288
 289       if (retval == NSS_STATUS_TRYAGAIN)
 290         {
 291           *h_errnop = TRY_AGAIN;
 292           *errnop = errno;
 293         }
 294       if (retval == NSS_STATUS_NOTFOUND)
 295         *h_errnop = HOST_NOT_FOUND;
 296       return retval;
 297     }
 298
 299   const size_t linebuflen = buffer + buflen - data->linebuffer;
 300   if (__builtin_expect ((size_t) (len + 1) > linebuflen, 0))
 301     {
 302       free (result);
 303       *h_errnop = NETDB_INTERNAL;
 304       *errnop = ERANGE;
 305       return NSS_STATUS_TRYAGAIN;
 306     }
 307
 308   char *p = strncpy (data->linebuffer, result, len);
 309   data->linebuffer[len] = '\0';
 310   while (isspace (*p))
 311     ++p;
 312   free (result);
 313
 314   int parse_res = parse_line (p, host, data, buflen, errnop, af, flags);
 315
 316   if (__builtin_expect (parse_res < 1 || host->h_addrtype != af, 0))
 317     {
 318       if (parse_res == -1)
 319         {
 320           *h_errnop = NETDB_INTERNAL;
 321           return NSS_STATUS_TRYAGAIN;
 322         }
 323       else
 324         {
 325           *h_errnop = HOST_NOT_FOUND;
 326           return NSS_STATUS_NOTFOUND;
 327         }
 328     }
 329
 330   *h_errnop = NETDB_SUCCESS;
 331   return NSS_STATUS_SUCCESS;
 332 }
 333
 334
 335 enum nss_status
 336 _nss_nis_gethostbyname2_r (const char *name, int af, struct hostent *host,
 337                            char *buffer, size_t buflen, int *errnop,
 338                            int *h_errnop)
 339 {
 340   if (af != AF_INET && af != AF_INET6)
 341     {
 342       *h_errnop = HOST_NOT_FOUND;
 343       return NSS_STATUS_NOTFOUND;
 344     }
 345
 346   return internal_gethostbyname2_r (name, af, host, buffer, buflen, errnop,
 347                                     h_errnop,
 348                         ((_res.options & RES_USE_INET6) ? AI_V4MAPPED : 0));
 349 }
 350
 351
 352 enum nss_status
 353 _nss_nis_gethostbyname_r (const char *name, struct hostent *host, char *buffer,
 354                           size_t buflen, int *errnop, int *h_errnop)
 355 {
 356   if (_res.options & RES_USE_INET6)
 357     {
 358       enum nss_status status;
 359
 360       status = internal_gethostbyname2_r (name, AF_INET6, host, buffer, buflen,
 361                                           errnop, h_errnop, AI_V4MAPPED);
 362       if (status == NSS_STATUS_SUCCESS)
 363         return status;
 364     }
 365
 366   return internal_gethostbyname2_r (name, AF_INET, host, buffer, buflen,
 367                                     errnop, h_errnop, 0);
 368 }
 369
 370
 371 enum nss_status
 372 _nss_nis_gethostbyaddr_r (const void *addr, socklen_t addrlen, int af,
 373                           struct hostent *host, char *buffer, size_t buflen,
 374                           int *errnop, int *h_errnop)
 375 {
 376   char *domain;
 377   if (__builtin_expect (yp_get_default_domain (&domain), 0))
 378     return NSS_STATUS_UNAVAIL;
 379
 380   uintptr_t pad = -(uintptr_t) buffer % __alignof__ (struct parser_data);
 381   buffer += pad;
 382
 383   struct parser_data *data = (void *) buffer;
 384   if (__builtin_expect (buflen < sizeof *data + 1 + pad, 0))
 385     {
 386       *errnop = ERANGE;
 387       *h_errnop = NETDB_INTERNAL;
 388       return NSS_STATUS_TRYAGAIN;
 389     }
 390   buflen -= pad;
 391
 392   char *buf = inet_ntoa (*(const struct in_addr *) addr);
 393
 394   char *result;
 395   int len;
 396   int yperr = yp_match (domain, "hosts.byaddr", buf, strlen (buf), &result,
 397                         &len);
 398
 399   if (__builtin_expect (yperr != YPERR_SUCCESS, 0))
 400     {
 401       enum nss_status retval = yperr2nss (yperr);
 402
 403       if (retval == NSS_STATUS_TRYAGAIN)
 404         {
 405           *h_errnop = TRY_AGAIN;
 406           *errnop = errno;
 407         }
 408       else if (retval == NSS_STATUS_NOTFOUND)
 409         *h_errnop = HOST_NOT_FOUND;
 410
 411       return retval;
 412     }
 413
 414   const size_t linebuflen = buffer + buflen - data->linebuffer;
 415   if (__builtin_expect ((size_t) (len + 1) > linebuflen, 0))
 416     {
 417       free (result);
 418       *errnop = ERANGE;
 419       *h_errnop = NETDB_INTERNAL;
 420       return NSS_STATUS_TRYAGAIN;
 421     }
 422
 423   char *p = strncpy (data->linebuffer, result, len);
 424   data->linebuffer[len] = '\0';
 425   while (isspace (*p))
 426     ++p;
 427   free (result);
 428
 429   int parse_res = parse_line (p, host, data, buflen, errnop, af,
 430                               ((_res.options & RES_USE_INET6)
 431                                ? AI_V4MAPPED : 0));
 432   if (__builtin_expect (parse_res < 1, 0))
 433     {
 434       if (parse_res == -1)
 435         {
 436           *h_errnop = NETDB_INTERNAL;
 437           return NSS_STATUS_TRYAGAIN;
 438         }
 439       else
 440         {
 441           *h_errnop = HOST_NOT_FOUND;
 442           return NSS_STATUS_NOTFOUND;
 443         }
 444     }
 445
 446   *h_errnop = NETDB_SUCCESS;
 447   return NSS_STATUS_SUCCESS;
 448 }
 449
 450
 451 enum nss_status
 452 _nss_nis_gethostbyname4_r (const char *name, struct gaih_addrtuple **pat,
 453                            char *buffer, size_t buflen, int *errnop,
 454                            int *herrnop, int32_t *ttlp)
 455 {
 456   char *domain;
 457   if (yp_get_default_domain (&domain))
 458     {
 459       *herrnop = NO_DATA;
 460       return NSS_STATUS_UNAVAIL;
 461     }
 462
 463   /* Convert name to lowercase.  */
 464   size_t namlen = strlen (name);
 465   char name2[namlen + 1];
 466   size_t i;
 467
 468   for (i = 0; i < namlen; ++i)
 469     name2[i] = tolower (name[i]);
 470   name2[i] = '\0';
 471
 472   char *result;
 473   int len;
 474   int yperr = yp_match (domain, "hosts.byname", name2, namlen, &result, &len);
 475
 476   if (__builtin_expect (yperr != YPERR_SUCCESS, 0))
 477     {
 478       enum nss_status retval = yperr2nss (yperr);
 479
 480       if (retval == NSS_STATUS_TRYAGAIN)
 481         {
 482           *herrnop = TRY_AGAIN;
 483           *errnop = errno;
 484         }
 485       if (retval == NSS_STATUS_NOTFOUND)
 486         *herrnop = HOST_NOT_FOUND;
 487       return retval;
 488     }
 489
 490   if (*pat == NULL)
 491     {
 492       uintptr_t pad = (-(uintptr_t) buffer
 493                        % __alignof__ (struct gaih_addrtuple));
 494       buffer += pad;
 495       buflen = buflen > pad ? buflen - pad : 0;
 496
 497       if (__builtin_expect (buflen < sizeof (struct gaih_addrtuple), 0))
 498         {
 499         erange:
 500           free (result);
 501           *errnop = ERANGE;
 502           *herrnop = NETDB_INTERNAL;
 503           return NSS_STATUS_TRYAGAIN;
 504         }
 505
 506       *pat = (struct gaih_addrtuple *) buffer;
 507       buffer += sizeof (struct gaih_addrtuple);
 508       buflen -= sizeof (struct gaih_addrtuple);
 509     }
 510
 511   uintptr_t pad = -(uintptr_t) buffer % __alignof__ (struct parser_data);
 512   buffer += pad;
 513
 514   struct parser_data *data = (void *) buffer;
 515
 516   if (__builtin_expect (buflen < sizeof *data + 1 + pad, 0))
 517     goto erange;
 518   buflen -= pad;
 519
 520   struct hostent host;
 521   int parse_res = parse_line (result, &host, data, buflen, errnop, AF_UNSPEC,
 522                               0);
 523   if (__builtin_expect (parse_res < 1, 0))
 524     {
 525       if (parse_res == -1)
 526         {
 527           *herrnop = NETDB_INTERNAL;
 528           return NSS_STATUS_TRYAGAIN;
 529         }
 530       else
 531         {
 532           *herrnop = HOST_NOT_FOUND;
 533           return NSS_STATUS_NOTFOUND;
 534         }
 535     }
 536
 537   (*pat)->next = NULL;
 538   (*pat)->family = host.h_addrtype;
 539   memcpy ((*pat)->addr, host.h_addr_list[0], host.h_length);
 540   (*pat)->scopeid = 0;
 541   assert (host.h_addr_list[1] == NULL);
 542
 543   /* Undo the alignment for parser_data.  */
 544   buffer -= pad;
 545   buflen += pad;
 546
 547   size_t h_name_len = strlen (host.h_name) + 1;
 548   if (h_name_len >= buflen)
 549     goto erange;
 550   (*pat)->name = memcpy (buffer, host.h_name, h_name_len);
 551
 552   free (result);
 553
 554   return NSS_STATUS_SUCCESS;
 555 }