Updated to fedora-glibc-20060501T0751
[kopensolaris-gnu/glibc.git] / nis / nss_nis / nis-grp.c
1 /* Copyright (C) 1996-1999, 2001-2004, 2006 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Thorsten Kukuk <kukuk@suse.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 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 <ctype.h>
21 #include <errno.h>
22 #include <grp.h>
23 #include <nss.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 #include <libnsl.h>
31
32 /* Get the declaration of the parser function.  */
33 #define ENTNAME grent
34 #define STRUCTURE group
35 #define EXTERN_PARSER
36 #include <nss/nss_files/files-parse.c>
37
38 /* Protect global state against multiple changers */
39 __libc_lock_define_initialized (static, lock)
40
41 static bool_t new_start = 1;
42 static char *oldkey;
43 static int oldkeylen;
44 static intern_t intern;
45
46
47 static void
48 internal_nis_endgrent (void)
49 {
50   new_start = 1;
51   if (oldkey != NULL)
52     {
53       free (oldkey);
54       oldkey = NULL;
55       oldkeylen = 0;
56     }
57
58   struct response_t *curr = intern.next;
59
60   while (curr != NULL)
61     {
62       struct response_t *last = curr;
63       curr = curr->next;
64       free (last);
65     }
66
67   intern.next = intern.start = NULL;
68 }
69
70
71 enum nss_status
72 _nss_nis_endgrent (void)
73 {
74   __libc_lock_lock (lock);
75
76   internal_nis_endgrent ();
77
78   __libc_lock_unlock (lock);
79
80   return NSS_STATUS_SUCCESS;
81 }
82
83
84 enum nss_status
85 internal_nis_setgrent (void)
86 {
87   /* We have to read all the data now.  */
88   char *domain;
89   if (__builtin_expect (yp_get_default_domain (&domain), 0))
90     return NSS_STATUS_UNAVAIL;
91
92   struct ypall_callback ypcb;
93
94   ypcb.foreach = _nis_saveit;
95   ypcb.data = (char *) &intern;
96   enum nss_status status = yperr2nss (yp_all (domain, "group.byname", &ypcb));
97
98
99   /* Mark the last buffer as full.  */
100   if (intern.next != NULL)
101     intern.next->size = intern.offset;
102
103   intern.next = intern.start;
104   intern.offset = 0;
105
106   return status;
107 }
108
109
110 enum nss_status
111 _nss_nis_setgrent (int stayopen)
112 {
113   enum nss_status result = NSS_STATUS_SUCCESS;
114
115   __libc_lock_lock (lock);
116
117   internal_nis_endgrent ();
118
119   if (_nsl_default_nss () & NSS_FLAG_SETENT_BATCH_READ)
120     result = internal_nis_setgrent ();
121
122   __libc_lock_unlock (lock);
123
124   return result;
125 }
126
127
128 static enum nss_status
129 internal_nis_getgrent_r (struct group *grp, char *buffer, size_t buflen,
130                          int *errnop)
131 {
132   /* If we read the entire database at setpwent time we just iterate
133      over the data we have in memory.  */
134   bool batch_read = intern.start != NULL;
135
136   char *domain = NULL;
137   if (!batch_read && __builtin_expect (yp_get_default_domain (&domain), 0))
138     return NSS_STATUS_UNAVAIL;
139
140   /* Get the next entry until we found a correct one. */
141   int parse_res;
142   do
143     {
144       char *result;
145       char *outkey;
146       int len;
147       int keylen;
148
149       if (batch_read)
150         {
151           struct response_t *bucket;
152
153         handle_batch_read:
154           bucket = intern.next;
155
156           if (__builtin_expect (intern.offset >= bucket->size, 0))
157             {
158               if (bucket->next == NULL)
159                 return NSS_STATUS_NOTFOUND;
160
161               /* We look at all the content in the current bucket.  Go on
162                  to the next.  */
163               bucket = intern.next = bucket->next;
164               intern.offset = 0;
165             }
166
167           for (result = &bucket->mem[intern.offset]; isspace (*result);
168                ++result)
169             ++intern.offset;
170
171           len = strlen (result);
172         }
173       else
174         {
175           int yperr;
176
177           if (new_start)
178             {
179               /* Maybe we should read the database in one piece.  */
180               if ((_nsl_default_nss () & NSS_FLAG_SETENT_BATCH_READ)
181                   && internal_nis_setgrent () == NSS_STATUS_SUCCESS
182                   && intern.start != NULL)
183                 {
184                   batch_read = true;
185                   goto handle_batch_read;
186                 }
187
188               yperr = yp_first (domain, "group.byname", &outkey, &keylen,
189                                 &result, &len);
190             }
191           else
192             yperr = yp_next (domain, "group.byname", oldkey, oldkeylen,
193                              &outkey, &keylen, &result, &len);
194
195           if (__builtin_expect (yperr != YPERR_SUCCESS, 0))
196             {
197               enum nss_status retval = yperr2nss (yperr);
198
199               if (retval == NSS_STATUS_TRYAGAIN)
200                 *errnop = errno;
201               return retval;
202             }
203         }
204
205       if (__builtin_expect ((size_t) (len + 1) > buflen, 0))
206         {
207           free (result);
208           *errnop = ERANGE;
209           return NSS_STATUS_TRYAGAIN;
210         }
211
212       char *p = strncpy (buffer, result, len);
213       buffer[len] = '\0';
214       while (isspace (*p))
215         ++p;
216       if (!batch_read)
217         free (result);
218
219       parse_res = _nss_files_parse_grent (p, grp, (void *) buffer, buflen,
220                                           errnop);
221       if (__builtin_expect (parse_res == -1, 0))
222         {
223           free (outkey);
224           *errnop = ERANGE;
225           return NSS_STATUS_TRYAGAIN;
226         }
227
228       if (batch_read)
229         intern.offset += len + 1;
230       else
231         {
232           free (oldkey);
233           oldkey = outkey;
234           oldkeylen = keylen;
235           new_start = 0;
236         }
237     }
238   while (parse_res < 1);
239
240   return NSS_STATUS_SUCCESS;
241 }
242
243 enum nss_status
244 _nss_nis_getgrent_r (struct group *result, char *buffer, size_t buflen,
245                      int *errnop)
246 {
247   int status;
248
249   __libc_lock_lock (lock);
250
251   status = internal_nis_getgrent_r (result, buffer, buflen, errnop);
252
253   __libc_lock_unlock (lock);
254
255   return status;
256 }
257
258 enum nss_status
259 _nss_nis_getgrnam_r (const char *name, struct group *grp,
260                      char *buffer, size_t buflen, int *errnop)
261 {
262   if (name == NULL)
263     {
264       *errnop = EINVAL;
265       return NSS_STATUS_UNAVAIL;
266     }
267
268   char *domain;
269   if (__builtin_expect (yp_get_default_domain (&domain), 0))
270     return NSS_STATUS_UNAVAIL;
271
272   char *result;
273   int len;
274   int yperr = yp_match (domain, "group.byname", name, strlen (name), &result,
275                         &len);
276
277   if (__builtin_expect (yperr != YPERR_SUCCESS, 0))
278     {
279       enum nss_status retval = yperr2nss (yperr);
280
281       if (retval == NSS_STATUS_TRYAGAIN)
282         *errnop = errno;
283       return retval;
284     }
285
286   if (__builtin_expect ((size_t) (len + 1) > buflen, 0))
287     {
288       free (result);
289       *errnop = ERANGE;
290       return NSS_STATUS_TRYAGAIN;
291     }
292
293   char *p = strncpy (buffer, result, len);
294   buffer[len] = '\0';
295   while (isspace (*p))
296     ++p;
297   free (result);
298
299   int parse_res = _nss_files_parse_grent (p, grp, (void *) buffer, buflen,
300                                           errnop);
301   if (__builtin_expect  (parse_res < 1, 0))
302     {
303       if (parse_res == -1)
304         return NSS_STATUS_TRYAGAIN;
305       else
306         return NSS_STATUS_NOTFOUND;
307     }
308   return NSS_STATUS_SUCCESS;
309 }
310
311 enum nss_status
312 _nss_nis_getgrgid_r (gid_t gid, struct group *grp,
313                      char *buffer, size_t buflen, int *errnop)
314 {
315   char *domain;
316   if (__builtin_expect (yp_get_default_domain (&domain), 0))
317     return NSS_STATUS_UNAVAIL;
318
319   char buf[32];
320   int nlen = sprintf (buf, "%lu", (unsigned long int) gid);
321
322   char *result;
323   int len;
324   int yperr = yp_match (domain, "group.bygid", buf, nlen, &result, &len);
325
326   if (__builtin_expect (yperr != YPERR_SUCCESS, 0))
327     {
328       enum nss_status retval = yperr2nss (yperr);
329
330       if (retval == NSS_STATUS_TRYAGAIN)
331         *errnop = errno;
332       return retval;
333     }
334
335   if (__builtin_expect ((size_t) (len + 1) > buflen, 0))
336     {
337       free (result);
338       *errnop = ERANGE;
339       return NSS_STATUS_TRYAGAIN;
340     }
341
342   char *p = strncpy (buffer, result, len);
343   buffer[len] = '\0';
344   while (isspace (*p))
345     ++p;
346   free (result);
347
348   int parse_res = _nss_files_parse_grent (p, grp, (void *) buffer, buflen,
349                                           errnop);
350   if (__builtin_expect (parse_res < 1, 0))
351     {
352       if (parse_res == -1)
353         return NSS_STATUS_TRYAGAIN;
354       else
355         return NSS_STATUS_NOTFOUND;
356     }
357   return NSS_STATUS_SUCCESS;
358 }