Include limit in interface as it was before.
[kopensolaris-gnu/glibc.git] / nis / nss_nis / nis-initgroups.c
1 /* Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Thorsten Kukuk <kukuk@suse.de>, 1998.
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 <grp.h>
22 #include <ctype.h>
23 #include <errno.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <rpcsvc/yp.h>
27 #include <rpcsvc/ypclnt.h>
28 #include <sys/param.h>
29
30 #include "nss-nis.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 struct response_t
39 {
40   char *val;
41   struct response_t *next;
42 };
43
44 struct intern_t
45 {
46   struct response_t *start;
47   struct response_t *next;
48 };
49 typedef struct intern_t intern_t;
50
51 static int
52 saveit (int instatus, char *inkey, int inkeylen, char *inval,
53         int invallen, char *indata)
54 {
55   intern_t *intern = (intern_t *) indata;
56
57   if (instatus != YP_TRUE)
58     return instatus;
59
60   if (inkey && inkeylen > 0 && inval && invallen > 0)
61     {
62       if (intern->start == NULL)
63         {
64           intern->start = malloc (sizeof (struct response_t));
65           if (intern->start == NULL)
66             return YP_FALSE;
67           intern->next = intern->start;
68         }
69       else
70         {
71           intern->next->next = malloc (sizeof (struct response_t));
72           if (intern->next->next == NULL)
73             return YP_FALSE;
74           intern->next = intern->next->next;
75         }
76       intern->next->next = NULL;
77       intern->next->val = malloc (invallen + 1);
78       if (intern->next->val == NULL)
79         return YP_FALSE;
80       strncpy (intern->next->val, inval, invallen);
81       intern->next->val[invallen] = '\0';
82     }
83
84   return 0;
85 }
86
87 static enum nss_status
88 internal_setgrent (intern_t *intern)
89 {
90   char *domainname;
91   struct ypall_callback ypcb;
92   enum nss_status status;
93
94   if (yp_get_default_domain (&domainname))
95     return NSS_STATUS_UNAVAIL;
96
97   intern->start = NULL;
98
99   ypcb.foreach = saveit;
100   ypcb.data = (char *) intern;
101   status = yperr2nss (yp_all (domainname, "group.byname", &ypcb));
102   intern->next = intern->start;
103
104   return status;
105 }
106
107 static enum nss_status
108 internal_getgrent_r (struct group *grp, char *buffer, size_t buflen,
109                      int *errnop, intern_t *intern)
110 {
111   struct parser_data *data = (void *) buffer;
112   int parse_res;
113   char *p;
114
115   if (intern->start == NULL)
116     internal_setgrent (intern);
117
118   /* Get the next entry until we found a correct one. */
119   do
120     {
121       if (intern->next == NULL)
122         {
123           *errnop = ENOENT;
124           return NSS_STATUS_NOTFOUND;
125         }
126       p = strncpy (buffer, intern->next->val, buflen);
127       while (isspace (*p))
128         ++p;
129
130       parse_res = _nss_files_parse_grent (p, grp, data, buflen, errnop);
131       if (parse_res == -1)
132         return NSS_STATUS_TRYAGAIN;
133       intern->next = intern->next->next;
134     }
135   while (!parse_res);
136
137   return NSS_STATUS_SUCCESS;
138 }
139
140 enum nss_status
141 _nss_nis_initgroups_dyn (const char *user, gid_t group, long int *start,
142                          long int *size, gid_t **groupsp, long int limit,
143                          int *errnop)
144 {
145   struct group grpbuf, *g;
146   size_t buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
147   char *tmpbuf;
148   enum nss_status status;
149   intern_t intern = { NULL, NULL };
150   gid_t *groups = *groupsp;
151
152   status = internal_setgrent (&intern);
153   if (status != NSS_STATUS_SUCCESS)
154     return status;
155
156   tmpbuf = __alloca (buflen);
157
158   do
159     {
160       while ((status =
161               internal_getgrent_r (&grpbuf, tmpbuf, buflen, errnop,
162                                    &intern)) == NSS_STATUS_TRYAGAIN
163              && *errnop == ERANGE)
164         {
165           buflen *= 2;
166           tmpbuf = __alloca (buflen);
167         }
168
169       if (status != NSS_STATUS_SUCCESS)
170         goto done;
171
172
173       g = &grpbuf;
174       if (g->gr_gid != group)
175         {
176           char **m;
177
178           for (m = g->gr_mem; *m != NULL; ++m)
179             if (strcmp (*m, user) == 0)
180               {
181                 /* Matches user.  Insert this group.  */
182                 if (*start == *size)
183                   {
184                     /* Need a bigger buffer.  */
185                     gid_t *newgroups;
186                     long int newsize;
187
188                     if (limit > 0 && *size == limit)
189                       /* We reached the maximum.  */
190                       goto done;
191
192                     if (limit <= 0)
193                       newsize = 2 * *size;
194                     else
195                       newsize = MIN (limit, 2 * *size);
196
197                     newgroups = realloc (groups, newsize * sizeof (*groups));
198                     if (newgroups == NULL)
199                       goto done;
200                     *groupsp = groups = newgroups;
201                     *size = newsize;
202                   }
203
204                 groups[*start] = g->gr_gid;
205                 *start += 1;
206
207                 break;
208               }
209         }
210     }
211   while (status == NSS_STATUS_SUCCESS);
212
213 done:
214   while (intern.start != NULL)
215     {
216       if (intern.start->val != NULL)
217         free (intern.start->val);
218       intern.next = intern.start;
219       intern.start = intern.start->next;
220       free (intern.next);
221     }
222
223   return NSS_STATUS_SUCCESS;
224 }