nis/nss_nisplus/nisplus-ethers.c

   1 /* Copyright (C) 1997,1998,2000-2003,2005 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         ((res)->objects.objects_val[(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         ((res)->objects.objects_val[(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       || result->objects.objects_len != 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   strncpy (p, NISENTRYVAL (0, 0, result), NISENTRYLEN (0, 0, result));
  72   room_left -= (NISENTRYLEN (0, 0, result) +1);
  73   ether->e_name = p;
  74
  75   struct ether_addr *ea = ether_aton (NISENTRYVAL (0, 1, result));
  76   if (ea == NULL)
  77     {
  78       *errnop = EINVAL;
  79       return -2;
  80     }
  81
  82   ether->e_addr = *ea;
  83
  84   return 1;
  85 }
  86
  87 static enum nss_status
  88 _nss_create_tablename (int *errnop)
  89 {
  90   if (tablename_val == NULL)
  91     {
  92       const char *local_dir = nis_local_directory ();
  93       size_t local_dir_len = strlen (local_dir);
  94       static const char prefix[] = "ethers.org_dir.";
  95
  96       char *p = malloc (sizeof (prefix) + local_dir_len);
  97       if (tablename_val == NULL)
  98         {
  99           *errnop = errno;
 100           return NSS_STATUS_TRYAGAIN;
 101         }
 102
 103       memcpy (__stpcpy (p, prefix), local_dir, local_dir_len + 1);
 104
 105       tablename_len = sizeof (prefix) - 1 + local_dir_len;
 106
 107       atomic_write_barrier ();
 108
 109       tablename_val = p;
 110     }
 111   return NSS_STATUS_SUCCESS;
 112 }
 113
 114
 115 enum nss_status
 116 _nss_nisplus_setetherent (int stayopen)
 117 {
 118   enum nss_status status;
 119   int err;
 120
 121   status = NSS_STATUS_SUCCESS;
 122
 123   __libc_lock_lock (lock);
 124
 125   if (result != NULL)
 126     {
 127       nis_freeresult (result);
 128       result = NULL;
 129     }
 130
 131   if (_nss_create_tablename (&err) != NSS_STATUS_SUCCESS)
 132     status = NSS_STATUS_UNAVAIL;
 133
 134   __libc_lock_unlock (lock);
 135
 136   return NSS_STATUS_SUCCESS;
 137 }
 138
 139 enum nss_status
 140 _nss_nisplus_endetherent (void)
 141 {
 142   __libc_lock_lock (lock);
 143
 144   if (result != NULL)
 145     {
 146       nis_freeresult (result);
 147       result = NULL;
 148     }
 149
 150   __libc_lock_unlock (lock);
 151
 152   return NSS_STATUS_SUCCESS;
 153 }
 154
 155 static enum nss_status
 156 internal_nisplus_getetherent_r (struct etherent *ether, char *buffer,
 157                                 size_t buflen, int *errnop)
 158 {
 159   if (tablename_val == NULL)
 160     {
 161       enum nss_status status = _nss_create_tablename (errnop);
 162
 163       if (status != NSS_STATUS_SUCCESS)
 164         return status;
 165     }
 166
 167   /* Get the next entry until we found a correct one. */
 168   int parse_res;
 169   do
 170     {
 171       nis_result *saved_result;
 172
 173       if (result == NULL)
 174         {
 175           saved_result = NULL;
 176           result = nis_first_entry (tablename_val);
 177           if (niserr2nss (result->status) != NSS_STATUS_SUCCESS)
 178             return niserr2nss (result->status);
 179         }
 180       else
 181         {
 182           saved_result = result;
 183           result = nis_next_entry (tablename_val, &result->cookie);
 184           if (niserr2nss (result->status) != NSS_STATUS_SUCCESS)
 185             {
 186               nis_freeresult (saved_result);
 187               return niserr2nss (result->status);
 188             }
 189         }
 190
 191       parse_res = _nss_nisplus_parse_etherent (result, ether, buffer,
 192                                                buflen, errnop);
 193       if (parse_res == -1)
 194         {
 195           nis_freeresult (result);
 196           result = saved_result;
 197           return NSS_STATUS_TRYAGAIN;
 198         }
 199
 200       if (saved_result != NULL)
 201         nis_freeresult (saved_result);
 202
 203     }
 204   while (!parse_res);
 205
 206   return NSS_STATUS_SUCCESS;
 207 }
 208
 209 enum nss_status
 210 _nss_nisplus_getetherent_r (struct etherent *result, char *buffer,
 211                             size_t buflen, int *errnop)
 212 {
 213   int status;
 214
 215   __libc_lock_lock (lock);
 216
 217   status = internal_nisplus_getetherent_r (result, buffer, buflen, errnop);
 218
 219   __libc_lock_unlock (lock);
 220
 221   return status;
 222 }
 223
 224 enum nss_status
 225 _nss_nisplus_gethostton_r (const char *name, struct etherent *eth,
 226                            char *buffer, size_t buflen, int *errnop)
 227 {
 228   if (tablename_val == NULL)
 229     {
 230       enum nss_status status = _nss_create_tablename (errnop);
 231
 232       if (status != NSS_STATUS_SUCCESS)
 233         return status;
 234     }
 235
 236   if (name == NULL)
 237     {
 238       *errnop = EINVAL;
 239       return NSS_STATUS_UNAVAIL;
 240     }
 241
 242   char buf[strlen (name) + 9 + tablename_len];
 243   int olderr = errno;
 244
 245   snprintf (buf, sizeof (buf), "[name=%s],%s", name, tablename_val);
 246
 247   nis_result *result = nis_list (buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
 248
 249   if (result == NULL)
 250     {
 251       *errnop = ENOMEM;
 252       return NSS_STATUS_TRYAGAIN;
 253     }
 254
 255   if (__builtin_expect (niserr2nss (result->status) != NSS_STATUS_SUCCESS, 0))
 256     {
 257       enum nss_status status = niserr2nss (result->status);
 258       nis_freeresult (result);
 259       return status;
 260     }
 261
 262   int parse_res = _nss_nisplus_parse_etherent (result, eth, buffer,
 263                                                buflen, errnop);
 264   if (__builtin_expect (parse_res < 1, 0))
 265     {
 266       __set_errno (olderr);
 267
 268       if (parse_res == -1)
 269         {
 270           nis_freeresult (result);
 271           return NSS_STATUS_TRYAGAIN;
 272         }
 273       else
 274         return NSS_STATUS_NOTFOUND;
 275     }
 276
 277   return NSS_STATUS_SUCCESS;
 278 }
 279
 280 enum nss_status
 281 _nss_nisplus_getntohost_r (const struct ether_addr *addr, struct etherent *eth,
 282                            char *buffer, size_t buflen, int *errnop)
 283 {
 284   if (tablename_val == NULL)
 285     {
 286       __libc_lock_lock (lock);
 287
 288       enum nss_status status = _nss_create_tablename (errnop);
 289
 290       __libc_lock_unlock (lock);
 291
 292       if (status != NSS_STATUS_SUCCESS)
 293         return status;
 294     }
 295
 296   if (addr == NULL)
 297     {
 298       *errnop = EINVAL;
 299       return NSS_STATUS_UNAVAIL;
 300     }
 301
 302   char buf[26 + tablename_len];
 303
 304   snprintf (buf, sizeof (buf),
 305             "[addr=%" PRIx8 ":%" PRIx8 ":%" PRIx8 ":%" PRIx8 ":%" PRIx8
 306             ":%" PRIx8 "],%s",
 307             addr->ether_addr_octet[0], addr->ether_addr_octet[1],
 308             addr->ether_addr_octet[2], addr->ether_addr_octet[3],
 309             addr->ether_addr_octet[4], addr->ether_addr_octet[5],
 310             tablename_val);
 311
 312   nis_result *result = nis_list (buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
 313
 314   if (result == NULL)
 315     {
 316       *errnop = ENOMEM;
 317       return NSS_STATUS_TRYAGAIN;
 318     }
 319
 320   if (__builtin_expect (niserr2nss (result->status) != NSS_STATUS_SUCCESS, 0))
 321     {
 322       enum nss_status status = niserr2nss (result->status);
 323       nis_freeresult (result);
 324       return status;
 325     }
 326
 327   int parse_res = _nss_nisplus_parse_etherent (result, eth, buffer,
 328                                                buflen, errnop);
 329   if (__builtin_expect (parse_res < 1, 0))
 330     {
 331       if (parse_res == -1)
 332         {
 333           nis_freeresult (result);
 334           return NSS_STATUS_TRYAGAIN;
 335         }
 336
 337       return NSS_STATUS_NOTFOUND;
 338     }
 339
 340   return NSS_STATUS_SUCCESS;
 341 }