Don't use relative include paths, use <...>.
[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 <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 {
83   struct parser_data *data = (void *) buffer;
84   char *domain, *result, *outkey;
85   int len, keylen, parse_res;
86
87   if (yp_get_default_domain (&domain))
88     return NSS_STATUS_UNAVAIL;
89
90   /* Get the next entry until we found a correct one. */
91   do
92     {
93       enum nss_status retval;
94       char *p;
95
96       if (new_start)
97         retval = yperr2nss (yp_first (domain, "passwd.byname",
98                                       &outkey, &keylen, &result, &len));
99       else
100         retval = yperr2nss ( yp_next (domain, "passwd.byname",
101                                       oldkey, oldkeylen,
102                                       &outkey, &keylen, &result, &len));
103
104       if (retval != NSS_STATUS_SUCCESS)
105         {
106           if (retval == NSS_STATUS_TRYAGAIN)
107             __set_errno (EAGAIN);
108           return retval;
109         }
110
111       if ((size_t) (len + 1) > buflen)
112         {
113           free (result);
114           __set_errno (ERANGE);
115           return NSS_STATUS_TRYAGAIN;
116         }
117
118       p = strncpy (buffer, result, len);
119       buffer[len] = '\0';
120       while (isspace (*p))
121         ++p;
122       free (result);
123
124       parse_res = _nss_files_parse_pwent (p, pwd, data, buflen);
125       if (!parse_res && errno == ERANGE)
126         return NSS_STATUS_TRYAGAIN;
127
128       free (oldkey);
129       oldkey = outkey;
130       oldkeylen = keylen;
131       new_start = 0;
132     }
133   while (!parse_res);
134
135   return NSS_STATUS_SUCCESS;
136 }
137
138 enum nss_status
139 _nss_nis_getpwent_r (struct passwd *result, char *buffer, size_t buflen)
140 {
141   int status;
142
143   __libc_lock_lock (lock);
144
145   status = internal_nis_getpwent_r (result, buffer, buflen);
146
147   __libc_lock_unlock (lock);
148
149   return status;
150 }
151
152 enum nss_status
153 _nss_nis_getpwnam_r (const char *name, struct passwd *pwd,
154                      char *buffer, size_t buflen)
155 {
156   struct parser_data *data = (void *) buffer;
157   enum nss_status retval;
158   char *domain, *result, *p;
159   int len, parse_res;
160
161   if (name == NULL)
162     {
163       __set_errno (EINVAL);
164       return NSS_STATUS_UNAVAIL;
165     }
166
167   if (yp_get_default_domain (&domain))
168     return NSS_STATUS_UNAVAIL;
169
170   retval = yperr2nss (yp_match (domain, "passwd.byname", name,
171                                 strlen (name), &result, &len));
172
173   if (retval != NSS_STATUS_SUCCESS)
174     {
175       if (retval == NSS_STATUS_TRYAGAIN)
176         __set_errno (EAGAIN);
177       return retval;
178     }
179
180   if ((size_t) (len + 1) > buflen)
181     {
182       free (result);
183       __set_errno (ERANGE);
184       return NSS_STATUS_TRYAGAIN;
185     }
186
187   p = strncpy (buffer, result, len);
188   buffer[len] = '\0';
189   while (isspace (*p))
190     ++p;
191   free (result);
192
193   parse_res = _nss_files_parse_pwent (p, pwd, data, buflen);
194
195   if (!parse_res)
196     {
197       if (errno == ERANGE)
198         return NSS_STATUS_TRYAGAIN;
199       else
200         return NSS_STATUS_NOTFOUND;
201     }
202   else
203     return NSS_STATUS_SUCCESS;
204 }
205
206 enum nss_status
207 _nss_nis_getpwuid_r (uid_t uid, struct passwd *pwd,
208                      char *buffer, size_t buflen)
209 {
210   struct parser_data *data = (void *) buffer;
211   enum nss_status retval;
212   char *domain, *result, *p;
213   int len, nlen, parse_res;
214   char buf[32];
215
216   if (yp_get_default_domain (&domain))
217     return NSS_STATUS_UNAVAIL;
218
219   nlen = sprintf (buf, "%d", uid);
220
221   retval = yperr2nss (yp_match (domain, "passwd.byuid", buf,
222                                 nlen, &result, &len));
223
224   if (retval != NSS_STATUS_SUCCESS)
225     {
226       if (retval == NSS_STATUS_TRYAGAIN)
227         __set_errno (EAGAIN);
228       return retval;
229     }
230
231   if ((size_t) (len + 1) > buflen)
232     {
233       free (result);
234       __set_errno (ERANGE);
235       return NSS_STATUS_TRYAGAIN;
236     }
237
238   p = strncpy (buffer, result, len);
239   buffer[len] = '\0';
240   while (isspace (*p))
241     ++p;
242   free (result);
243
244   parse_res = _nss_files_parse_pwent (p, pwd, data, buflen);
245
246   if (!parse_res)
247     {
248       if (errno == ERANGE)
249         return NSS_STATUS_TRYAGAIN;
250       else
251         return NSS_STATUS_NOTFOUND;
252     }
253   else
254     return NSS_STATUS_SUCCESS;
255 }