update from main archive 961211
[kopensolaris-gnu/glibc.git] / nis / nss_nis / nis-pwd.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 <pwd.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_setpwent (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_endpwent (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_getpwent_r (struct passwd *pwd, 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, "passwd.byname",
91                                       &outkey, &keylen, &result, &len));
92       else
93         retval = yperr2nss ( yp_next (domain, "passwd.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 ((size_t) (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_pwent (p, pwd, 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_getpwent_r (struct passwd *result, char *buffer, size_t buflen)
133 {
134   int status;
135
136   __libc_lock_lock (lock);
137
138   status = internal_nis_getpwent_r (result, buffer, buflen);
139
140   __libc_lock_unlock (lock);
141
142   return status;
143 }
144
145 enum nss_status
146 _nss_nis_getpwnam_r (const char *name, struct passwd *pwd,
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, "passwd.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 ((size_t) (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_pwent (p, pwd, 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_getpwuid_r (uid_t uid, struct passwd *pwd,
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", uid);
211
212   retval = yperr2nss (yp_match (domain, "passwd.byuid", 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 ((size_t) (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_pwent (p, pwd, 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 }