nis/nss_nis/nis-ethers.c

   1 /* Copyright (C) 1996-2003, 2004 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Thorsten Kukuk <kukuk@suse.de>, 1996.
   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 <ctype.h>
  22 #include <errno.h>
  23 #include <string.h>
  24 #include <bits/libc-lock.h>
  25 #include <rpcsvc/yp.h>
  26 #include <rpcsvc/ypclnt.h>
  27 #include <netinet/ether.h>
  28 #include <netinet/if_ether.h>
  29
  30 #include "nss-nis.h"
  31
  32 /* Protect global state against multiple changers */
  33 __libc_lock_define_initialized (static, lock)
  34
  35 /* Get the declaration of the parser function.  */
  36 #define ENTNAME etherent
  37 #define STRUCTURE etherent
  38 #define EXTERN_PARSER
  39 #include <nss/nss_files/files-parse.c>
  40
  41 struct response
  42 {
  43   struct response *next;
  44   char val[0];
  45 };
  46
  47 static struct response *start;
  48 static struct response *next;
  49
  50 static int
  51 saveit (int instatus, char *inkey, int inkeylen, char *inval,
  52         int invallen, char *indata)
  53 {
  54   if (instatus != YP_TRUE)
  55     return 1;
  56
  57   if (inkey && inkeylen > 0 && inval && invallen > 0)
  58     {
  59       struct response *newp = malloc (sizeof (struct response) + invallen + 1);
  60       if (newp == NULL)
  61         return 1; /* We have no error code for out of memory */
  62
  63       if (start == NULL)
  64         start = newp;
  65       else
  66         next->next = newp;
  67       next = newp;
  68
  69       newp->next = NULL;
  70       *((char *) mempcpy (newp->val, inval, invallen)) = '\0';
  71     }
  72
  73   return 0;
  74 }
  75
  76 static void
  77 internal_nis_endetherent (void)
  78 {
  79   while (start != NULL)
  80     {
  81       next = start;
  82       start = start->next;
  83       free (next);
  84     }
  85 }
  86
  87 enum nss_status
  88 _nss_nis_endetherent (void)
  89 {
  90   __libc_lock_lock (lock);
  91
  92   internal_nis_endetherent ();
  93   next = NULL;
  94
  95   __libc_lock_unlock (lock);
  96
  97   return NSS_STATUS_SUCCESS;
  98 }
  99
 100 static enum nss_status
 101 internal_nis_setetherent (void)
 102 {
 103   char *domainname;
 104   struct ypall_callback ypcb;
 105   enum nss_status status;
 106
 107   yp_get_default_domain (&domainname);
 108
 109   internal_nis_endetherent ();
 110
 111   ypcb.foreach = saveit;
 112   ypcb.data = NULL;
 113   status = yperr2nss (yp_all (domainname, "ethers.byname", &ypcb));
 114   next = start;
 115
 116   return status;
 117 }
 118
 119 enum nss_status
 120 _nss_nis_setetherent (int stayopen)
 121 {
 122   enum nss_status result;
 123
 124   __libc_lock_lock (lock);
 125
 126   result = internal_nis_setetherent ();
 127
 128   __libc_lock_unlock (lock);
 129
 130   return result;
 131 }
 132
 133 static enum nss_status
 134 internal_nis_getetherent_r (struct etherent *eth, char *buffer, size_t buflen,
 135                             int *errnop)
 136 {
 137   struct parser_data *data = (void *) buffer;
 138   int parse_res;
 139
 140   if (start == NULL)
 141     internal_nis_setetherent ();
 142
 143   /* Get the next entry until we found a correct one. */
 144   do
 145     {
 146       char *p;
 147
 148       if (next == NULL)
 149         return NSS_STATUS_NOTFOUND;
 150
 151       p = strncpy (buffer, next->val, buflen);
 152
 153       while (isspace (*p))
 154         ++p;
 155
 156       parse_res = _nss_files_parse_etherent (p, eth, data, buflen, errnop);
 157       if (parse_res == -1)
 158         return NSS_STATUS_TRYAGAIN;
 159       next = next->next;
 160     }
 161   while (!parse_res);
 162
 163   return NSS_STATUS_SUCCESS;
 164 }
 165
 166 enum nss_status
 167 _nss_nis_getetherent_r (struct etherent *result, char *buffer, size_t buflen,
 168                         int *errnop)
 169 {
 170   int status;
 171
 172   __libc_lock_lock (lock);
 173
 174   status = internal_nis_getetherent_r (result, buffer, buflen, errnop);
 175
 176   __libc_lock_unlock (lock);
 177
 178   return status;
 179 }
 180
 181 enum nss_status
 182 _nss_nis_gethostton_r (const char *name, struct etherent *eth,
 183                        char *buffer, size_t buflen, int *errnop)
 184 {
 185   struct parser_data *data = (void *) buffer;
 186   enum nss_status retval;
 187   char *domain, *result, *p;
 188   int len, parse_res;
 189
 190   if (name == NULL)
 191     {
 192       *errnop = EINVAL;
 193       return NSS_STATUS_UNAVAIL;
 194     }
 195
 196   if (yp_get_default_domain (&domain))
 197     return NSS_STATUS_UNAVAIL;
 198
 199   retval = yperr2nss (yp_match (domain, "ethers.byname", name,
 200                                 strlen (name), &result, &len));
 201
 202   if (retval != NSS_STATUS_SUCCESS)
 203     {
 204       if (retval == NSS_STATUS_TRYAGAIN)
 205         *errnop = errno;
 206       return retval;
 207     }
 208
 209   if ((size_t) (len + 1) > buflen)
 210     {
 211       free (result);
 212       *errnop = ERANGE;
 213       return NSS_STATUS_TRYAGAIN;
 214     }
 215
 216   p = strncpy (buffer, result, len);
 217   buffer[len] = '\0';
 218   while (isspace (*p))
 219     ++p;
 220   free (result);
 221
 222   parse_res = _nss_files_parse_etherent (p, eth, data, buflen, errnop);
 223   if (parse_res < 1)
 224     {
 225       if (parse_res == -1)
 226         return NSS_STATUS_TRYAGAIN;
 227       else
 228         return NSS_STATUS_NOTFOUND;
 229     }
 230   return NSS_STATUS_SUCCESS;
 231 }
 232
 233 enum nss_status
 234 _nss_nis_getntohost_r (const struct ether_addr *addr, struct etherent *eth,
 235                        char *buffer, size_t buflen, int *errnop)
 236 {
 237   struct parser_data *data = (void *) buffer;
 238   enum nss_status retval;
 239   char *domain, *result, *p;
 240   int len, nlen, parse_res;
 241   char buf[33];
 242
 243   if (addr == NULL)
 244     {
 245       *errnop = EINVAL;
 246       return NSS_STATUS_UNAVAIL;
 247     }
 248
 249   if (yp_get_default_domain (&domain))
 250     return NSS_STATUS_UNAVAIL;
 251
 252   nlen = sprintf (buf, "%x:%x:%x:%x:%x:%x",
 253                   (int) addr->ether_addr_octet[0],
 254                   (int) addr->ether_addr_octet[1],
 255                   (int) addr->ether_addr_octet[2],
 256                   (int) addr->ether_addr_octet[3],
 257                   (int) addr->ether_addr_octet[4],
 258                   (int) addr->ether_addr_octet[5]);
 259
 260   retval = yperr2nss (yp_match (domain, "ethers.byaddr", buf,
 261                                 nlen, &result, &len));
 262
 263   if (retval != NSS_STATUS_SUCCESS)
 264     {
 265       if (retval == NSS_STATUS_TRYAGAIN)
 266         *errnop = errno;
 267       return retval;
 268     }
 269
 270   if ((size_t) (len + 1) > buflen)
 271     {
 272       free (result);
 273       *errnop = ERANGE;
 274       return NSS_STATUS_TRYAGAIN;
 275     }
 276
 277   p = strncpy (buffer, result, len);
 278   buffer[len] = '\0';
 279   while (isspace (*p))
 280     ++p;
 281   free (result);
 282
 283   parse_res = _nss_files_parse_etherent (p, eth, data, buflen, errnop);
 284   if (parse_res < 1)
 285     {
 286       if (parse_res == -1)
 287         return NSS_STATUS_TRYAGAIN;
 288       else
 289         return NSS_STATUS_NOTFOUND;
 290     }
 291   return NSS_STATUS_SUCCESS;
 292 }