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