1 /* Copyright (C) 1996 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public License as
6 published by the Free Software Foundation; either version 2 of the
7 License, or (at your option) any later version.
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Library General Public License for more details.
14 You should have received a copy of the GNU Library General Public
15 License along with the GNU C Library; see the file COPYING.LIB. If not,
16 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 Boston, MA 02111-1307, USA. */
19 #include <libc-lock.h>
27 /* Protect above variable against multiple uses at the same time. */
28 __libc_lock_define_initialized (static, lock)
30 /* This handle for the NSS data base is shared between all
31 set/get/endXXXent functions. */
32 static service_user *nip;
34 /* The whole information for the set/get/endnetgrent functions are
35 kept in this structure. */
36 static struct __netgrent dataset;
38 /* The lookup function for the first entry of this service. */
39 extern int __nss_netgroup_lookup (service_user **nip, const char *name,
43 /* Set up NIP to run through the services. If ALL is zero, use NIP's
44 current location if it's not nil. Return nonzero if there are no
46 static enum nss_status
47 setup (void **fctp, const char *func_name, int all)
49 /* Remember the first service_entry, it's always the same. */
50 static service_user *startp = NULL;
55 no_more = __nss_netgroup_lookup (&nip, func_name, fctp);
56 startp = no_more ? (service_user *) -1 : nip;
58 else if (startp == (service_user *) -1)
59 /* No services at all. */
64 /* Reset to the beginning of the service list. */
66 /* Look up the first function. */
67 no_more = __nss_lookup (&nip, func_name, fctp);
72 /* Free used memory. */
74 free_memory (struct __netgrent *data)
76 while (data->known_groups != NULL)
78 struct name_list *tmp = data->known_groups;
79 data->known_groups = data->known_groups->next;
80 free ((void *) tmp->name);
84 while (data->needed_groups != NULL)
86 struct name_list *tmp = data->needed_groups;
87 data->needed_groups = data->needed_groups->next;
88 free ((void *) tmp->name);
94 __internal_setnetgrent_reuse (const char *group, struct __netgrent *datap)
96 enum nss_status (*fct) (const char *, struct __netgrent *);
97 enum nss_status status = NSS_STATUS_UNAVAIL;
98 struct name_list *new_elem;
101 /* Cycle through all the services and run their setnetgrent functions. */
102 no_more = setup ((void **) &fct, "setnetgrent", 1);
105 /* Ignore status, we force check in `__nss_next'. */
106 status = (*fct) (group, datap);
108 no_more = __nss_next (&nip, "setnetgrent", (void **) &fct, status, 0);
111 /* Add the current group to the list of known groups. */
112 new_elem = (struct name_list *) malloc (sizeof (struct name_list));
113 if (new_elem == NULL || (new_elem->name = __strdup (group)) == NULL)
115 if (new_elem != NULL)
117 status = NSS_STATUS_UNAVAIL;
121 new_elem->next = datap->known_groups;
122 datap->known_groups = new_elem;
125 return status == NSS_STATUS_SUCCESS;
129 __internal_setnetgrent (const char *group, struct __netgrent *datap)
131 /* Free list of all netgroup names from last run. */
134 return __internal_setnetgrent_reuse (group, datap);
138 setnetgrent (const char *group)
142 __libc_lock_lock (lock);
144 result = __internal_setnetgrent (group, &dataset);
146 __libc_lock_unlock (lock);
153 __internal_endnetgrent (struct __netgrent *datap)
155 service_user *old_nip;
156 enum nss_status (*fct) (struct __netgrent *);
159 /* Remember which was the last used service. */
162 /* Cycle through all the services and run their setnetgrent functions. */
163 no_more = setup ((void **) &fct, "endnetgrent", 1);
166 /* Ignore status, we force check in `__nss_next'. */
167 (void) (*fct) (datap);
169 no_more = (nip == old_nip
170 || __nss_next (&nip, "endnetgrent", (void **) &fct, 0, 1));
173 /* Now free list of all netgroup names from last run. */
181 __libc_lock_lock (lock);
183 __internal_endnetgrent (&dataset);
185 __libc_lock_unlock (lock);
190 __internal_getnetgrent (char **hostp, char **userp, char **domainp,
191 struct __netgrent *datap,
192 char *buffer, size_t buflen)
194 enum nss_status (*fct) (struct __netgrent *, char *, size_t);
197 /* Initialize status to return if no more functions are found. */
198 enum nss_status status = NSS_STATUS_NOTFOUND;
200 /* Run through available functions, starting with the same function last
201 run. We will repeat each function as long as it succeeds, and then go
202 on to the next service action. */
203 no_more = setup ((void **) &fct, "getnetgrent_r", 0);
206 status = (*fct) (datap, buffer, buflen);
208 if (status == NSS_STATUS_RETURN)
210 /* This was the last one for this group. Look at next group
213 while (datap->needed_groups != NULL && ! found)
215 struct name_list *tmp = datap->needed_groups;
216 datap->needed_groups = datap->needed_groups->next;
217 tmp->next = datap->known_groups;
218 datap->known_groups = tmp;
220 found = __internal_setnetgrent_reuse (datap->known_groups->name,
227 else if (status == NSS_STATUS_SUCCESS && datap->type == group_val)
229 /* The last entry was a name of another netgroup. */
230 struct name_list *namep;
232 /* Ignore if we've seen the name before. */
233 for (namep = datap->known_groups; namep != NULL;
235 if (strcmp (datap->val.group, namep->name) == 0)
241 namep = (struct name_list *) malloc (sizeof (struct name_list));
243 || (namep->name = __strdup (datap->val.group)) == NULL)
245 /* We are out of memory. */
248 status = NSS_STATUS_RETURN;
252 namep->next = datap->needed_groups;
253 datap->needed_groups = namep;
254 /* And get the next entry. */
259 no_more = __nss_next (&nip, "getnetgrent_r", (void **) &fct, status, 0);
262 if (status == NSS_STATUS_SUCCESS)
264 *hostp = (char *) datap->val.triple.host;
265 *userp = (char *) datap->val.triple.user;
266 *domainp = (char *) datap->val.triple.domain;
269 return status == NSS_STATUS_SUCCESS ? 1 : 0;
272 /* The real entry point. */
274 __getnetgrent_r (char **hostp, char **userp, char **domainp,
275 char *buffer, size_t buflen)
277 enum nss_status status;
279 __libc_lock_lock (lock);
281 status = __internal_getnetgrent (hostp, userp, domainp, &dataset,
284 __libc_lock_unlock (lock);
288 weak_alias (__getnetgrent_r, getnetgrent_r)
290 /* Test whether given (host,user,domain) triple is in NETGROUP. */
292 innetgr (const char *netgroup, const char *host, const char *user,
295 int (*setfct) (const char *, struct __netgrent *);
296 void (*endfct) (struct __netgrent *);
297 int (*getfct) (struct __netgrent *, char *, size_t);
298 struct name_list *known = NULL;
299 struct name_list *needed = NULL;
302 const char *current_group = netgroup;
305 /* Walk through the services until we found an answer or we shall
306 not work further. We can do some optimization here. Since all
307 services must provide the `setnetgrent' function we can do all
308 the work during one walk through the service list. */
311 no_more = setup ((void **) &setfct, "setnetgrent", 1);
314 enum nss_status status;
315 struct __netgrent entry;
317 /* Clear the space for the netgroup data. */
318 bzero (&entry, sizeof (entry));
321 status = (*setfct) (current_group, &entry);
322 if (status == NSS_STATUS_SUCCESS
323 && __nss_lookup (&nip, "getnetgrent_r", (void **) &getfct) == 0)
327 while ((*getfct) (&entry, buffer, sizeof buffer)
328 == NSS_STATUS_SUCCESS)
330 if (entry.type == group_val)
332 /* Make sure we haven't seen the name before. */
333 struct name_list *namep;
335 for (namep = known; namep != NULL; namep = namep->next)
336 if (strcmp (entry.val.group, namep->name) == 0)
339 && strcmp (netgroup, entry.val.group) != 0)
342 (struct name_list *) malloc (sizeof (*namep));
344 || ((namep->name = __strdup (entry.val.group))
347 /* Out of memory, simply return. */
354 namep->next = needed;
362 if ((entry.val.triple.host == NULL || host == NULL
363 || strcmp (entry.val.triple.host, host) == 0)
364 && (entry.val.triple.user == NULL || user == NULL
365 || strcmp (entry.val.triple.user, user) == 0)
366 && (entry.val.triple.domain == NULL || domain == NULL
367 || strcmp (entry.val.triple.domain, domain) == 0))
378 /* If we found one service which does know the given
379 netgroup we don't try further. */
380 status = NSS_STATUS_RETURN;
383 /* Free all resources of the service. */
384 if (__nss_lookup (&nip, "endnetgrent", (void **) &endfct) == 0)
387 /* Look for the next service. */
388 no_more = __nss_next (&nip, "setnetgrent",
389 (void **) &setfct, status, 0);
392 if (result == 0 && needed != NULL)
394 struct name_list *tmp = needed;
398 current_group = known->name;
406 /* Free the memory. */
407 while (known != NULL)
409 struct name_list *tmp = known;
411 free ((void *) tmp->name);
414 while (needed != NULL)
416 struct name_list *tmp = needed;
417 needed = needed->next;
418 free ((void *) tmp->name);