Fix "buffer to small" problems and memory leaks.
[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 {
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       if ((parse_res = _nss_files_parse_pwent (p, pwd, data, buflen)) == -1)
125         {
126           free (outkey);
127           return NSS_STATUS_TRYAGAIN;
128         }
129
130       free (oldkey);
131       oldkey = outkey;
132       oldkeylen = keylen;
133       new_start = 0;
134     }
135   while (parse_res < 1);
136
137   return NSS_STATUS_SUCCESS;
138 }
139
140 enum nss_status
141 _nss_nis_getpwent_r (struct passwd *result, char *buffer, size_t buflen)
142 {
143   int status;
144
145   __libc_lock_lock (lock);
146
147   status = internal_nis_getpwent_r (result, buffer, buflen);
148
149   __libc_lock_unlock (lock);
150
151   return status;
152 }
153
154 enum nss_status
155 _nss_nis_getpwnam_r (const char *name, struct passwd *pwd,
156                      char *buffer, size_t buflen)
157 {
158   struct parser_data *data = (void *) buffer;
159   enum nss_status retval;
160   char *domain, *result, *p;
161   int len, parse_res;
162
163   if (name == NULL)
164     {
165       __set_errno (EINVAL);
166       return NSS_STATUS_UNAVAIL;
167     }
168
169   if (yp_get_default_domain (&domain))
170     return NSS_STATUS_UNAVAIL;
171
172   retval = yperr2nss (yp_match (domain, "passwd.byname", name,
173                                 strlen (name), &result, &len));
174
175   if (retval != NSS_STATUS_SUCCESS)
176     {
177       if (retval == NSS_STATUS_TRYAGAIN)
178         __set_errno (EAGAIN);
179       return retval;
180     }
181
182   if ((size_t) (len + 1) > buflen)
183     {
184       free (result);
185       __set_errno (ERANGE);
186       return NSS_STATUS_TRYAGAIN;
187     }
188
189   p = strncpy (buffer, result, len);
190   buffer[len] = '\0';
191   while (isspace (*p))
192     ++p;
193   free (result);
194
195   parse_res = _nss_files_parse_pwent (p, pwd, data, buflen);
196
197   if (parse_res < 1)
198     {
199       if (parse_res == -1)
200         return NSS_STATUS_TRYAGAIN;
201       else
202         return NSS_STATUS_NOTFOUND;
203     }
204   else
205     return NSS_STATUS_SUCCESS;
206 }
207
208 enum nss_status
209 _nss_nis_getpwuid_r (uid_t uid, struct passwd *pwd,
210                      char *buffer, size_t buflen)
211 {
212   struct parser_data *data = (void *) buffer;
213   enum nss_status retval;
214   char *domain, *result, *p;
215   int len, nlen, parse_res;
216   char buf[32];
217
218   if (yp_get_default_domain (&domain))
219     return NSS_STATUS_UNAVAIL;
220
221   nlen = sprintf (buf, "%d", uid);
222
223   retval = yperr2nss (yp_match (domain, "passwd.byuid", buf,
224                                 nlen, &result, &len));
225
226   if (retval != NSS_STATUS_SUCCESS)
227     {
228       if (retval == NSS_STATUS_TRYAGAIN)
229         __set_errno (EAGAIN);
230       return retval;
231     }
232
233   if ((size_t) (len + 1) > buflen)
234     {
235       free (result);
236       __set_errno (ERANGE);
237       return NSS_STATUS_TRYAGAIN;
238     }
239
240   p = strncpy (buffer, result, len);
241   buffer[len] = '\0';
242   while (isspace (*p))
243     ++p;
244   free (result);
245
246   parse_res = _nss_files_parse_pwent (p, pwd, data, buflen);
247
248   if (parse_res < 1)
249     {
250       if (parse_res == -1)
251         return NSS_STATUS_TRYAGAIN;
252       else
253         return NSS_STATUS_NOTFOUND;
254     }
255   else
256     return NSS_STATUS_SUCCESS;
257 }