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