1 /* Copyright (C) 1996,1997,1998,1999,2001,2002, 2003 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Thorsten Kukuk <kukuk@suse.de>, 1996.
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.
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.
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
26 #include <stdio_ext.h>
28 #include <rpc/types.h>
29 #include <bits/libc-lock.h>
31 static service_user *ni;
32 static enum nss_status (*nss_setgrent) (int stayopen);
33 static enum nss_status (*nss_getgrnam_r) (const char *name,
34 struct group * grp, char *buffer,
35 size_t buflen, int *errnop);
36 static enum nss_status (*nss_getgrgid_r) (gid_t gid, struct group * grp,
37 char *buffer, size_t buflen,
39 static enum nss_status (*nss_getgrent_r) (struct group * grp, char *buffer,
40 size_t buflen, int *errnop);
41 static enum nss_status (*nss_endgrent) (void);
43 /* Get the declaration of the parser function. */
45 #define STRUCTURE group
47 #include <nss/nss_files/files-parse.c>
49 /* Structure for remembering -group members ... */
50 #define BLACKLIST_INITIAL_SIZE 512
51 #define BLACKLIST_INCREMENT 256
63 struct blacklist_t blacklist;
65 typedef struct ent_t ent_t;
67 static ent_t ext_ent = {TRUE, NULL, {NULL, 0, 0}};
69 /* Protect global state against multiple changers. */
70 __libc_lock_define_initialized (static, lock)
72 /* Prototypes for local functions. */
73 static void blacklist_store_name (const char *, ent_t *);
74 static int in_blacklist (const char *, int, ent_t *);
76 /* Initialize the NSS interface/functions. The calling function must
79 init_nss_interface (void)
81 if (__nss_database_lookup ("group_compat", NULL, "nis", &ni) >= 0)
83 nss_setgrent = __nss_lookup_function (ni, "setgrent");
84 nss_getgrnam_r = __nss_lookup_function (ni, "getgrnam_r");
85 nss_getgrgid_r = __nss_lookup_function (ni, "getgrgid_r");
86 nss_getgrent_r = __nss_lookup_function (ni, "getgrent_r");
87 nss_endgrent = __nss_lookup_function (ni, "endgrent");
91 static enum nss_status
92 internal_setgrent (ent_t *ent, int stayopen)
94 enum nss_status status = NSS_STATUS_SUCCESS;
98 if (ent->blacklist.data != NULL)
100 ent->blacklist.current = 1;
101 ent->blacklist.data[0] = '|';
102 ent->blacklist.data[1] = '\0';
105 ent->blacklist.current = 0;
107 if (ent->stream == NULL)
109 ent->stream = fopen ("/etc/group", "rm");
111 if (ent->stream == NULL)
112 status = errno == EAGAIN ? NSS_STATUS_TRYAGAIN : NSS_STATUS_UNAVAIL;
115 /* We have to make sure the file is `closed on exec'. */
118 result = flags = fcntl (fileno_unlocked (ent->stream), F_GETFD, 0);
122 result = fcntl (fileno_unlocked (ent->stream), F_SETFD, flags);
126 /* Something went wrong. Close the stream and return a
128 fclose (ent->stream);
130 status = NSS_STATUS_UNAVAIL;
133 /* We take care of locking ourself. */
134 __fsetlocking (ent->stream, FSETLOCKING_BYCALLER);
138 rewind (ent->stream);
140 if (status == NSS_STATUS_SUCCESS && nss_setgrent)
141 return nss_setgrent (stayopen);
148 _nss_compat_setgrent (int stayopen)
150 enum nss_status result;
152 __libc_lock_lock (lock);
155 init_nss_interface ();
157 result = internal_setgrent (&ext_ent, stayopen);
159 __libc_lock_unlock (lock);
165 static enum nss_status
166 internal_endgrent (ent_t *ent)
171 if (ent->stream != NULL)
173 fclose (ent->stream);
177 if (ent->blacklist.data != NULL)
179 ent->blacklist.current = 1;
180 ent->blacklist.data[0] = '|';
181 ent->blacklist.data[1] = '\0';
184 ent->blacklist.current = 0;
186 return NSS_STATUS_SUCCESS;
190 _nss_compat_endgrent (void)
192 enum nss_status result;
194 __libc_lock_lock (lock);
196 result = internal_endgrent (&ext_ent);
198 __libc_lock_unlock (lock);
203 /* get the next group from NSS (+ entry) */
204 static enum nss_status
205 getgrent_next_nss (struct group *result, ent_t *ent, char *buffer,
206 size_t buflen, int *errnop)
209 return NSS_STATUS_UNAVAIL;
213 enum nss_status status;
215 if ((status = nss_getgrent_r (result, buffer, buflen, errnop)) !=
219 while (in_blacklist (result->gr_name, strlen (result->gr_name), ent));
221 return NSS_STATUS_SUCCESS;
224 /* This function handle the +group entrys in /etc/group */
225 static enum nss_status
226 getgrnam_plusgroup (const char *name, struct group *result, ent_t *ent,
227 char *buffer, size_t buflen, int *errnop)
230 return NSS_STATUS_UNAVAIL;
232 if (nss_getgrnam_r (name, result, buffer, buflen, errnop) !=
234 return NSS_STATUS_NOTFOUND;
236 if (in_blacklist (result->gr_name, strlen (result->gr_name), ent))
237 return NSS_STATUS_NOTFOUND;
239 /* We found the entry. */
240 return NSS_STATUS_SUCCESS;
243 static enum nss_status
244 getgrent_next_file (struct group *result, ent_t *ent,
245 char *buffer, size_t buflen, int *errnop)
247 struct parser_data *data = (void *) buffer;
256 fgetpos (ent->stream, &pos);
257 buffer[buflen - 1] = '\xff';
258 p = fgets_unlocked (buffer, buflen, ent->stream);
259 if (p == NULL && feof_unlocked (ent->stream))
260 return NSS_STATUS_NOTFOUND;
262 if (p == NULL || buffer[buflen - 1] != '\xff')
264 fsetpos (ent->stream, &pos);
266 return NSS_STATUS_TRYAGAIN;
269 /* Terminate the line for any case. */
270 buffer[buflen - 1] = '\0';
272 /* Skip leading blanks. */
276 while (*p == '\0' || *p == '#' || /* Ignore empty and comment lines. */
277 /* Parse the line. If it is invalid, loop to
278 get the next line of the file to parse. */
279 !(parse_res = _nss_files_parse_grent (p, result, data, buflen,
284 /* The parser ran out of space. */
285 fsetpos (ent->stream, &pos);
287 return NSS_STATUS_TRYAGAIN;
290 if (result->gr_name[0] != '+' && result->gr_name[0] != '-')
291 /* This is a real entry. */
295 if (result->gr_name[0] == '-' && result->gr_name[1] != '\0'
296 && result->gr_name[1] != '@')
298 blacklist_store_name (&result->gr_name[1], ent);
303 if (result->gr_name[0] == '+' && result->gr_name[1] != '\0'
304 && result->gr_name[1] != '@')
306 size_t len = strlen (result->gr_name);
308 enum nss_status status;
310 /* Store the group in the blacklist for the "+" at the end of
312 memcpy (buf, &result->gr_name[1], len);
313 status = getgrnam_plusgroup (&result->gr_name[1], result, ent,
314 buffer, buflen, errnop);
315 blacklist_store_name (buf, ent);
316 if (status == NSS_STATUS_SUCCESS) /* We found the entry. */
318 else if (status == NSS_STATUS_RETURN /* We couldn't parse the entry */
319 || status == NSS_STATUS_NOTFOUND) /* No group in NIS */
323 if (status == NSS_STATUS_TRYAGAIN)
325 /* The parser ran out of space. */
326 fsetpos (ent->stream, &pos);
334 if (result->gr_name[0] == '+' && result->gr_name[1] == '\0')
338 return getgrent_next_nss (result, ent, buffer, buflen, errnop);
342 return NSS_STATUS_SUCCESS;
347 _nss_compat_getgrent_r (struct group *grp, char *buffer, size_t buflen,
350 enum nss_status result = NSS_STATUS_SUCCESS;
352 __libc_lock_lock (lock);
354 /* Be prepared that the setgrent function was not called before. */
356 init_nss_interface ();
358 if (ext_ent.stream == NULL)
359 result = internal_setgrent (&ext_ent, 1);
361 if (result == NSS_STATUS_SUCCESS)
364 result = getgrent_next_file (grp, &ext_ent, buffer, buflen, errnop);
366 result = getgrent_next_nss (grp, &ext_ent, buffer, buflen, errnop);
368 __libc_lock_unlock (lock);
373 /* Searches in /etc/group and the NIS/NIS+ map for a special group */
374 static enum nss_status
375 internal_getgrnam_r (const char *name, struct group *result, ent_t *ent,
376 char *buffer, size_t buflen, int *errnop)
378 struct parser_data *data = (void *) buffer;
387 fgetpos (ent->stream, &pos);
388 buffer[buflen - 1] = '\xff';
389 p = fgets_unlocked (buffer, buflen, ent->stream);
390 if (p == NULL && feof_unlocked (ent->stream))
391 return NSS_STATUS_NOTFOUND;
393 if (p == NULL || buffer[buflen - 1] != '\xff')
395 fsetpos (ent->stream, &pos);
397 return NSS_STATUS_TRYAGAIN;
400 /* Terminate the line for any case. */
401 buffer[buflen - 1] = '\0';
403 /* Skip leading blanks. */
407 while (*p == '\0' || *p == '#' || /* Ignore empty and comment lines. */
408 /* Parse the line. If it is invalid, loop to
409 get the next line of the file to parse. */
410 !(parse_res = _nss_files_parse_grent (p, result, data, buflen,
415 /* The parser ran out of space. */
416 fsetpos (ent->stream, &pos);
418 return NSS_STATUS_TRYAGAIN;
421 /* This is a real entry. */
422 if (result->gr_name[0] != '+' && result->gr_name[0] != '-')
424 if (strcmp (result->gr_name, name) == 0)
425 return NSS_STATUS_SUCCESS;
431 if (result->gr_name[0] == '-' && result->gr_name[1] != '\0')
433 if (strcmp (&result->gr_name[1], name) == 0)
434 return NSS_STATUS_NOTFOUND;
440 if (result->gr_name[0] == '+' && result->gr_name[1] != '\0')
442 if (strcmp (name, &result->gr_name[1]) == 0)
444 enum nss_status status;
446 status = getgrnam_plusgroup (name, result, ent,
447 buffer, buflen, errnop);
448 if (status == NSS_STATUS_RETURN)
449 /* We couldn't parse the entry */
456 if (result->gr_name[0] == '+' && result->gr_name[1] == '\0')
458 enum nss_status status;
460 status = getgrnam_plusgroup (name, result, ent,
461 buffer, buflen, errnop);
462 if (status == NSS_STATUS_RETURN)
463 /* We couldn't parse the entry */
470 return NSS_STATUS_SUCCESS;
474 _nss_compat_getgrnam_r (const char *name, struct group *grp,
475 char *buffer, size_t buflen, int *errnop)
477 ent_t ent = {TRUE, NULL, {NULL, 0, 0}};
478 enum nss_status result;
480 if (name[0] == '-' || name[0] == '+')
481 return NSS_STATUS_NOTFOUND;
483 __libc_lock_lock (lock);
486 init_nss_interface ();
488 __libc_lock_unlock (lock);
490 result = internal_setgrent (&ent, 0);
492 if (result == NSS_STATUS_SUCCESS)
493 result = internal_getgrnam_r (name, grp, &ent, buffer, buflen, errnop);
495 internal_endgrent (&ent);
500 /* Searches in /etc/group and the NIS/NIS+ map for a special group id */
501 static enum nss_status
502 internal_getgrgid_r (gid_t gid, struct group *result, ent_t *ent,
503 char *buffer, size_t buflen, int *errnop)
505 struct parser_data *data = (void *) buffer;
514 fgetpos (ent->stream, &pos);
515 buffer[buflen - 1] = '\xff';
516 p = fgets_unlocked (buffer, buflen, ent->stream);
517 if (p == NULL && feof_unlocked (ent->stream))
518 return NSS_STATUS_NOTFOUND;
520 if (p == NULL || buffer[buflen - 1] != '\xff')
522 fsetpos (ent->stream, &pos);
524 return NSS_STATUS_TRYAGAIN;
527 /* Terminate the line for any case. */
528 buffer[buflen - 1] = '\0';
530 /* Skip leading blanks. */
534 while (*p == '\0' || *p == '#' || /* Ignore empty and comment lines. */
535 /* Parse the line. If it is invalid, loop to
536 get the next line of the file to parse. */
537 !(parse_res = _nss_files_parse_grent (p, result, data, buflen,
542 /* The parser ran out of space. */
543 fsetpos (ent->stream, &pos);
545 return NSS_STATUS_TRYAGAIN;
548 /* This is a real entry. */
549 if (result->gr_name[0] != '+' && result->gr_name[0] != '-')
551 if (result->gr_gid == gid)
552 return NSS_STATUS_SUCCESS;
558 if (result->gr_name[0] == '-' && result->gr_name[1] != '\0')
560 blacklist_store_name (&result->gr_name[1], ent);
565 if (result->gr_name[0] == '+' && result->gr_name[1] != '\0')
567 enum nss_status status;
569 /* Store the group in the blacklist for the "+" at the end of
571 blacklist_store_name (&result->gr_name[1], ent);
572 status = getgrnam_plusgroup (&result->gr_name[1], result, ent,
573 buffer, buflen, errnop);
574 if (status == NSS_STATUS_SUCCESS && result->gr_gid == gid)
580 if (result->gr_name[0] == '+' && result->gr_name[1] == '\0')
582 enum nss_status status;
584 status = nss_getgrgid_r (gid, result, buffer, buflen, errnop);
585 if (status == NSS_STATUS_RETURN) /* We couldn't parse the entry */
586 return NSS_STATUS_NOTFOUND;
592 return NSS_STATUS_SUCCESS;
596 _nss_compat_getgrgid_r (gid_t gid, struct group *grp,
597 char *buffer, size_t buflen, int *errnop)
599 ent_t ent = {TRUE, NULL, {NULL, 0, 0}};
600 enum nss_status result;
602 __libc_lock_lock (lock);
605 init_nss_interface ();
607 __libc_lock_unlock (lock);
609 result = internal_setgrent (&ent, 0);
611 if (result == NSS_STATUS_SUCCESS)
612 result = internal_getgrgid_r (gid, grp, &ent, buffer, buflen, errnop);
614 internal_endgrent (&ent);
620 /* Support routines for remembering -@netgroup and -user entries.
621 The names are stored in a single string with `|' as separator. */
623 blacklist_store_name (const char *name, ent_t *ent)
625 int namelen = strlen (name);
628 /* first call, setup cache */
629 if (ent->blacklist.size == 0)
631 ent->blacklist.size = MAX (BLACKLIST_INITIAL_SIZE, 2 * namelen);
632 ent->blacklist.data = malloc (ent->blacklist.size);
633 if (ent->blacklist.data == NULL)
635 ent->blacklist.data[0] = '|';
636 ent->blacklist.data[1] = '\0';
637 ent->blacklist.current = 1;
641 if (in_blacklist (name, namelen, ent))
642 return; /* no duplicates */
644 if (ent->blacklist.current + namelen + 1 >= ent->blacklist.size)
646 ent->blacklist.size += MAX (BLACKLIST_INCREMENT, 2 * namelen);
647 tmp = realloc (ent->blacklist.data, ent->blacklist.size);
650 free (ent->blacklist.data);
651 ent->blacklist.size = 0;
654 ent->blacklist.data = tmp;
658 tmp = stpcpy (ent->blacklist.data + ent->blacklist.current, name);
661 ent->blacklist.current += namelen + 1;
666 /* returns TRUE if ent->blacklist contains name, else FALSE */
668 in_blacklist (const char *name, int namelen, ent_t *ent)
670 char buf[namelen + 3];
673 if (ent->blacklist.data == NULL)
677 cp = stpcpy (&buf[1], name);
680 return strstr (ent->blacklist.data, buf) != NULL;