nis/nss_nis/nis-proto.c

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