e3ba0cd2ddaaa4dbe972cd8f0ede586d995d6198
[kopensolaris-gnu/glibc.git] / nis / nss_nis / nis-initgroups.c
1 /* Copyright (C) 1998-2000, 2002, 2003, 2004 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 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 <alloca.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include <grp.h>
24 #include <nss.h>
25 #include <pwd.h>
26 #include <stdio.h>
27 #include <stdio_ext.h>
28 #include <string.h>
29 #include <unistd.h>
30 #include <rpcsvc/yp.h>
31 #include <rpcsvc/ypclnt.h>
32 #include <sys/param.h>
33
34 #include "nss-nis.h"
35
36 /* Get the declaration of the parser function.  */
37 #define ENTNAME grent
38 #define STRUCTURE group
39 #define EXTERN_PARSER
40 #include <nss/nss_files/files-parse.c>
41
42 struct response_t
43 {
44   struct response_t *next;
45   char val[0];
46 };
47
48 struct intern_t
49 {
50   struct response_t *start;
51   struct response_t *next;
52 };
53 typedef struct intern_t intern_t;
54
55 static int
56 saveit (int instatus, char *inkey, int inkeylen, char *inval,
57         int invallen, char *indata)
58 {
59   intern_t *intern = (intern_t *) indata;
60
61   if (instatus != YP_TRUE)
62     return instatus;
63
64   if (inkey && inkeylen > 0 && inval && invallen > 0)
65     {
66       struct response_t *newp = malloc (sizeof (struct response_t)
67                                         + invallen + 1);
68       if (newp == NULL)
69         return YP_FALSE; /* We have no error code for out of memory */
70
71       if (intern->start == NULL)
72         intern->start = newp;
73       else
74         intern->next->next = newp;
75       intern->next = newp;
76
77       newp->next = NULL;
78       *((char *) mempcpy (newp->val, inval, invallen)) = '\0';
79     }
80
81   return 0;
82 }
83
84 static enum nss_status
85 internal_setgrent (char *domainname, intern_t *intern)
86 {
87   struct ypall_callback ypcb;
88   enum nss_status status;
89
90   intern->start = NULL;
91
92   ypcb.foreach = saveit;
93   ypcb.data = (char *) intern;
94   status = yperr2nss (yp_all (domainname, "group.byname", &ypcb));
95   intern->next = intern->start;
96
97   return status;
98 }
99
100 static enum nss_status
101 internal_getgrent_r (struct group *grp, char *buffer, size_t buflen,
102                      int *errnop, intern_t *intern)
103 {
104   struct parser_data *data = (void *) buffer;
105   int parse_res;
106   char *p;
107
108   if (intern->start == NULL)
109     return NSS_STATUS_NOTFOUND;
110
111   /* Get the next entry until we found a correct one. */
112   do
113     {
114       if (intern->next == NULL)
115         return NSS_STATUS_NOTFOUND;
116
117       p = strncpy (buffer, intern->next->val, buflen);
118       while (isspace (*p))
119         ++p;
120
121       parse_res = _nss_files_parse_grent (p, grp, data, buflen, errnop);
122       if (parse_res == -1)
123         return NSS_STATUS_TRYAGAIN;
124       intern->next = intern->next->next;
125     }
126   while (!parse_res);
127
128   return NSS_STATUS_SUCCESS;
129 }
130
131
132 static int init;
133 static int use_netid;
134
135
136 static const char default_nss[] = "/etc/default/nss";
137
138 static void
139 check_default_nss (void)
140 {
141   FILE *fp = fopen (default_nss, "rc");
142   if (fp != NULL)
143     {
144       char *line = NULL;
145       size_t linelen = 0;
146
147       __fsetlocking (fp, FSETLOCKING_BYCALLER);
148
149       while (!feof_unlocked (fp))
150         {
151           ssize_t n = getline (&line, &linelen, fp);
152           if (n <= 0)
153             break;
154
155           /* There currently is only one variable we expect, so
156              simplify the parsing.  Recognize only
157
158                NETID_AUTHORITATIVE = TRUE
159
160              with arbitrary white spaces.  */
161           char *cp = line;
162           while (isspace (*cp))
163             ++cp;
164
165           /* Recognize comment lines.  */
166           if (*cp == '#')
167             continue;
168
169           static const char netid_authoritative[] = "NETID_AUTHORITATIVE";
170           if (strncmp (cp, netid_authoritative,
171                        sizeof (netid_authoritative) - 1) != 0)
172             continue;
173
174           cp += sizeof (netid_authoritative) - 1;
175           while (isspace (*cp))
176             ++cp;
177           if (*cp++ != '=')
178             continue;
179           while (isspace (*cp))
180             ++cp;
181
182           if (strncmp (cp, "TRUE", 4) != 0)
183             continue;
184           cp +=4;
185
186           while (isspace (*cp))
187             ++cp;
188
189           if (*cp == '\0')
190             use_netid = 1;
191
192           /* For now, just drop out of the loop.  */
193           break;
194         }
195
196       free (line);
197
198       fclose (fp);
199     }
200   init = 1;
201 }
202
203
204 static int
205 get_uid (const char *user, uid_t *uidp)
206 {
207   size_t buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
208   char *buf = (char *) alloca (buflen);
209
210   while (1)
211     {
212       struct passwd result;
213       struct passwd *resp;
214
215       int r = getpwnam_r (user, &result, buf, buflen, &resp);
216       if (r == 0 && resp != NULL)
217         {
218           *uidp = resp->pw_uid;
219           return 0;
220         }
221
222       if (r != ERANGE)
223         break;
224
225       extend_alloca (buf, buflen, 2 * buflen);
226     }
227
228   return 1;
229 }
230
231
232 static enum nss_status
233 initgroups_netid (uid_t uid, gid_t group, long int *start, long int *size,
234                   gid_t **groupsp, long int limit, int *errnop,
235                   const char *domainname)
236 {
237   /* Prepare the key.  The form is "unix.UID@DOMAIN" with the UID and
238      DOMAIN field filled in appropriately.  */
239   char key[sizeof ("unix.@") + sizeof (uid_t) * 3 + strlen (domainname)];
240   ssize_t keylen = snprintf (key, sizeof (key), "unix.%lu@%s",
241                              (unsigned long int) uid, domainname);
242
243   enum nss_status retval;
244   char *result;
245   int reslen;
246   retval = yperr2nss (yp_match (domainname, "netid.byname", key, keylen,
247                                 &result, &reslen));
248   if (retval != NSS_STATUS_SUCCESS)
249     return retval;
250
251   /* Parse the result: following the colon is a comma separated list of
252      group IDs.  */
253   char *cp = strchr (result, ':');
254   if (cp == NULL)
255     {
256     errout:
257       free (result);
258       return NSS_STATUS_NOTFOUND;
259     }
260   /* Skip the colon.  */
261   ++cp;
262
263   gid_t *groups = *groupsp;
264   while (*cp != '\0')
265     {
266       char *endp;
267       unsigned long int gid = strtoul (cp, &endp, 0);
268       if (cp == endp)
269         goto errout;
270       if (*endp == ',')
271         ++endp;
272       else if (*endp != '\0')
273         goto errout;
274       cp = endp;
275
276       if (gid == group)
277         /* We do not need this group again.  */
278         continue;
279
280       /* Insert this group.  */
281       if (*start == *size)
282         {
283           /* Need a bigger buffer.  */
284           gid_t *newgroups;
285           long int newsize;
286
287           if (limit > 0 && *size == limit)
288             /* We reached the maximum.  */
289             break;
290
291           if (limit <= 0)
292             newsize = 2 * *size;
293           else
294             newsize = MIN (limit, 2 * *size);
295
296           newgroups = realloc (groups, newsize * sizeof (*groups));
297           if (newgroups == NULL)
298             goto errout;
299           *groupsp = groups = newgroups;
300           *size = newsize;
301         }
302
303       groups[*start] = gid;
304       *start += 1;
305     }
306
307   free (result);
308
309   return NSS_STATUS_SUCCESS;
310 }
311
312
313 enum nss_status
314 _nss_nis_initgroups_dyn (const char *user, gid_t group, long int *start,
315                          long int *size, gid_t **groupsp, long int limit,
316                          int *errnop)
317 {
318   /* We always need the domain name.  */
319   char *domainname;
320   if (yp_get_default_domain (&domainname))
321     return NSS_STATUS_UNAVAIL;
322
323   /* Check whether we are supposed to use the netid.byname map.  */
324   if (!init)
325     check_default_nss ();
326
327   if (use_netid)
328     {
329       /* We need the user ID.  */
330       uid_t uid;
331
332       if (get_uid (user, &uid) == 0
333           && initgroups_netid (uid, group, start, size, groupsp, limit,
334                                errnop, domainname) == NSS_STATUS_SUCCESS)
335         return NSS_STATUS_SUCCESS;
336     }
337
338   struct group grpbuf, *g;
339   size_t buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
340   char *tmpbuf;
341   enum nss_status status;
342   intern_t intern = { NULL, NULL };
343   gid_t *groups = *groupsp;
344
345   status = internal_setgrent (domainname, &intern);
346   if (status != NSS_STATUS_SUCCESS)
347     return status;
348
349   tmpbuf = __alloca (buflen);
350
351   do
352     {
353       while ((status =
354               internal_getgrent_r (&grpbuf, tmpbuf, buflen, errnop,
355                                    &intern)) == NSS_STATUS_TRYAGAIN
356              && *errnop == ERANGE)
357         tmpbuf = extend_alloca (tmpbuf, buflen, 2 * buflen);
358
359       if (status != NSS_STATUS_SUCCESS)
360         goto done;
361
362
363       g = &grpbuf;
364       if (g->gr_gid != group)
365         {
366           char **m;
367
368           for (m = g->gr_mem; *m != NULL; ++m)
369             if (strcmp (*m, user) == 0)
370               {
371                 /* Matches user.  Insert this group.  */
372                 if (*start == *size)
373                   {
374                     /* Need a bigger buffer.  */
375                     gid_t *newgroups;
376                     long int newsize;
377
378                     if (limit > 0 && *size == limit)
379                       /* We reached the maximum.  */
380                       goto done;
381
382                     if (limit <= 0)
383                       newsize = 2 * *size;
384                     else
385                       newsize = MIN (limit, 2 * *size);
386
387                     newgroups = realloc (groups, newsize * sizeof (*groups));
388                     if (newgroups == NULL)
389                       goto done;
390                     *groupsp = groups = newgroups;
391                     *size = newsize;
392                   }
393
394                 groups[*start] = g->gr_gid;
395                 *start += 1;
396
397                 break;
398               }
399         }
400     }
401   while (status == NSS_STATUS_SUCCESS);
402
403 done:
404   while (intern.start != NULL)
405     {
406       intern.next = intern.start;
407       intern.start = intern.start->next;
408       free (intern.next);
409     }
410
411   return NSS_STATUS_SUCCESS;
412 }