nis/nss_nisplus/nisplus-pwd.c

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