nis/nss_nis/nis-grp.c

   1 /* Copyright (C) 1996 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 <grp.h>
  22 #include <ctype.h>
  23 #include <errno.h>
  24 #include <string.h>
  25 #include <libc-lock.h>
  26 #include <rpcsvc/yp.h>
  27 #include <rpcsvc/ypclnt.h>
  28
  29 #include "nss-nis.h"
  30
  31 /* Protect global state against multiple changers */
  32 __libc_lock_define_initialized (static, lock)
  33
  34 static bool_t new_start = 1;
  35 static char *oldkey = NULL;
  36 static int oldkeylen = 0;
  37
  38 enum nss_status
  39 _nss_nis_setgrent (void)
  40 {
  41   __libc_lock_lock (lock);
  42
  43   new_start = 1;
  44   if (oldkey != NULL)
  45     {
  46       free (oldkey);
  47       oldkey = NULL;
  48       oldkeylen = 0;
  49     }
  50
  51   __libc_lock_unlock (lock);
  52
  53   return NSS_STATUS_SUCCESS;
  54 }
  55
  56 enum nss_status
  57 _nss_nis_endgrent (void)
  58 {
  59   __libc_lock_lock (lock);
  60
  61   new_start = 1;
  62   if (oldkey != NULL)
  63     {
  64       free (oldkey);
  65       oldkey = NULL;
  66       oldkeylen = 0;
  67     }
  68
  69   __libc_lock_unlock (lock);
  70
  71   return NSS_STATUS_SUCCESS;
  72 }
  73
  74 static enum nss_status
  75 internal_nis_getgrent_r (struct group *grp, char *buffer, size_t buflen)
  76 {
  77   char *domain, *result, *outkey;
  78   int len, keylen, parse_res;
  79
  80   if (yp_get_default_domain (&domain))
  81     return NSS_STATUS_UNAVAIL;
  82
  83   /* Get the next entry until we found a correct one. */
  84   do
  85     {
  86       enum nss_status retval;
  87       char *p;
  88
  89       if (new_start)
  90         retval = yperr2nss (yp_first (domain, "group.byname",
  91                                       &outkey, &keylen, &result, &len));
  92       else
  93         retval = yperr2nss ( yp_next (domain, "group.byname",
  94                                       oldkey, oldkeylen,
  95                                       &outkey, &keylen, &result, &len));
  96
  97       if (retval != NSS_STATUS_SUCCESS)
  98         {
  99           if (retval == NSS_STATUS_TRYAGAIN)
 100             __set_errno (EAGAIN);
 101           return retval;
 102         }
 103
 104       if (len + 1 > buflen)
 105         {
 106           free (result);
 107           __set_errno (ERANGE);
 108           return NSS_STATUS_TRYAGAIN;
 109         }
 110
 111       p = strncpy (buffer, result, len);
 112       buffer[len] = '\0';
 113       while (isspace (*p))
 114         ++p;
 115       free (result);
 116
 117       parse_res = _nss_files_parse_grent (p, grp, buffer, buflen);
 118       if (!parse_res && errno == ERANGE)
 119         return NSS_STATUS_TRYAGAIN;
 120
 121       free (oldkey);
 122       oldkey = outkey;
 123       oldkeylen = keylen;
 124       new_start = 0;
 125     }
 126   while (!parse_res);
 127
 128   return NSS_STATUS_SUCCESS;
 129 }
 130
 131 enum nss_status
 132 _nss_nis_getgrent_r (struct group *result, char *buffer, size_t buflen)
 133 {
 134   int status;
 135
 136   __libc_lock_lock (lock);
 137
 138   status = internal_nis_getgrent_r (result, buffer, buflen);
 139
 140   __libc_lock_unlock (lock);
 141
 142   return status;
 143 }
 144
 145 enum nss_status
 146 _nss_nis_getgrnam_r (const char *name, struct group *grp,
 147                      char *buffer, size_t buflen)
 148 {
 149   enum nss_status retval;
 150   char *domain, *result, *p;
 151   int len, parse_res;
 152
 153   if (name == NULL)
 154     {
 155       __set_errno (EINVAL);
 156       return NSS_STATUS_UNAVAIL;
 157     }
 158
 159   if (yp_get_default_domain (&domain))
 160     return NSS_STATUS_UNAVAIL;
 161
 162   retval = yperr2nss (yp_match (domain, "group.byname", name,
 163                                 strlen (name), &result, &len));
 164
 165   if (retval != NSS_STATUS_SUCCESS)
 166     {
 167       if (retval == NSS_STATUS_TRYAGAIN)
 168         __set_errno (EAGAIN);
 169       return retval;
 170     }
 171
 172   if (len + 1 > buflen)
 173     {
 174       free (result);
 175       __set_errno (ERANGE);
 176       return NSS_STATUS_TRYAGAIN;
 177     }
 178
 179   p = strncpy (buffer, result, len);
 180   buffer[len] = '\0';
 181   while (isspace (*p))
 182     ++p;
 183   free (result);
 184
 185   parse_res = _nss_files_parse_grent (p, grp, buffer, buflen);
 186
 187   if (!parse_res)
 188     {
 189       if (errno == ERANGE)
 190         return NSS_STATUS_TRYAGAIN;
 191       else
 192         return NSS_STATUS_NOTFOUND;
 193     }
 194   else
 195     return NSS_STATUS_SUCCESS;
 196 }
 197
 198 enum nss_status
 199 _nss_nis_getgrgid_r (gid_t gid, struct group *grp,
 200                      char *buffer, size_t buflen)
 201 {
 202   enum nss_status retval;
 203   char *domain, *result, *p;
 204   int len, nlen, parse_res;
 205   char buf[32];
 206
 207   if (yp_get_default_domain (&domain))
 208     return NSS_STATUS_UNAVAIL;
 209
 210   nlen = sprintf (buf, "%d", gid);
 211
 212   retval = yperr2nss (yp_match (domain, "group.bygid", buf,
 213                                 nlen, &result, &len));
 214
 215   if (retval != NSS_STATUS_SUCCESS)
 216     {
 217       if (retval == NSS_STATUS_TRYAGAIN)
 218         __set_errno (EAGAIN);
 219       return retval;
 220     }
 221
 222   if (len + 1 > buflen)
 223     {
 224       free (result);
 225       __set_errno (ERANGE);
 226       return NSS_STATUS_TRYAGAIN;
 227     }
 228
 229   p = strncpy (buffer, result, len);
 230   buffer[len] = '\0';
 231   while (isspace (*p))
 232     ++p;
 233   free (result);
 234
 235   parse_res = _nss_files_parse_grent (p, grp, buffer, buflen);
 236
 237   if (!parse_res)
 238     {
 239       if (errno == ERANGE)
 240         return NSS_STATUS_TRYAGAIN;
 241       else
 242         return NSS_STATUS_NOTFOUND;
 243     }
 244   else
 245     return NSS_STATUS_SUCCESS;
 246 }