initgroup function for compat NSS module.
[kopensolaris-gnu/glibc.git] / nis / nss_compat / compat-initgroups.c
1 /* Copyright (C) 1998 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.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 <errno.h>
21 #include <fcntl.h>
22 #include <nss.h>
23 #include <grp.h>
24 #include <ctype.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <rpcsvc/yp.h>
28 #include <rpcsvc/ypclnt.h>
29 #include <rpcsvc/nis.h>
30 #include <nsswitch.h>
31
32 #include "nss-nisplus.h"
33 #include "nisplus-parser.h"
34
35 static service_user *ni = NULL;
36 static bool_t use_nisplus = FALSE; /* default: group_compat: nis */
37 static nis_name grptable = NULL; /* Name of the group table */
38 static size_t grptablelen = 0;
39
40 /* Get the declaration of the parser function.  */
41 #define ENTNAME grent
42 #define STRUCTURE group
43 #define EXTERN_PARSER
44 #include <nss/nss_files/files-parse.c>
45
46 /* Structure for remembering -group members ... */
47 #define BLACKLIST_INITIAL_SIZE 512
48 #define BLACKLIST_INCREMENT 256
49 struct blacklist_t
50   {
51     char *data;
52     int current;
53     int size;
54   };
55
56 struct ent_t
57   {
58     bool_t nis;
59     bool_t nis_first;
60     char *oldkey;
61     int oldkeylen;
62     nis_result *result;
63     FILE *stream;
64     struct blacklist_t blacklist;
65 };
66 typedef struct ent_t ent_t;
67
68
69 /* Prototypes for local functions.  */
70 static void blacklist_store_name (const char *, ent_t *);
71 static int in_blacklist (const char *, int, ent_t *);
72
73 static enum nss_status
74 _nss_first_init (void)
75 {
76   if (ni == NULL)
77     {
78       __nss_database_lookup ("group_compat", NULL, "nis", &ni);
79       use_nisplus = (strcmp (ni->name, "nisplus") == 0);
80     }
81
82   if (grptable == NULL)
83     {
84       static const char key[] = "group.org_dir.";
85       const char *local_dir = nis_local_directory ();
86       size_t len_local_dir = strlen (local_dir);
87
88       grptable = malloc (sizeof (key) + len_local_dir);
89       if (grptable == NULL)
90         return NSS_STATUS_TRYAGAIN;
91
92       grptablelen = ((char *) mempcpy (mempcpy (grptable,
93                                                 key, sizeof (key) - 1),
94                                        local_dir, len_local_dir + 1)
95                      - grptable) - 1;
96     }
97
98   return NSS_STATUS_SUCCESS;
99 }
100
101 static enum nss_status
102 internal_setgrent (ent_t *ent)
103 {
104   enum nss_status status = NSS_STATUS_SUCCESS;
105
106   ent->nis = ent->nis_first = 0;
107
108   if (_nss_first_init () != NSS_STATUS_SUCCESS)
109     return NSS_STATUS_UNAVAIL;
110
111   if (ent->oldkey != NULL)
112     {
113       free (ent->oldkey);
114       ent->oldkey = NULL;
115       ent->oldkeylen = 0;
116     }
117
118   if (ent->result != NULL)
119     {
120       nis_freeresult (ent->result);
121       ent->result = NULL;
122     }
123
124   if (ent->blacklist.data != NULL)
125     {
126       ent->blacklist.current = 1;
127       ent->blacklist.data[0] = '|';
128       ent->blacklist.data[1] = '\0';
129     }
130   else
131     ent->blacklist.current = 0;
132
133   if (ent->stream == NULL)
134     {
135       ent->stream = fopen ("/etc/group", "r");
136
137       if (ent->stream == NULL)
138         status = errno == EAGAIN ? NSS_STATUS_TRYAGAIN : NSS_STATUS_UNAVAIL;
139       else
140         {
141           /* We have to make sure the file is  `closed on exec'.  */
142           int result, flags;
143
144           result = flags = fcntl (fileno (ent->stream), F_GETFD, 0);
145           if (result >= 0)
146             {
147               flags |= FD_CLOEXEC;
148               result = fcntl (fileno (ent->stream), F_SETFD, flags);
149             }
150           if (result < 0)
151             {
152               /* Something went wrong.  Close the stream and return a
153                  failure.  */
154               fclose (ent->stream);
155               ent->stream = NULL;
156               status = NSS_STATUS_UNAVAIL;
157             }
158         }
159     }
160   else
161     rewind (ent->stream);
162
163   return status;
164 }
165
166
167 static enum nss_status
168 internal_endgrent (ent_t *ent)
169 {
170   if (ent->stream != NULL)
171     {
172       fclose (ent->stream);
173       ent->stream = NULL;
174     }
175
176   ent->nis = ent->nis_first = 0;
177
178   if (ent->oldkey != NULL)
179     {
180       free (ent->oldkey);
181       ent->oldkey = NULL;
182       ent->oldkeylen = 0;
183     }
184
185   if (ent->result != NULL)
186     {
187       nis_freeresult (ent->result);
188       ent->result = NULL;
189     }
190
191   if (ent->blacklist.data != NULL)
192     {
193       ent->blacklist.current = 1;
194       ent->blacklist.data[0] = '|';
195       ent->blacklist.data[1] = '\0';
196     }
197   else
198     ent->blacklist.current = 0;
199
200   return NSS_STATUS_SUCCESS;
201 }
202
203 static enum nss_status
204 getgrent_next_nis (struct group *result, ent_t *ent, char *buffer,
205                    size_t buflen, int *errnop)
206 {
207   struct parser_data *data = (void *) buffer;
208   char *domain;
209   char *outkey, *outval;
210   int outkeylen, outvallen, parse_res;
211   char *p;
212
213   if (yp_get_default_domain (&domain) != YPERR_SUCCESS)
214     {
215       ent->nis = 0;
216       return NSS_STATUS_NOTFOUND;
217     }
218
219   do
220     {
221       char *save_oldkey;
222       int save_oldlen;
223       bool_t save_nis_first;
224
225       if (ent->nis_first)
226         {
227           if (yp_first (domain, "group.byname", &outkey, &outkeylen,
228                         &outval, &outvallen) != YPERR_SUCCESS)
229             {
230               ent->nis = 0;
231               return NSS_STATUS_UNAVAIL;
232             }
233
234           if ( buflen < ((size_t) outvallen + 1))
235             {
236               free (outval);
237               *errnop = ERANGE;
238               return NSS_STATUS_TRYAGAIN;
239             }
240
241           save_oldkey = ent->oldkey;
242           save_oldlen = ent->oldkeylen;
243           save_nis_first = TRUE;
244           ent->oldkey = outkey;
245           ent->oldkeylen = outkeylen;
246           ent->nis_first = FALSE;
247         }
248       else
249         {
250           if (yp_next (domain, "group.byname", ent->oldkey, ent->oldkeylen,
251                        &outkey, &outkeylen, &outval, &outvallen)
252               != YPERR_SUCCESS)
253             {
254               ent->nis = 0;
255               return NSS_STATUS_NOTFOUND;
256             }
257
258           if ( buflen < ((size_t) outvallen + 1))
259             {
260               free (outval);
261               *errnop = ERANGE;
262               return NSS_STATUS_TRYAGAIN;
263             }
264
265           save_oldkey = ent->oldkey;
266           save_oldlen = ent->oldkeylen;
267           save_nis_first = FALSE;
268           ent->oldkey = outkey;
269           ent->oldkeylen = outkeylen;
270         }
271
272       /* Copy the found data to our buffer...  */
273       p = strncpy (buffer, outval, buflen);
274
275       /* ...and free the data.  */
276       free (outval);
277
278       while (isspace (*p))
279         ++p;
280
281       parse_res = _nss_files_parse_grent (p, result, data, buflen, errnop);
282       if (parse_res == -1)
283         {
284           free (ent->oldkey);
285           ent->oldkey = save_oldkey;
286           ent->oldkeylen = save_oldlen;
287           ent->nis_first = save_nis_first;
288           *errnop = ERANGE;
289           return NSS_STATUS_TRYAGAIN;
290         }
291       else
292         {
293           if (!save_nis_first)
294             free (save_oldkey);
295         }
296
297       if (parse_res &&
298           in_blacklist (result->gr_name, strlen (result->gr_name), ent))
299         parse_res = 0; /* if result->gr_name in blacklist,search next entry */
300     }
301   while (!parse_res);
302
303   return NSS_STATUS_SUCCESS;
304 }
305
306 static enum nss_status
307 getgrent_next_nisplus (struct group *result, ent_t *ent, char *buffer,
308                        size_t buflen, int *errnop)
309 {
310   int parse_res;
311
312   do
313     {
314       nis_result *save_oldres;
315       bool_t save_nis_first;
316
317       if (ent->nis_first)
318         {
319           save_oldres = ent->result;
320           save_nis_first = TRUE;
321           ent->result = nis_first_entry(grptable);
322           if (niserr2nss (ent->result->status) != NSS_STATUS_SUCCESS)
323             {
324               ent->nis = 0;
325               return niserr2nss (ent->result->status);
326             }
327           ent->nis_first = FALSE;
328         }
329       else
330         {
331           nis_result *res;
332
333           save_oldres = ent->result;
334           save_nis_first = FALSE;
335           res = nis_next_entry(grptable, &ent->result->cookie);
336           ent->result = res;
337           if (niserr2nss (ent->result->status) != NSS_STATUS_SUCCESS)
338             {
339               ent->nis = 0;
340               return niserr2nss (ent->result->status);
341             }
342         }
343       parse_res = _nss_nisplus_parse_grent (ent->result, 0, result,
344                                             buffer, buflen, errnop);
345       if (parse_res == -1)
346         {
347           nis_freeresult (ent->result);
348           ent->result = save_oldres;
349           ent->nis_first = save_nis_first;
350           *errnop = ERANGE;
351           return NSS_STATUS_TRYAGAIN;
352         }
353       else
354         {
355           if (!save_nis_first)
356             nis_freeresult (save_oldres);
357         }
358
359       if (parse_res &&
360           in_blacklist (result->gr_name, strlen (result->gr_name), ent))
361         parse_res = 0; /* if result->gr_name in blacklist,search next entry */
362     }
363   while (!parse_res);
364
365   return NSS_STATUS_SUCCESS;
366 }
367
368 /* This function handle the +group entrys in /etc/group */
369 static enum nss_status
370 getgrnam_plusgroup (const char *name, struct group *result, char *buffer,
371                     size_t buflen, int *errnop)
372 {
373   struct parser_data *data = (void *) buffer;
374   int parse_res;
375
376   if (use_nisplus) /* Do the NIS+ query here */
377     {
378       nis_result *res;
379       char buf[strlen (name) + 24 + grptablelen];
380
381       sprintf(buf, "[name=%s],%s", name, grptable);
382       res = nis_list(buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
383       if (niserr2nss (res->status) != NSS_STATUS_SUCCESS)
384         {
385           enum nss_status status =  niserr2nss (res->status);
386
387           nis_freeresult (res);
388           return status;
389         }
390       parse_res = _nss_nisplus_parse_grent (res, 0, result, buffer, buflen,
391                                             errnop);
392       if (parse_res == -1)
393         {
394           nis_freeresult (res);
395           *errnop = ERANGE;
396           return NSS_STATUS_TRYAGAIN;
397         }
398       nis_freeresult (res);
399     }
400   else /* Use NIS */
401     {
402       char *domain, *outval, *p;
403       int outvallen;
404
405       if (yp_get_default_domain (&domain) != YPERR_SUCCESS)
406         return NSS_STATUS_NOTFOUND;
407
408       if (yp_match (domain, "group.byname", name, strlen (name),
409                     &outval, &outvallen) != YPERR_SUCCESS)
410         return NSS_STATUS_NOTFOUND;
411
412       if (buflen < ((size_t) outvallen + 1))
413         {
414           free (outval);
415           *errnop = ERANGE;
416           return NSS_STATUS_TRYAGAIN;
417         }
418
419       /* Copy the found data to our buffer...  */
420       p = strncpy (buffer, outval, buflen);
421
422       /* ... and free the data.  */
423       free (outval);
424       while (isspace (*p))
425         ++p;
426       parse_res = _nss_files_parse_grent (p, result, data, buflen, errnop);
427       if (parse_res == -1)
428         return NSS_STATUS_TRYAGAIN;
429     }
430
431   if (parse_res)
432     /* We found the entry.  */
433     return NSS_STATUS_SUCCESS;
434   else
435     return NSS_STATUS_RETURN;
436 }
437
438 static enum nss_status
439 getgrent_next_file (struct group *result, ent_t *ent,
440                     char *buffer, size_t buflen, int *errnop)
441 {
442   struct parser_data *data = (void *) buffer;
443   while (1)
444     {
445       fpos_t pos;
446       int parse_res = 0;
447       char *p;
448
449       do
450         {
451           fgetpos (ent->stream, &pos);
452           buffer[buflen - 1] = '\xff';
453           p = fgets (buffer, buflen, ent->stream);
454           if (p == NULL && feof (ent->stream))
455             return NSS_STATUS_NOTFOUND;
456           if (p == NULL || buffer[buflen - 1] != '\xff')
457             {
458               fsetpos (ent->stream, &pos);
459               *errnop = ERANGE;
460               return NSS_STATUS_TRYAGAIN;
461             }
462
463           /* Terminate the line for any case.  */
464           buffer[buflen - 1] = '\0';
465
466           /* Skip leading blanks.  */
467           while (isspace (*p))
468             ++p;
469         }
470       while (*p == '\0' || *p == '#' || /* Ignore empty and comment lines. */
471       /* Parse the line.  If it is invalid, loop to
472          get the next line of the file to parse.  */
473              !(parse_res = _nss_files_parse_grent (p, result, data, buflen,
474                                                    errnop)));
475
476       if (parse_res == -1)
477         {
478           /* The parser ran out of space.  */
479           fsetpos (ent->stream, &pos);
480           *errnop = ERANGE;
481           return NSS_STATUS_TRYAGAIN;
482         }
483
484       if (result->gr_name[0] != '+' && result->gr_name[0] != '-')
485         /* This is a real entry.  */
486         break;
487
488       /* -group */
489       if (result->gr_name[0] == '-' && result->gr_name[1] != '\0'
490           && result->gr_name[1] != '@')
491         {
492           blacklist_store_name (&result->gr_name[1], ent);
493           continue;
494         }
495
496       /* +group */
497       if (result->gr_name[0] == '+' && result->gr_name[1] != '\0'
498           && result->gr_name[1] != '@')
499         {
500           enum nss_status status;
501
502           /* Store the group in the blacklist for the "+" at the end of
503              /etc/group */
504           blacklist_store_name (&result->gr_name[1], ent);
505           status = getgrnam_plusgroup (&result->gr_name[1], result, buffer,
506                                        buflen, errnop);
507           if (status == NSS_STATUS_SUCCESS) /* We found the entry. */
508             break;
509           else
510             if (status == NSS_STATUS_RETURN /* We couldn't parse the entry */
511                 || status == NSS_STATUS_NOTFOUND) /* No group in NIS */
512               continue;
513             else
514               {
515                 if (status == NSS_STATUS_TRYAGAIN)
516                   {
517                     /* The parser ran out of space.  */
518                     fsetpos (ent->stream, &pos);
519                     *errnop = ERANGE;
520                   }
521                 return status;
522               }
523         }
524
525       /* +:... */
526       if (result->gr_name[0] == '+' && result->gr_name[1] == '\0')
527         {
528           ent->nis = TRUE;
529           ent->nis_first = TRUE;
530
531           if (use_nisplus)
532             return getgrent_next_nisplus (result, ent, buffer, buflen, errnop);
533           else
534             return getgrent_next_nis (result, ent, buffer, buflen, errnop);
535         }
536     }
537
538   return NSS_STATUS_SUCCESS;
539 }
540
541
542 static enum nss_status
543 internal_getgrent_r (struct group *gr, ent_t *ent, char *buffer,
544                      size_t buflen, int *errnop)
545 {
546   if (ent->nis)
547     {
548       if (use_nisplus)
549         return getgrent_next_nisplus (gr, ent, buffer, buflen, errnop);
550       else
551         return getgrent_next_nis (gr, ent, buffer, buflen, errnop);
552     }
553   else
554     return getgrent_next_file (gr, ent, buffer, buflen, errnop);
555 }
556
557 enum nss_status
558 _nss_compat_initgroups (const char *user, gid_t group, long int *start,
559                         long int *size, gid_t *groups, long int limit,
560                         int *errnop)
561 {
562   struct group grpbuf, *g;
563   size_t buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
564   char *tmpbuf;
565   enum nss_status status;
566   ent_t intern = {0, 0, NULL, 0, NULL, NULL, {NULL, 0, 0}};
567
568   status = internal_setgrent (&intern);
569   if (status != NSS_STATUS_SUCCESS)
570     return status;
571
572   tmpbuf = __alloca (buflen);
573
574   do
575     {
576       while ((status =
577               internal_getgrent_r (&grpbuf, &intern, tmpbuf, buflen,
578                                    errnop)) == NSS_STATUS_TRYAGAIN
579              && *errnop == ERANGE)
580         {
581           buflen *= 2;
582           tmpbuf = __alloca (buflen);
583         }
584
585       if (status != NSS_STATUS_SUCCESS)
586         goto done;
587
588       g = &grpbuf;
589       if (g->gr_gid != group)
590         {
591           char **m;
592
593           for (m = g->gr_mem; *m != NULL; ++m)
594             if (strcmp (*m, user) == 0)
595               {
596                 /* Matches user.  Insert this group.  */
597                 if (*start == *size && limit <= 0)
598                   {
599                     /* Need a bigger buffer.  */
600                     groups = realloc (groups, *size * sizeof (*groups));
601                     if (groups == NULL)
602                       goto done;
603                     *size *= 2;
604                   }
605
606                 groups[*start] = g->gr_gid;
607                 *start += 1;
608
609                 if (*start == limit)
610                   /* Can't take any more groups; stop searching.  */
611                   goto done;
612
613                 break;
614               }
615         }
616     }
617   while (status == NSS_STATUS_SUCCESS);
618
619 done:
620   internal_endgrent (&intern);
621
622   return NSS_STATUS_SUCCESS;
623 }
624
625
626 /* Support routines for remembering -@netgroup and -user entries.
627    The names are stored in a single string with `|' as separator. */
628 static void
629 blacklist_store_name (const char *name, ent_t *ent)
630 {
631   int namelen = strlen (name);
632   char *tmp;
633
634   /* first call, setup cache */
635   if (ent->blacklist.size == 0)
636     {
637       ent->blacklist.size = MAX (BLACKLIST_INITIAL_SIZE, 2 * namelen);
638       ent->blacklist.data = malloc (ent->blacklist.size);
639       if (ent->blacklist.data == NULL)
640         return;
641       ent->blacklist.data[0] = '|';
642       ent->blacklist.data[1] = '\0';
643       ent->blacklist.current = 1;
644     }
645   else
646     {
647       if (in_blacklist (name, namelen, ent))
648         return;                 /* no duplicates */
649
650       if (ent->blacklist.current + namelen + 1 >= ent->blacklist.size)
651         {
652           ent->blacklist.size += MAX (BLACKLIST_INCREMENT, 2 * namelen);
653           tmp = realloc (ent->blacklist.data, ent->blacklist.size);
654           if (tmp == NULL)
655             {
656               free (ent->blacklist.data);
657               ent->blacklist.size = 0;
658               return;
659             }
660           ent->blacklist.data = tmp;
661         }
662     }
663
664   tmp = stpcpy (ent->blacklist.data + ent->blacklist.current, name);
665   *tmp++ = '|';
666   *tmp = '\0';
667   ent->blacklist.current += namelen + 1;
668
669   return;
670 }
671
672 /* returns TRUE if ent->blacklist contains name, else FALSE */
673 static bool_t
674 in_blacklist (const char *name, int namelen, ent_t *ent)
675 {
676   char buf[namelen + 3];
677   char *cp;
678
679   if (ent->blacklist.data == NULL)
680     return FALSE;
681
682   buf[0] = '|';
683   cp = stpcpy (&buf[1], name);
684   *cp++= '|';
685   *cp = '\0';
686   return strstr (ent->blacklist.data, buf) != NULL;
687 }