nis/nss_nisplus/nisplus-grp.c

   1 /* Copyright (C) 1997, 2001, 2002, 2003, 2005 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 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 <atomic.h>
  21 #include <nss.h>
  22 #include <grp.h>
  23 #include <ctype.h>
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <bits/libc-lock.h>
  27 #include <rpcsvc/nis.h>
  28
  29 #include "nss-nisplus.h"
  30 #include "nisplus-parser.h"
  31
  32
  33 __libc_lock_define_initialized (static, lock);
  34
  35 static nis_result *result;
  36 static unsigned long next_entry;
  37 static nis_name tablename_val;
  38 static size_t tablename_len;
  39
  40 static enum nss_status
  41 _nss_create_tablename (int *errnop)
  42 {
  43   if (tablename_val == NULL)
  44     {
  45       const char *local_dir = nis_local_directory ();
  46       size_t local_dir_len = strlen (local_dir);
  47       static const char prefix[] = "group.org_dir.";
  48
  49       char *p = malloc (sizeof (prefix) + local_dir_len);
  50       if (tablename_val == NULL)
  51         {
  52           *errnop = errno;
  53           return NSS_STATUS_TRYAGAIN;
  54         }
  55
  56       memcpy (__stpcpy (p, prefix), local_dir, local_dir_len + 1);
  57
  58       tablename_len = sizeof (prefix) - 1 + local_dir_len;
  59
  60       atomic_write_barrier ();
  61
  62       tablename_val = p;
  63     }
  64
  65   return NSS_STATUS_SUCCESS;
  66 }
  67
  68 static enum nss_status
  69 internal_setgrent (void)
  70 {
  71   enum nss_status status;
  72
  73   if (result != NULL)
  74     {
  75       nis_freeresult (result);
  76       result = NULL;
  77     }
  78   next_entry = 0;
  79
  80   if (tablename_val == NULL)
  81     {
  82       int err;
  83       if (_nss_create_tablename (&err) != NSS_STATUS_SUCCESS)
  84         return NSS_STATUS_UNAVAIL;
  85     }
  86
  87   result = nis_list (tablename_val, FOLLOW_LINKS | FOLLOW_PATH, NULL, NULL);
  88   if (result == NULL)
  89     {
  90       status = NSS_STATUS_TRYAGAIN;
  91       __set_errno (ENOMEM);
  92     }
  93   else
  94     {
  95       status = niserr2nss (result->status);
  96       if (status != NSS_STATUS_SUCCESS)
  97         {
  98           nis_freeresult (result);
  99           result = NULL;
 100         }
 101     }
 102   return status;
 103 }
 104
 105 enum nss_status
 106 _nss_nisplus_setgrent (int stayopen)
 107 {
 108   enum nss_status status;
 109
 110   __libc_lock_lock (lock);
 111
 112   status = internal_setgrent ();
 113
 114   __libc_lock_unlock (lock);
 115
 116   return status;
 117 }
 118
 119 enum nss_status
 120 _nss_nisplus_endgrent (void)
 121 {
 122   __libc_lock_lock (lock);
 123
 124   if (result != NULL)
 125     {
 126       nis_freeresult (result);
 127       result = NULL;
 128     }
 129
 130   __libc_lock_unlock (lock);
 131
 132   return NSS_STATUS_SUCCESS;
 133 }
 134
 135 static enum nss_status
 136 internal_nisplus_getgrent_r (struct group *gr, char *buffer, size_t buflen,
 137                              int *errnop)
 138 {
 139   int parse_res;
 140
 141   if (result == NULL)
 142     {
 143       enum nss_status status;
 144
 145       status = internal_setgrent ();
 146       if (result == NULL || status != NSS_STATUS_SUCCESS)
 147         return status;
 148     }
 149
 150   /* Get the next entry until we found a correct one. */
 151   do
 152     {
 153       if (next_entry >= result->objects.objects_len)
 154         return NSS_STATUS_NOTFOUND;
 155
 156       parse_res = _nss_nisplus_parse_grent (result, next_entry, gr,
 157                                             buffer, buflen, errnop);
 158       if (parse_res == -1)
 159         return NSS_STATUS_TRYAGAIN;
 160
 161       ++next_entry;
 162     }
 163   while (!parse_res);
 164
 165   return NSS_STATUS_SUCCESS;
 166 }
 167
 168 enum nss_status
 169 _nss_nisplus_getgrent_r (struct group *result, char *buffer, size_t buflen,
 170                          int *errnop)
 171 {
 172   int status;
 173
 174   __libc_lock_lock (lock);
 175
 176   status = internal_nisplus_getgrent_r (result, buffer, buflen, errnop);
 177
 178   __libc_lock_unlock (lock);
 179
 180   return status;
 181 }
 182
 183 enum nss_status
 184 _nss_nisplus_getgrnam_r (const char *name, struct group *gr,
 185                          char *buffer, size_t buflen, int *errnop)
 186 {
 187   int parse_res;
 188
 189   if (tablename_val == NULL)
 190     {
 191       __libc_lock_lock (lock);
 192
 193       enum nss_status status = _nss_create_tablename (errnop);
 194
 195       __libc_lock_unlock (lock);
 196
 197       if (status != NSS_STATUS_SUCCESS)
 198         return status;
 199     }
 200
 201   if (name == NULL)
 202     {
 203       *errnop = EINVAL;
 204       return NSS_STATUS_NOTFOUND;
 205     }
 206
 207   nis_result *result;
 208   char buf[strlen (name) + 9 + tablename_len];
 209   int olderr = errno;
 210
 211   snprintf (buf, sizeof (buf), "[name=%s],%s", name, tablename_val);
 212
 213   result = nis_list (buf, FOLLOW_LINKS | FOLLOW_PATH, NULL, NULL);
 214
 215   if (result == NULL)
 216     {
 217       *errnop = ENOMEM;
 218       return NSS_STATUS_TRYAGAIN;
 219     }
 220
 221   if (__builtin_expect (niserr2nss (result->status) != NSS_STATUS_SUCCESS, 0))
 222     {
 223       enum nss_status status = niserr2nss (result->status);
 224
 225       nis_freeresult (result);
 226       return status;
 227     }
 228
 229   parse_res = _nss_nisplus_parse_grent (result, 0, gr, buffer, buflen, errnop);
 230   nis_freeresult (result);
 231   if (__builtin_expect (parse_res < 1, 0))
 232     {
 233       if (parse_res == -1)
 234         {
 235           *errnop = ERANGE;
 236           return NSS_STATUS_TRYAGAIN;
 237         }
 238       else
 239         {
 240           __set_errno (olderr);
 241           return NSS_STATUS_NOTFOUND;
 242         }
 243     }
 244
 245   return NSS_STATUS_SUCCESS;
 246 }
 247
 248 enum nss_status
 249 _nss_nisplus_getgrgid_r (const gid_t gid, struct group *gr,
 250                          char *buffer, size_t buflen, int *errnop)
 251 {
 252   if (tablename_val == NULL)
 253     {
 254       __libc_lock_lock (lock);
 255
 256       enum nss_status status = _nss_create_tablename (errnop);
 257
 258       __libc_lock_unlock (lock);
 259
 260       if (status != NSS_STATUS_SUCCESS)
 261         return status;
 262     }
 263
 264   int parse_res;
 265   nis_result *result;
 266   char buf[8 + 3 * sizeof (unsigned long int) + tablename_len];
 267   int olderr = errno;
 268
 269   snprintf (buf, sizeof (buf), "[gid=%lu],%s",
 270             (unsigned long int) gid, tablename_val);
 271
 272   result = nis_list (buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
 273
 274   if (result == NULL)
 275     {
 276       *errnop = ENOMEM;
 277       return NSS_STATUS_TRYAGAIN;
 278     }
 279
 280   if (__builtin_expect (niserr2nss (result->status) != NSS_STATUS_SUCCESS, 0))
 281     {
 282       enum nss_status status = niserr2nss (result->status);
 283
 284       __set_errno (olderr);
 285
 286       nis_freeresult (result);
 287       return status;
 288     }
 289
 290   parse_res = _nss_nisplus_parse_grent (result, 0, gr, buffer, buflen, errnop);
 291
 292   nis_freeresult (result);
 293   if (__builtin_expect (parse_res < 1, 0))
 294     {
 295       __set_errno (olderr);
 296
 297       if (parse_res == -1)
 298         {
 299           *errnop = ERANGE;
 300           return NSS_STATUS_TRYAGAIN;
 301         }
 302       else
 303         return NSS_STATUS_NOTFOUND;
 304     }
 305
 306   return NSS_STATUS_SUCCESS;
 307 }