nis/nss_nisplus/nisplus-ethers.c

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