nis/nss_nisplus/nisplus-hosts.c

   1 /* Copyright (C) 1997 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.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 Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    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    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 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 <libc-lock.h>
  28 #include <rpcsvc/nis.h>
  29 #include <rpcsvc/nislib.h>
  30
  31 #include "nss-nisplus.h"
  32
  33 __libc_lock_define_initialized (static, lock)
  34
  35 static nis_result *result = NULL;
  36 static nis_name *names = NULL;
  37
  38 #define NISENTRYVAL(idx,col,res) \
  39         ((res)->objects.objects_val[(idx)].zo_data.objdata_u.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)].zo_data.objdata_u.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 #include "../../resolv/mapv4v6hostent.h"
  47
  48 #define ENTNAME         hostent
  49 #define DATABASE        "hosts"
  50 #define NEED_H_ERRNO
  51
  52 #define ENTDATA hostent_data
  53 struct hostent_data
  54   {
  55     unsigned char host_addr[16];        /* IPv4 or IPv6 address.  */
  56     char *h_addr_ptrs[2];       /* Points to that and null terminator.  */
  57   };
  58
  59 #define TRAILING_LIST_MEMBER            h_aliases
  60 #define TRAILING_LIST_SEPARATOR_P       isspace
  61 #include "../../nss/nss_files/files-parse.c"
  62 LINE_PARSER
  63 ("#",
  64  {
  65    char *addr;
  66
  67    STRING_FIELD (addr, isspace, 1);
  68
  69    /* Parse address.  */
  70    if ((_res.options & RES_USE_INET6)
  71        && inet_pton (AF_INET6, addr, entdata->host_addr) > 0)
  72      {
  73        result->h_addrtype = AF_INET6;
  74        result->h_length = IN6ADDRSZ;
  75      }
  76    else
  77      if (inet_pton (AF_INET, addr, entdata->host_addr) > 0)
  78        {
  79          if (_res.options & RES_USE_INET6)
  80            {
  81              map_v4v6_address ((char *) entdata->host_addr,
  82                                (char *) entdata->host_addr);
  83              result->h_addrtype = AF_INET6;
  84              result->h_length = IN6ADDRSZ;
  85            }
  86          else
  87            {
  88              result->h_addrtype = AF_INET;
  89              result->h_length = INADDRSZ;
  90            }
  91        }
  92      else
  93        /* Illegal address: ignore line.  */
  94        return 0;
  95
  96    /* Store a pointer to the address in the expected form.  */
  97    entdata->h_addr_ptrs[0] = entdata->host_addr;
  98    entdata->h_addr_ptrs[1] = NULL;
  99    result->h_addr_list = entdata->h_addr_ptrs;
 100
 101    /* If we need the host entry in IPv6 form change it now.  */
 102    if (_res.options & RES_USE_INET6)
 103      {
 104         char *bufptr = data->linebuffer;
 105        size_t buflen = (char *) data + datalen - bufptr;
 106        map_v4v6_hostent (result, &bufptr, &buflen);
 107      }
 108
 109    STRING_FIELD (result->h_name, isspace, 1);
 110  }
 111 )
 112
 113
 114 static int
 115 _nss_nisplus_parse_hostent (nis_result *result, struct hostent *host,
 116                             char *buffer, size_t buflen)
 117 {
 118   char *p = buffer;
 119   size_t room_left = buflen;
 120   int parse_res;
 121   unsigned int i;
 122   struct parser_data *data = (void *) buffer;
 123
 124   if (result == NULL)
 125     return 0;
 126
 127   if ((result->status != NIS_SUCCESS && result->status != NIS_S_SUCCESS) ||
 128       result->objects.objects_val[0].zo_data.zo_type != ENTRY_OBJ ||
 129       strcmp(result->objects.objects_val[0].zo_data.objdata_u.en_data.en_type,
 130              "hosts_tbl") != 0 ||
 131       result->objects.objects_val[0].zo_data.objdata_u.en_data.en_cols.en_cols_len < 4)
 132     return 0;
 133
 134   memset (p, '\0', room_left);
 135
 136   /* Generate the hosts entry format and use the normal parser */
 137   if (NISENTRYLEN (0, 2, result) + 1 > room_left)
 138     {
 139       __set_errno (ERANGE);
 140       return 0;
 141     }
 142   strncpy (p, NISENTRYVAL (0, 2, result),
 143            NISENTRYLEN (0, 2, result));
 144   room_left -= (NISENTRYLEN (0, 2, result) + 1);
 145
 146   if (NISENTRYLEN (0, 0, result) + 1 > room_left)
 147     {
 148       __set_errno (ERANGE);
 149       return 0;
 150     }
 151   strcat (p, "\t");
 152   strncat (p, NISENTRYVAL (0, 0, result), NISENTRYLEN (0, 0, result));
 153   room_left -= (NISENTRYLEN (0, 0, result) + 1);
 154                                        /* + 1: We overwrite the last \0 */
 155
 156   for (i = 1; i < result->objects.objects_len; i++)
 157     {
 158       if (NISENTRYLEN (i, 1, result) + 1 > room_left)
 159         {
 160           __set_errno (ERANGE);
 161           return 0;
 162         }
 163       strcat (p, " ");
 164       strcat (p, NISENTRYVAL (i, 1, result));
 165       room_left -= (NISENTRYLEN (i, 1, result) + 1);
 166     }
 167
 168   parse_res = parse_line (p, host, data, buflen);
 169
 170   return parse_res;
 171 }
 172
 173 enum nss_status
 174 _nss_nisplus_sethostent (void)
 175 {
 176   __libc_lock_lock (lock);
 177
 178   if (result)
 179     nis_freeresult (result);
 180   result = NULL;
 181   if (names)
 182     {
 183       nis_freenames (names);
 184       names = NULL;
 185     }
 186
 187   __libc_lock_unlock (lock);
 188
 189   return NSS_STATUS_SUCCESS;
 190 }
 191
 192 enum nss_status
 193 _nss_nisplus_endhostent (void)
 194 {
 195   __libc_lock_lock (lock);
 196
 197   if (result)
 198     nis_freeresult (result);
 199   result = NULL;
 200   if (names)
 201     {
 202       nis_freenames (names);
 203       names = NULL;
 204     }
 205
 206   __libc_lock_unlock (lock);
 207
 208   return NSS_STATUS_SUCCESS;
 209 }
 210
 211 static enum nss_status
 212 internal_nisplus_gethostent_r (struct hostent *host, char *buffer,
 213                                size_t buflen, int *herrnop)
 214 {
 215   int parse_res;
 216
 217   /* Get the next entry until we found a correct one. */
 218   do
 219     {
 220       if (result == NULL)
 221         {
 222           names = nis_getnames("hosts.org_dir");
 223           if (names == NULL || names[0] == NULL)
 224             return NSS_STATUS_UNAVAIL;
 225
 226           result = nis_first_entry(names[0]);
 227           if (niserr2nss (result->status) != NSS_STATUS_SUCCESS)
 228             {
 229               int retval;
 230
 231               retval = niserr2nss (result->status);
 232               if (retval == NSS_STATUS_TRYAGAIN)
 233                 {
 234                   *herrnop = NETDB_INTERNAL;
 235                   __set_errno (EAGAIN);
 236                 }
 237               return retval;
 238             }
 239
 240         }
 241       else
 242         {
 243           nis_result *res2;
 244
 245           res2 = nis_next_entry(names[0], &result->cookie);
 246           nis_freeresult (result);
 247           result = res2;
 248           if (niserr2nss (result->status) != NSS_STATUS_SUCCESS)
 249             {
 250               int retval;
 251
 252               retval = niserr2nss (result->status);
 253               if (retval == NSS_STATUS_TRYAGAIN)
 254                 {
 255                   *herrnop = NETDB_INTERNAL;
 256                   __set_errno (EAGAIN);
 257                 }
 258               return retval;
 259             }
 260         }
 261
 262       parse_res = _nss_nisplus_parse_hostent (result, host, buffer, buflen);
 263       if (!parse_res && errno == ERANGE)
 264         {
 265           *herrnop = NETDB_INTERNAL;
 266           return NSS_STATUS_TRYAGAIN;
 267         }
 268
 269     } while (!parse_res);
 270
 271   return NSS_STATUS_SUCCESS;
 272 }
 273
 274 enum nss_status
 275 _nss_nisplus_gethostent_r (struct hostent *result, char *buffer,
 276                            size_t buflen, int *herrnop)
 277 {
 278   int status;
 279
 280   __libc_lock_lock (lock);
 281
 282   status = internal_nisplus_gethostent_r (result, buffer, buflen, herrnop);
 283
 284   __libc_lock_unlock (lock);
 285
 286   return status;
 287 }
 288
 289 enum nss_status
 290 _nss_nisplus_gethostbyname2_r (const char *name, int af, struct hostent *host,
 291                               char *buffer, size_t buflen, int *herrnop)
 292 {
 293   int parse_res, retval;
 294
 295   if (name == NULL)
 296     {
 297       __set_errno (EINVAL);
 298       *herrnop = NETDB_INTERNAL;
 299       return NSS_STATUS_NOTFOUND;
 300     }
 301   else
 302     {
 303       nis_result *result;
 304       char buf[strlen (name) + 255];
 305
 306       /* Search at first in the alias list, and use the correct name
 307          for the next search */
 308       sprintf(buf, "[name=%s],hosts.org_dir", name);
 309       result = nis_list(buf, EXPAND_NAME, NULL, NULL);
 310
 311       /* If we do not find it, try it as original name. But if the
 312          database is correct, we should find it in the first case, too */
 313       if ((result->status != NIS_SUCCESS &&
 314            result->status != NIS_S_SUCCESS) ||
 315           result->objects.objects_val[0].zo_data.zo_type != ENTRY_OBJ ||
 316           strcmp(result->objects.objects_val[0].zo_data.objdata_u.en_data.en_type,
 317                  "hosts_tbl") != 0 ||
 318           result->objects.objects_val[0].zo_data.objdata_u.en_data.en_cols.en_cols_len
 319           < 3)
 320         sprintf(buf, "[cname=%s],hosts.org_dir", name);
 321       else
 322         sprintf(buf, "[cname=%s],hosts.org_dir", NISENTRYVAL(0, 0, result));
 323
 324       nis_freeresult (result);
 325       result = nis_list(buf, EXPAND_NAME, NULL, NULL);
 326
 327       retval = niserr2nss (result->status);
 328       if (retval != NSS_STATUS_SUCCESS)
 329         {
 330           if (retval == NSS_STATUS_TRYAGAIN)
 331             {
 332               __set_errno (EAGAIN);
 333               *herrnop = NETDB_INTERNAL;
 334             }
 335           nis_freeresult (result);
 336           return retval;
 337         }
 338
 339       parse_res = _nss_nisplus_parse_hostent (result, host, buffer, buflen);
 340
 341       nis_freeresult (result);
 342
 343       if (parse_res)
 344         return NSS_STATUS_SUCCESS;
 345
 346       *herrnop = NETDB_INTERNAL;
 347       if (!parse_res && errno == ERANGE)
 348         return NSS_STATUS_TRYAGAIN;
 349       else
 350         return NSS_STATUS_NOTFOUND;
 351     }
 352 }
 353
 354 enum nss_status
 355 _nss_nisplus_gethostbyname_r (const char *name, struct hostent *host,
 356                               char *buffer, size_t buflen, int *h_errnop)
 357 {
 358   if (_res.options & RES_USE_INET6)
 359     {
 360       enum nss_status status;
 361
 362       status = _nss_nisplus_gethostbyname2_r (name, AF_INET6, host, buffer,
 363                                               buflen, h_errnop);
 364       if (status == NSS_STATUS_SUCCESS)
 365         return status;
 366     }
 367
 368   return _nss_nisplus_gethostbyname2_r (name, AF_INET, host, buffer,
 369                                         buflen, h_errnop);
 370 }
 371
 372 enum nss_status
 373 _nss_nisplus_gethostbyaddr_r (const char *addr, struct hostent *host,
 374                               char *buffer, size_t buflen, int *herrnop)
 375 {
 376   if (addr == NULL)
 377     return NSS_STATUS_NOTFOUND;
 378   else
 379     {
 380       nis_result *result;
 381       char buf[24 + strlen (addr)];
 382       int retval, parse_res;
 383
 384       sprintf(buf, "[addr=%s],hosts.org_dir", addr);
 385
 386       result = nis_list(buf, EXPAND_NAME, NULL, NULL);
 387
 388       retval = niserr2nss (result->status);
 389       if (retval != NSS_STATUS_SUCCESS)
 390         {
 391           if (retval == NSS_STATUS_TRYAGAIN)
 392             {
 393               __set_errno (EAGAIN);
 394               *herrnop = NETDB_INTERNAL;
 395             }
 396           nis_freeresult (result);
 397           return retval;
 398         }
 399
 400       parse_res = _nss_nisplus_parse_hostent (result, host, buffer, buflen);
 401
 402       nis_freeresult (result);
 403
 404       if (parse_res)
 405         return NSS_STATUS_SUCCESS;
 406
 407       *herrnop = NETDB_INTERNAL;
 408       if (!parse_res && errno == ERANGE)
 409         return NSS_STATUS_TRYAGAIN;
 410       else
 411         return NSS_STATUS_NOTFOUND;
 412     }
 413 }