nis/nss_nis/nis-hosts.c

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