nis/nss_nisplus/nisplus-hosts.c

   1 /* Copyright (C) 1997-2002, 2003 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Thorsten Kukuk <kukuk@suse.de>, 1997.
   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, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <nss.h>
  21 #include <netdb.h>
  22 #include <errno.h>
  23 #include <ctype.h>
  24 #include <string.h>
  25 #include <netinet/in.h>
  26 #include <arpa/inet.h>
  27 #include <bits/libc-lock.h>
  28 #include <rpcsvc/nis.h>
  29
  30 #include "nss-nisplus.h"
  31
  32 __libc_lock_define_initialized (static, lock)
  33
  34 static nis_result *result;
  35 static nis_name tablename_val;
  36 static u_long tablename_len;
  37
  38 #define NISENTRYVAL(idx,col,res) \
  39         ((res)->objects.objects_val[(idx)].EN_data.en_cols.en_cols_val[(col)].ec_value.ec_value_val)
  40
  41 #define NISENTRYLEN(idx,col,res) \
  42         ((res)->objects.objects_val[(idx)].EN_data.en_cols.en_cols_val[(col)].ec_value.ec_value_len)
  43
  44 /* Get implementation for some internal functions. */
  45 #include <resolv/mapv4v6addr.h>
  46
  47 static int
  48 _nss_nisplus_parse_hostent (nis_result *result, int af, struct hostent *host,
  49                             char *buffer, size_t buflen, int *errnop,
  50                             int flags)
  51 {
  52   unsigned int i;
  53   char *first_unused = buffer;
  54   size_t room_left = buflen;
  55   char *data, *p, *line;
  56
  57   if (result == NULL)
  58     return 0;
  59
  60   if ((result->status != NIS_SUCCESS && result->status != NIS_S_SUCCESS) ||
  61       __type_of (result->objects.objects_val) != NIS_ENTRY_OBJ ||
  62       strcmp(result->objects.objects_val[0].EN_data.en_type,
  63              "hosts_tbl") != 0 ||
  64       result->objects.objects_val[0].EN_data.en_cols.en_cols_len < 4)
  65     return 0;
  66
  67   if (room_left < NISENTRYLEN (0, 2, result) + 1)
  68     {
  69     no_more_room:
  70       *errnop = ERANGE;
  71       return -1;
  72     }
  73
  74   data = first_unused;
  75
  76   /* Parse address.  */
  77   if (af == AF_INET && inet_pton (af, NISENTRYVAL (0, 2, result), data) > 0)
  78     {
  79       if (flags & AI_V4MAPPED)
  80         {
  81           map_v4v6_address (data, data);
  82           host->h_addrtype = AF_INET6;
  83           host->h_length = IN6ADDRSZ;
  84         }
  85       else
  86         {
  87           host->h_addrtype = AF_INET;
  88           host->h_length = INADDRSZ;
  89         }
  90     }
  91   else if (af == AF_INET6
  92            && inet_pton (AF_INET6, NISENTRYVAL (0, 2, result), data) > 0)
  93     {
  94       host->h_addrtype = AF_INET6;
  95       host->h_length = IN6ADDRSZ;
  96     }
  97   else
  98     /* Illegal address: ignore line.  */
  99     return 0;
 100
 101   first_unused+=host->h_length;
 102   room_left-=host->h_length;
 103
 104   if (NISENTRYLEN (0, 0, result) + 1 > room_left)
 105     goto no_more_room;
 106
 107   p = __stpncpy (first_unused, NISENTRYVAL (0, 0, result),
 108                  NISENTRYLEN (0, 0, result));
 109   *p = '\0';
 110   room_left -= (NISENTRYLEN (0, 0, result) + 1);
 111   host->h_name = first_unused;
 112   first_unused += NISENTRYLEN (0, 0, result) +1;
 113   p = first_unused;
 114
 115   line = p;
 116   for (i = 0; i < result->objects.objects_len; ++i)
 117     {
 118       if (strcmp (NISENTRYVAL (i, 1, result), host->h_name) != 0)
 119         {
 120           if (NISENTRYLEN (i, 1, result) + 2 > room_left)
 121             goto no_more_room;
 122
 123           *p++ = ' ';
 124           p = __stpncpy (p, NISENTRYVAL (i, 1, result),
 125                          NISENTRYLEN (i, 1, result));
 126           *p = '\0';
 127           room_left -= (NISENTRYLEN (i, 1, result) + 1);
 128         }
 129     }
 130   *p++ = '\0';
 131   first_unused = p;
 132
 133   /* Adjust the pointer so it is aligned for
 134      storing pointers.  */
 135   first_unused += __alignof__ (char *) - 1;
 136   first_unused -= ((first_unused - (char *) 0) % __alignof__ (char *));
 137   host->h_addr_list = (char **) first_unused;
 138   if (room_left < 2 * sizeof (char *))
 139     goto no_more_room;
 140
 141   room_left -= (2 * sizeof (char *));
 142   host->h_addr_list[0] = data;
 143   host->h_addr_list[1] = NULL;
 144   host->h_aliases = &host->h_addr_list[2];
 145   host->h_aliases[0] = NULL;
 146
 147   i = 0;
 148   while (*line != '\0')
 149     {
 150       /* Skip leading blanks.  */
 151       while (isspace (*line))
 152         ++line;
 153
 154       if (*line == '\0')
 155         break;
 156
 157       if (room_left < sizeof (char *))
 158         goto no_more_room;
 159
 160       room_left -= sizeof (char *);
 161       host->h_aliases[i] = line;
 162
 163       while (*line != '\0' && *line != ' ')
 164         ++line;
 165
 166       if (*line == ' ')
 167         {
 168           *line = '\0';
 169           ++line;
 170           ++i;
 171         }
 172       else
 173         host->h_aliases[i+1] = NULL;
 174     }
 175   return 1;
 176 }
 177
 178 static enum nss_status
 179 _nss_create_tablename (int *errnop)
 180 {
 181   if (tablename_val == NULL)
 182     {
 183       char buf [40 + strlen (nis_local_directory ())];
 184       char *p;
 185
 186       p = __stpcpy (buf, "hosts.org_dir.");
 187       p = __stpcpy (p, nis_local_directory ());
 188       tablename_val = __strdup (buf);
 189       if (tablename_val == NULL)
 190         {
 191           *errnop = errno;
 192           return NSS_STATUS_TRYAGAIN;
 193         }
 194       tablename_len = strlen (tablename_val);
 195     }
 196   return NSS_STATUS_SUCCESS;
 197 }
 198
 199 enum nss_status
 200 _nss_nisplus_sethostent (int stayopen)
 201 {
 202   enum nss_status status = NSS_STATUS_SUCCESS;
 203   int err;
 204
 205   __libc_lock_lock (lock);
 206
 207   if (result)
 208     nis_freeresult (result);
 209   result = NULL;
 210
 211   if (tablename_val == NULL)
 212     status = _nss_create_tablename (&err);
 213
 214   __libc_lock_unlock (lock);
 215
 216   return status;
 217 }
 218
 219 enum nss_status
 220 _nss_nisplus_endhostent (void)
 221 {
 222   __libc_lock_lock (lock);
 223
 224   if (result)
 225     nis_freeresult (result);
 226   result = NULL;
 227
 228   __libc_lock_unlock (lock);
 229
 230   return NSS_STATUS_SUCCESS;
 231 }
 232
 233 static enum nss_status
 234 internal_nisplus_gethostent_r (struct hostent *host, char *buffer,
 235                                size_t buflen, int *errnop, int *herrnop)
 236 {
 237   int parse_res;
 238
 239   /* Get the next entry until we found a correct one. */
 240   do
 241     {
 242       nis_result *saved_res;
 243
 244       if (result == NULL)
 245         {
 246           saved_res = NULL;
 247           if (tablename_val == NULL)
 248             {
 249               enum nss_status status = _nss_create_tablename (errnop);
 250
 251               if (status != NSS_STATUS_SUCCESS)
 252                 return status;
 253             }
 254
 255           result = nis_first_entry (tablename_val);
 256           if (niserr2nss (result->status) != NSS_STATUS_SUCCESS)
 257             {
 258               enum nss_status retval = niserr2nss (result->status);
 259               if (retval == NSS_STATUS_TRYAGAIN)
 260                 {
 261                   *herrnop = NETDB_INTERNAL;
 262                   *errnop = errno;
 263                 }
 264               return retval;
 265             }
 266
 267         }
 268       else
 269         {
 270           nis_result *res2;
 271
 272           saved_res = result;
 273           res2 = nis_next_entry(tablename_val, &result->cookie);
 274           result = res2;
 275           if (niserr2nss (result->status) != NSS_STATUS_SUCCESS)
 276             {
 277               enum nss_status retval= niserr2nss (result->status);
 278
 279               nis_freeresult (result);
 280               result = saved_res;
 281               if (retval == NSS_STATUS_TRYAGAIN)
 282                 {
 283                   *herrnop = NETDB_INTERNAL;
 284                   *errnop = errno;
 285                 }
 286               return retval;
 287             }
 288         }
 289
 290       if (_res.options & RES_USE_INET6)
 291         parse_res = _nss_nisplus_parse_hostent (result, AF_INET6, host, buffer,
 292                                                 buflen, errnop, AI_V4MAPPED);
 293       else
 294         parse_res = _nss_nisplus_parse_hostent (result, AF_INET, host, buffer,
 295                                                 buflen, errnop, 0);
 296
 297       if (parse_res == -1)
 298         {
 299           nis_freeresult (result);
 300           result = saved_res;
 301           *herrnop = NETDB_INTERNAL;
 302           *errnop = ERANGE;
 303           return NSS_STATUS_TRYAGAIN;
 304         }
 305       if (saved_res != NULL)
 306         nis_freeresult (saved_res);
 307
 308     } while (!parse_res);
 309
 310   return NSS_STATUS_SUCCESS;
 311 }
 312
 313 enum nss_status
 314 _nss_nisplus_gethostent_r (struct hostent *result, char *buffer,
 315                            size_t buflen, int *errnop, int *herrnop)
 316 {
 317   int status;
 318
 319   __libc_lock_lock (lock);
 320
 321   status = internal_nisplus_gethostent_r (result, buffer, buflen, errnop,
 322                                           herrnop);
 323
 324   __libc_lock_unlock (lock);
 325
 326   return status;
 327 }
 328
 329 static enum nss_status
 330 internal_gethostbyname2_r (const char *name, int af, struct hostent *host,
 331                            char *buffer, size_t buflen, int *errnop,
 332                            int *herrnop, int flags)
 333 {
 334   int parse_res, retval;
 335
 336   if (tablename_val == NULL)
 337     {
 338       enum nss_status status = _nss_create_tablename (errnop);
 339
 340       if (status != NSS_STATUS_SUCCESS)
 341         {
 342           *herrnop = NETDB_INTERNAL;
 343           return NSS_STATUS_UNAVAIL;
 344         }
 345     }
 346
 347   if (name == NULL)
 348     {
 349       *errnop = EINVAL;
 350       *herrnop = NETDB_INTERNAL;
 351       return NSS_STATUS_NOTFOUND;
 352     }
 353   else
 354     {
 355       nis_result *result;
 356       char buf[strlen (name) + 255 + tablename_len];
 357       int olderr = errno;
 358
 359       /* Search at first in the alias list, and use the correct name
 360          for the next search */
 361       sprintf (buf, "[name=%s],%s", name, tablename_val);
 362       result = nis_list (buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
 363
 364       if (result != NULL)
 365         {
 366           /* If we do not find it, try it as original name. But if the
 367              database is correct, we should find it in the first case, too */
 368           if ((result->status != NIS_SUCCESS
 369                && result->status != NIS_S_SUCCESS)
 370               || __type_of (result->objects.objects_val) != NIS_ENTRY_OBJ
 371               || strcmp (result->objects.objects_val->EN_data.en_type,
 372                          "hosts_tbl") != 0
 373               || result->objects.objects_val->EN_data.en_cols.en_cols_len < 3)
 374             sprintf (buf, "[cname=%s],%s", name, tablename_val);
 375           else
 376             sprintf (buf, "[cname=%s],%s", NISENTRYVAL(0, 0, result),
 377                      tablename_val);
 378
 379           nis_freeresult (result);
 380           result = nis_list (buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
 381         }
 382
 383       if (result == NULL)
 384         {
 385           *errnop = ENOMEM;
 386           return NSS_STATUS_TRYAGAIN;
 387         }
 388       retval = niserr2nss (result->status);
 389       if (retval != NSS_STATUS_SUCCESS)
 390         {
 391           if (retval == NSS_STATUS_TRYAGAIN)
 392             {
 393               *errnop = errno;
 394               *herrnop = NETDB_INTERNAL;
 395             }
 396           else
 397             __set_errno (olderr);
 398           nis_freeresult (result);
 399           return retval;
 400         }
 401
 402       parse_res = _nss_nisplus_parse_hostent (result, af, host, buffer,
 403                                               buflen, errnop, flags);
 404
 405       nis_freeresult (result);
 406
 407       if (parse_res > 0)
 408         return NSS_STATUS_SUCCESS;
 409
 410       *herrnop = NETDB_INTERNAL;
 411       if (parse_res == -1)
 412         {
 413           *errnop = ERANGE;
 414           return NSS_STATUS_TRYAGAIN;
 415         }
 416       else
 417         {
 418           __set_errno (olderr);
 419           return NSS_STATUS_NOTFOUND;
 420         }
 421     }
 422 }
 423
 424 enum nss_status
 425 _nss_nisplus_gethostbyname2_r (const char *name, int af, struct hostent *host,
 426                                char *buffer, size_t buflen, int *errnop,
 427                                int *herrnop)
 428 {
 429   return internal_gethostbyname2_r (name, af, host, buffer, buflen, errnop,
 430                                     herrnop,
 431                          ((_res.options & RES_USE_INET6) ? AI_V4MAPPED : 0));
 432 }
 433
 434 #if 0
 435 enum nss_status
 436 _nss_nisplus_getipnodebyname_r (const char *name, int af, int flags,
 437                                 struct hostent *result, char *buffer,
 438                                 size_t buflen, int *errnop, int *herrnop)
 439 {
 440   return internal_gethostbyname2_r (name, af, result, buffer, buflen,
 441                                     errnop, herrnop, flags);
 442 }
 443 #endif
 444
 445 enum nss_status
 446 _nss_nisplus_gethostbyname_r (const char *name, struct hostent *host,
 447                               char *buffer, size_t buflen, int *errnop,
 448                               int *h_errnop)
 449 {
 450   if (_res.options & RES_USE_INET6)
 451     {
 452       enum nss_status status;
 453
 454       status = internal_gethostbyname2_r (name, AF_INET6, host, buffer,
 455                                           buflen, errnop, h_errnop,
 456                                           AI_V4MAPPED);
 457       if (status == NSS_STATUS_SUCCESS)
 458         return status;
 459     }
 460
 461   return internal_gethostbyname2_r (name, AF_INET, host, buffer,
 462                                    buflen, errnop, h_errnop, 0);
 463 }
 464
 465 enum nss_status
 466 _nss_nisplus_gethostbyaddr_r (const void *addr, socklen_t addrlen, int af,
 467                               struct hostent *host, char *buffer,
 468                               size_t buflen, int *errnop, int *herrnop)
 469 {
 470   if (tablename_val == NULL)
 471     {
 472       enum nss_status status = _nss_create_tablename (errnop);
 473
 474       if (status != NSS_STATUS_SUCCESS)
 475         return status;
 476     }
 477
 478   if (addr == NULL)
 479     return NSS_STATUS_NOTFOUND;
 480   else
 481     {
 482       nis_result *result;
 483       char buf[255 + tablename_len];
 484       int retval, parse_res;
 485       int olderr = errno;
 486
 487       sprintf (buf, "[addr=%s],%s",
 488                inet_ntoa (*(const struct in_addr *) addr), tablename_val);
 489       result = nis_list (buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
 490
 491       if (result == NULL)
 492         {
 493           __set_errno (ENOMEM);
 494           return NSS_STATUS_TRYAGAIN;
 495         }
 496       retval = niserr2nss (result->status);
 497       if (retval != NSS_STATUS_SUCCESS)
 498         {
 499           if (retval == NSS_STATUS_TRYAGAIN)
 500             {
 501               *errnop = errno;
 502               *herrnop = NETDB_INTERNAL;
 503             }
 504           else
 505             __set_errno (olderr);
 506           nis_freeresult (result);
 507           return retval;
 508         }
 509
 510       parse_res = _nss_nisplus_parse_hostent (result, af, host,
 511                                               buffer, buflen, errnop,
 512                      ((_res.options & RES_USE_INET6) ? AI_V4MAPPED : 0));
 513       nis_freeresult (result);
 514
 515       if (parse_res > 0)
 516         return NSS_STATUS_SUCCESS;
 517
 518       *herrnop = NETDB_INTERNAL;
 519       if (parse_res == -1)
 520         {
 521           *errnop = ERANGE;
 522           return NSS_STATUS_TRYAGAIN;
 523         }
 524       else
 525         {
 526           __set_errno (olderr);
 527           return NSS_STATUS_NOTFOUND;
 528         }
 529     }
 530 }