nis/nss_nisplus/nisplus-spwd.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 <nss.h>
  21 #include <errno.h>
  22 #include <shadow.h>
  23 #include <string.h>
  24 #include <bits/libc-lock.h>
  25 #include <rpcsvc/nis.h>
  26
  27 #include "nss-nisplus.h"
  28 #include "nisplus-parser.h"
  29
  30 __libc_lock_define_initialized (static, lock)
  31
  32 static nis_result *result;
  33
  34 /* Defined in nisplus-pwd.c.  */
  35 extern nis_name pwd_tablename_val attribute_hidden;
  36 extern size_t pwd_tablename_len attribute_hidden;
  37 extern enum nss_status _nss_pwd_create_tablename (int *errnop);
  38
  39
  40 enum nss_status
  41 _nss_nisplus_setspent (int stayopen)
  42 {
  43   enum nss_status status = NSS_STATUS_SUCCESS;
  44   int err;
  45
  46   __libc_lock_lock (lock);
  47
  48   if (result != NULL)
  49     {
  50       nis_freeresult (result);
  51       result = NULL;
  52     }
  53
  54   if (pwd_tablename_val == NULL)
  55     status = _nss_pwd_create_tablename (&err);
  56
  57   __libc_lock_unlock (lock);
  58
  59   return NSS_STATUS_SUCCESS;
  60 }
  61
  62 enum nss_status
  63 _nss_nisplus_endspent (void)
  64 {
  65   __libc_lock_lock (lock);
  66
  67   if (result != NULL)
  68     {
  69       nis_freeresult (result);
  70       result = NULL;
  71     }
  72
  73   __libc_lock_unlock (lock);
  74
  75   return NSS_STATUS_SUCCESS;
  76 }
  77
  78 static enum nss_status
  79 internal_nisplus_getspent_r (struct spwd *sp, char *buffer, size_t buflen,
  80                              int *errnop)
  81 {
  82   int parse_res;
  83
  84   /* Get the next entry until we found a correct one. */
  85   do
  86     {
  87       nis_result *saved_res;
  88
  89       if (result == NULL)
  90         {
  91           saved_res = NULL;
  92
  93           if (pwd_tablename_val == NULL)
  94             {
  95               enum nss_status status = _nss_pwd_create_tablename (errnop);
  96
  97               if (status != NSS_STATUS_SUCCESS)
  98                 return status;
  99             }
 100
 101           result = nis_first_entry (pwd_tablename_val);
 102           if (result == NULL)
 103             {
 104               *errnop = errno;
 105               return NSS_STATUS_TRYAGAIN;
 106             }
 107           if (niserr2nss (result->status) != NSS_STATUS_SUCCESS)
 108             return niserr2nss (result->status);
 109         }
 110       else
 111         {
 112           saved_res = result;
 113           result = nis_next_entry (pwd_tablename_val, &result->cookie);
 114           if (result == NULL)
 115             {
 116               *errnop = errno;
 117               return NSS_STATUS_TRYAGAIN;
 118             }
 119           if (niserr2nss (result->status) != NSS_STATUS_SUCCESS)
 120             {
 121               nis_freeresult (saved_res);
 122               return niserr2nss (result->status);
 123             }
 124         }
 125
 126       parse_res = _nss_nisplus_parse_spent (result, sp, buffer,
 127                                             buflen, errnop);
 128       if (__builtin_expect (parse_res == -1, 0))
 129         {
 130           nis_freeresult (result);
 131           result = saved_res;
 132           *errnop = ERANGE;
 133           return NSS_STATUS_TRYAGAIN;
 134         }
 135
 136       if (saved_res != NULL)
 137         nis_freeresult (saved_res);
 138     }
 139   while (!parse_res);
 140
 141   return NSS_STATUS_SUCCESS;
 142 }
 143
 144 enum nss_status
 145 _nss_nisplus_getspent_r (struct spwd *result, char *buffer, size_t buflen,
 146                          int *errnop)
 147 {
 148   int status;
 149
 150   __libc_lock_lock (lock);
 151
 152   status = internal_nisplus_getspent_r (result, buffer, buflen, errnop);
 153
 154   __libc_lock_unlock (lock);
 155
 156   return status;
 157 }
 158
 159 enum nss_status
 160 _nss_nisplus_getspnam_r (const char *name, struct spwd *sp,
 161                      char *buffer, size_t buflen, int *errnop)
 162 {
 163   int parse_res;
 164
 165   if (pwd_tablename_val == NULL)
 166     {
 167       enum nss_status status = _nss_pwd_create_tablename (errnop);
 168
 169       if (status != NSS_STATUS_SUCCESS)
 170         return status;
 171     }
 172
 173   if (name == NULL)
 174     {
 175       *errnop = EINVAL;
 176       return NSS_STATUS_NOTFOUND;
 177     }
 178
 179   nis_result *result;
 180   char buf[strlen (name) + 9 + pwd_tablename_len];
 181   int olderr = errno;
 182
 183   snprintf (buf, sizeof (buf), "[name=%s],%s", name, pwd_tablename_val);
 184
 185   result = nis_list (buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
 186
 187   if (result == NULL)
 188     {
 189       *errnop = ENOMEM;
 190       return NSS_STATUS_TRYAGAIN;
 191     }
 192
 193   if (__builtin_expect (niserr2nss (result->status) != NSS_STATUS_SUCCESS, 0))
 194     {
 195       enum nss_status status = niserr2nss (result->status);
 196
 197       __set_errno (olderr);
 198
 199       nis_freeresult (result);
 200       return status;
 201     }
 202
 203   parse_res = _nss_nisplus_parse_spent (result, sp, buffer, buflen, errnop);
 204   nis_freeresult (result);
 205
 206   if (__builtin_expect (parse_res < 1, 0))
 207     {
 208       if (parse_res == -1)
 209         {
 210           *errnop = ERANGE;
 211           return NSS_STATUS_TRYAGAIN;
 212         }
 213       else
 214         {
 215           __set_errno (olderr);
 216           return NSS_STATUS_NOTFOUND;
 217         }
 218     }
 219
 220   return NSS_STATUS_SUCCESS;
 221 }