nis/nss_nis/nis-rpc.c

   1 /* Copyright (C) 1996-1998,2000,2002,2003,2004,2006
   2    Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Thorsten Kukuk <kukuk@suse.de>, 1996.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 #include <nss.h>
  22 #include <netdb.h>
  23 #include <ctype.h>
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <bits/libc-lock.h>
  27 #include <rpcsvc/yp.h>
  28 #include <rpcsvc/ypclnt.h>
  29
  30 #include "nss-nis.h"
  31
  32 /* Get the declaration of the parser function.  */
  33 #define ENTNAME rpcent
  34 #define EXTERN_PARSER
  35 #include <nss/nss_files/files-parse.c>
  36
  37 __libc_lock_define_initialized (static, lock)
  38
  39 static intern_t intern;
  40
  41
  42 static void
  43 internal_nis_endrpcent (intern_t *intern)
  44 {
  45   struct response_t *curr = intern->next;
  46
  47   while (curr != NULL)
  48     {
  49       struct response_t *last = curr;
  50       curr = curr->next;
  51       free (last);
  52     }
  53
  54   intern->next = intern->start = NULL;
  55 }
  56
  57 static enum nss_status
  58 internal_nis_setrpcent (intern_t *intern)
  59 {
  60   char *domainname;
  61   struct ypall_callback ypcb;
  62   enum nss_status status;
  63
  64   if (yp_get_default_domain (&domainname))
  65     return NSS_STATUS_UNAVAIL;
  66
  67   internal_nis_endrpcent (intern);
  68
  69   ypcb.foreach = _nis_saveit;
  70   ypcb.data = (char *) intern;
  71   status = yperr2nss (yp_all (domainname, "rpc.bynumber", &ypcb));
  72
  73   /* Mark the last buffer as full.  */
  74   if (intern->next != NULL)
  75     intern->next->size = intern->offset;
  76
  77   intern->next = intern->start;
  78   intern->offset = 0;
  79
  80   return status;
  81 }
  82
  83 enum nss_status
  84 _nss_nis_setrpcent (int stayopen)
  85 {
  86   enum nss_status status;
  87
  88   __libc_lock_lock (lock);
  89
  90   status = internal_nis_setrpcent (&intern);
  91
  92   __libc_lock_unlock (lock);
  93
  94   return status;
  95 }
  96
  97 enum nss_status
  98 _nss_nis_endrpcent (void)
  99 {
 100   __libc_lock_lock (lock);
 101
 102   internal_nis_endrpcent (&intern);
 103
 104   __libc_lock_unlock (lock);
 105
 106   return NSS_STATUS_SUCCESS;
 107 }
 108
 109 static enum nss_status
 110 internal_nis_getrpcent_r (struct rpcent *rpc, char *buffer, size_t buflen,
 111                           int *errnop, intern_t *intern)
 112 {
 113   struct parser_data *pdata = (void *) buffer;
 114   int parse_res;
 115   char *p;
 116
 117   if (intern->start == NULL)
 118     internal_nis_setrpcent (intern);
 119
 120   /* Get the next entry until we found a correct one. */
 121   do
 122     {
 123       struct response_t *bucket = intern->next;
 124
 125       if (__builtin_expect (intern->offset >= bucket->size, 0))
 126         {
 127           if (bucket->next == NULL)
 128             return NSS_STATUS_NOTFOUND;
 129
 130           /* We look at all the content in the current bucket.  Go on
 131              to the next.  */
 132           bucket = intern->next = bucket->next;
 133           intern->offset = 0;
 134         }
 135
 136       for (p = &bucket->mem[intern->offset]; isspace (*p); ++p)
 137         ++intern->offset;
 138
 139       size_t len = strlen (p) + 1;
 140       if (__builtin_expect (len > buflen, 0))
 141         {
 142           *errnop = ERANGE;
 143           return NSS_STATUS_TRYAGAIN;
 144         }
 145
 146       /* We unfortunately have to copy the data in the user-provided
 147          buffer because that buffer might be around for a very long
 148          time and the servent structure must remain valid.  If we would
 149          rely on the BUCKET memory the next 'setservent' or 'endservent'
 150          call would destroy it.
 151
 152          The important thing is that it is a single NUL-terminated
 153          string.  This is what the parsing routine expects.  */
 154       p = memcpy (buffer, &bucket->mem[intern->offset], len);
 155
 156       parse_res = _nss_files_parse_rpcent (p, rpc, pdata, buflen, errnop);
 157       if (__builtin_expect (parse_res == -1, 0))
 158         return NSS_STATUS_TRYAGAIN;
 159
 160       intern->offset += len;
 161     }
 162   while (!parse_res);
 163
 164   return NSS_STATUS_SUCCESS;
 165 }
 166
 167 enum nss_status
 168 _nss_nis_getrpcent_r (struct rpcent *rpc, char *buffer, size_t buflen,
 169                       int *errnop)
 170 {
 171   enum nss_status status;
 172
 173   __libc_lock_lock (lock);
 174
 175   status = internal_nis_getrpcent_r (rpc, buffer, buflen, errnop, &intern);
 176
 177   __libc_lock_unlock (lock);
 178
 179   return status;
 180 }
 181
 182 enum nss_status
 183 _nss_nis_getrpcbyname_r (const char *name, struct rpcent *rpc,
 184                          char *buffer, size_t buflen, int *errnop)
 185 {
 186   if (name == NULL)
 187     {
 188       *errnop = EINVAL;
 189       return NSS_STATUS_UNAVAIL;
 190     }
 191
 192   intern_t data = { NULL, NULL, 0 };
 193   enum nss_status status = internal_nis_setrpcent (&data);
 194   if (__builtin_expect (status != NSS_STATUS_SUCCESS, 0))
 195     return status;
 196
 197   int found = 0;
 198   while (!found &&
 199          ((status = internal_nis_getrpcent_r (rpc, buffer, buflen, errnop,
 200                                               &data)) == NSS_STATUS_SUCCESS))
 201     {
 202       if (strcmp (rpc->r_name, name) == 0)
 203         found = 1;
 204       else
 205         {
 206           int i = 0;
 207
 208           while (rpc->r_aliases[i] != NULL)
 209             {
 210               if (strcmp (rpc->r_aliases[i], name) == 0)
 211                 {
 212                   found = 1;
 213                   break;
 214                 }
 215               else
 216                 ++i;
 217             }
 218         }
 219     }
 220
 221   internal_nis_endrpcent (&data);
 222
 223   if (__builtin_expect (!found && status == NSS_STATUS_SUCCESS, 0))
 224     return NSS_STATUS_NOTFOUND;
 225
 226   return status;
 227 }
 228
 229 enum nss_status
 230 _nss_nis_getrpcbynumber_r (int number, struct rpcent *rpc,
 231                            char *buffer, size_t buflen, int *errnop)
 232 {
 233   char *domain;
 234   if (__builtin_expect (yp_get_default_domain (&domain), 0))
 235     return NSS_STATUS_UNAVAIL;
 236
 237   char buf[32];
 238   int nlen = snprintf (buf, sizeof (buf), "%d", number);
 239
 240   char *result;
 241   int len;
 242   int yperr = yp_match (domain, "rpc.bynumber", buf, nlen, &result, &len);
 243
 244   if (__builtin_expect (yperr != YPERR_SUCCESS, 0))
 245     {
 246       enum nss_status retval = yperr2nss (yperr);
 247
 248       if (retval == NSS_STATUS_TRYAGAIN)
 249         *errnop = errno;
 250       return retval;
 251     }
 252
 253   if (__builtin_expect ((size_t) (len + 1) > buflen, 0))
 254     {
 255       free (result);
 256       *errnop = ERANGE;
 257       return NSS_STATUS_TRYAGAIN;
 258     }
 259
 260   char *p = strncpy (buffer, result, len);
 261   buffer[len] = '\0';
 262   while (isspace (*p))
 263     ++p;
 264   free (result);
 265
 266   int parse_res = _nss_files_parse_rpcent (p, rpc, (void  *) buffer, buflen,
 267                                            errnop);
 268   if (__builtin_expect (parse_res < 1, 0))
 269     {
 270       if (parse_res == -1)
 271         return NSS_STATUS_TRYAGAIN;
 272       else
 273         return NSS_STATUS_NOTFOUND;
 274     }
 275   else
 276     return NSS_STATUS_SUCCESS;
 277 }