nis/nss_nisplus/nisplus-ethers.c

   1 /* Copyright (C) 1997,1998,2000-2003,2005,2006 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 <atomic.h>
  21 #include <ctype.h>
  22 #include <errno.h>
  23 #include <inttypes.h>
  24 #include <netdb.h>
  25 #include <nss.h>
  26 #include <string.h>
  27 #include <netinet/ether.h>
  28 #include <netinet/if_ether.h>
  29 #include <rpcsvc/nis.h>
  30 #include <bits/libc-lock.h>
  31
  32 #include "nss-nisplus.h"
  33
  34 __libc_lock_define_initialized (static, lock)
  35
  36 static nis_result *result;
  37 static nis_name tablename_val;
  38 static u_long tablename_len;
  39
  40
  41 #define NISENTRYVAL(idx, col, res) \
  42         (NIS_RES_OBJECT (res)[idx].zo_data.objdata_u.en_data.en_cols.en_cols_val[col].ec_value.ec_value_val)
  43
  44 #define NISENTRYLEN(idx, col, res) \
  45         (NIS_RES_OBJECT (res)[idx].zo_data.objdata_u.en_data.en_cols.en_cols_val[col].ec_value.ec_value_len)
  46
  47 static int
  48 _nss_nisplus_parse_etherent (nis_result *result, struct etherent *ether,
  49                              char *buffer, size_t buflen, int *errnop)
  50 {
  51   char *p = buffer;
  52   size_t room_left = buflen;
  53
  54   if (result == NULL)
  55     return 0;
  56
  57   if ((result->status != NIS_SUCCESS && result->status != NIS_S_SUCCESS)
  58       || NIS_RES_NUMOBJ (result) != 1
  59       || __type_of (NIS_RES_OBJECT (result)) != NIS_ENTRY_OBJ
  60       || strcmp (NIS_RES_OBJECT (result)->EN_data.en_type,
  61                  "ethers_tbl") != 0
  62       || NIS_RES_OBJECT (result)->EN_data.en_cols.en_cols_len < 2)
  63     return 0;
  64
  65   /* Generate the ether entry format and use the normal parser */
  66   if (NISENTRYLEN (0, 0, result) + 1 > room_left)
  67     {
  68       *errnop = ERANGE;
  69       return -1;
  70     }
  71   char *cp = __stpncpy (p, NISENTRYVAL (0, 0, result),
  72                         NISENTRYLEN (0, 0, result));
  73   *cp = '\0';
  74   room_left -= NISENTRYLEN (0, 0, result) + 1;
  75   ether->e_name = p;
  76
  77   struct ether_addr *ea = ether_aton (NISENTRYVAL (0, 1, result));
  78   if (ea == NULL)
  79     {
  80       *errnop = EINVAL;
  81       return -2;
  82     }
  83
  84   ether->e_addr = *ea;
  85
  86   return 1;
  87 }
  88
  89 static enum nss_status
  90 _nss_create_tablename (int *errnop)
  91 {
  92   if (tablename_val == NULL)
  93     {
  94       const char *local_dir = nis_local_directory ();
  95       size_t local_dir_len = strlen (local_dir);
  96       static const char prefix[] = "ethers.org_dir.";
  97
  98       char *p = malloc (sizeof (prefix) + local_dir_len);
  99       if (p == NULL)
 100         {
 101           *errnop = errno;
 102           return NSS_STATUS_TRYAGAIN;
 103         }
 104
 105       memcpy (__stpcpy (p, prefix), local_dir, local_dir_len + 1);
 106
 107       tablename_len = sizeof (prefix) - 1 + local_dir_len;
 108
 109       atomic_write_barrier ();
 110
 111       tablename_val = p;
 112     }
 113   return NSS_STATUS_SUCCESS;
 114 }
 115
 116
 117 enum nss_status
 118 _nss_nisplus_setetherent (int stayopen)
 119 {
 120   enum nss_status status;
 121   int err;
 122
 123   status = NSS_STATUS_SUCCESS;
 124
 125   __libc_lock_lock (lock);
 126
 127   if (result != NULL)
 128     {
 129       nis_freeresult (result);
 130       result = NULL;
 131     }
 132
 133   if (_nss_create_tablename (&err) != NSS_STATUS_SUCCESS)
 134     status = NSS_STATUS_UNAVAIL;
 135
 136   __libc_lock_unlock (lock);
 137
 138   return NSS_STATUS_SUCCESS;
 139 }
 140
 141 enum nss_status
 142 _nss_nisplus_endetherent (void)
 143 {
 144   __libc_lock_lock (lock);
 145
 146   if (result != NULL)
 147     {
 148       nis_freeresult (result);
 149       result = NULL;
 150     }
 151
 152   __libc_lock_unlock (lock);
 153
 154   return NSS_STATUS_SUCCESS;
 155 }
 156
 157 static enum nss_status
 158 internal_nisplus_getetherent_r (struct etherent *ether, char *buffer,
 159                                 size_t buflen, int *errnop)
 160 {
 161   if (tablename_val == NULL)
 162     {
 163       enum nss_status status = _nss_create_tablename (errnop);
 164
 165       if (status != NSS_STATUS_SUCCESS)
 166         return status;
 167     }
 168
 169   /* Get the next entry until we found a correct one. */
 170   int parse_res;
 171   do
 172     {
 173       nis_result *saved_result;
 174
 175       if (result == NULL)
 176         {
 177           saved_result = NULL;
 178           result = nis_first_entry (tablename_val);
 179           if (result == NULL)
 180             {
 181               *errnop = errno;
 182               return NSS_STATUS_TRYAGAIN;
 183             }
 184           if (niserr2nss (result->status) != NSS_STATUS_SUCCESS)
 185             return niserr2nss (result->status);
 186         }
 187       else
 188         {
 189           saved_result = result;
 190           result = nis_next_entry (tablename_val, &result->cookie);
 191           if (result == NULL)
 192             {
 193               *errnop = errno;
 194               return NSS_STATUS_TRYAGAIN;
 195             }
 196           if (niserr2nss (result->status) != NSS_STATUS_SUCCESS)
 197             {
 198               nis_freeresult (saved_result);
 199               return niserr2nss (result->status);
 200             }
 201         }
 202
 203       parse_res = _nss_nisplus_parse_etherent (result, ether, buffer,
 204                                                buflen, errnop);
 205       if (parse_res == -1)
 206         {
 207           nis_freeresult (result);
 208           result = saved_result;
 209           return NSS_STATUS_TRYAGAIN;
 210         }
 211
 212       if (saved_result != NULL)
 213         nis_freeresult (saved_result);
 214
 215     }
 216   while (!parse_res);
 217
 218   return NSS_STATUS_SUCCESS;
 219 }
 220
 221 enum nss_status
 222 _nss_nisplus_getetherent_r (struct etherent *result, char *buffer,
 223                             size_t buflen, int *errnop)
 224 {
 225   int status;
 226
 227   __libc_lock_lock (lock);
 228
 229   status = internal_nisplus_getetherent_r (result, buffer, buflen, errnop);
 230
 231   __libc_lock_unlock (lock);
 232
 233   return status;
 234 }
 235
 236 enum nss_status
 237 _nss_nisplus_gethostton_r (const char *name, struct etherent *eth,
 238                            char *buffer, size_t buflen, int *errnop)
 239 {
 240   if (tablename_val == NULL)
 241     {
 242       enum nss_status status = _nss_create_tablename (errnop);
 243
 244       if (status != NSS_STATUS_SUCCESS)
 245         return status;
 246     }
 247
 248   if (name == NULL)
 249     {
 250       *errnop = EINVAL;
 251       return NSS_STATUS_UNAVAIL;
 252     }
 253
 254   char buf[strlen (name) + 9 + tablename_len];
 255   int olderr = errno;
 256
 257   snprintf (buf, sizeof (buf), "[name=%s],%s", name, tablename_val);
 258
 259   nis_result *result = nis_list (buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
 260
 261   if (result == NULL)
 262     {
 263       *errnop = ENOMEM;
 264       return NSS_STATUS_TRYAGAIN;
 265     }
 266
 267   if (__builtin_expect (niserr2nss (result->status) != NSS_STATUS_SUCCESS, 0))
 268     {
 269       enum nss_status status = niserr2nss (result->status);
 270       nis_freeresult (result);
 271       return status;
 272     }
 273
 274   int parse_res = _nss_nisplus_parse_etherent (result, eth, buffer,
 275                                                buflen, errnop);
 276
 277   /* We do not need the lookup result anymore.  */
 278   nis_freeresult (result);
 279
 280   if (__builtin_expect (parse_res < 1, 0))
 281     {
 282       __set_errno (olderr);
 283
 284       if (parse_res == -1)
 285         return NSS_STATUS_TRYAGAIN;
 286
 287       return NSS_STATUS_NOTFOUND;
 288     }
 289
 290   return NSS_STATUS_SUCCESS;
 291 }
 292
 293 enum nss_status
 294 _nss_nisplus_getntohost_r (const struct ether_addr *addr, struct etherent *eth,
 295                            char *buffer, size_t buflen, int *errnop)
 296 {
 297   if (tablename_val == NULL)
 298     {
 299       __libc_lock_lock (lock);
 300
 301       enum nss_status status = _nss_create_tablename (errnop);
 302
 303       __libc_lock_unlock (lock);
 304
 305       if (status != NSS_STATUS_SUCCESS)
 306         return status;
 307     }
 308
 309   if (addr == NULL)
 310     {
 311       *errnop = EINVAL;
 312       return NSS_STATUS_UNAVAIL;
 313     }
 314
 315   char buf[26 + tablename_len];
 316
 317   snprintf (buf, sizeof (buf),
 318             "[addr=%" PRIx8 ":%" PRIx8 ":%" PRIx8 ":%" PRIx8 ":%" PRIx8
 319             ":%" PRIx8 "],%s",
 320             addr->ether_addr_octet[0], addr->ether_addr_octet[1],
 321             addr->ether_addr_octet[2], addr->ether_addr_octet[3],
 322             addr->ether_addr_octet[4], addr->ether_addr_octet[5],
 323             tablename_val);
 324
 325   nis_result *result = nis_list (buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
 326
 327   if (result == NULL)
 328     {
 329       *errnop = ENOMEM;
 330       return NSS_STATUS_TRYAGAIN;
 331     }
 332
 333   if (__builtin_expect (niserr2nss (result->status) != NSS_STATUS_SUCCESS, 0))
 334     {
 335       enum nss_status status = niserr2nss (result->status);
 336       nis_freeresult (result);
 337       return status;
 338     }
 339
 340   int parse_res = _nss_nisplus_parse_etherent (result, eth, buffer,
 341                                                buflen, errnop);
 342
 343   /* We do not need the lookup result anymore.  */
 344   nis_freeresult (result);
 345
 346   if (__builtin_expect (parse_res < 1, 0))
 347     {
 348       if (parse_res == -1)
 349         return NSS_STATUS_TRYAGAIN;
 350
 351       return NSS_STATUS_NOTFOUND;
 352     }
 353
 354   return NSS_STATUS_SUCCESS;
 355 }