?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove building with NOCRYPTO option
[minix3.git] / lib / libc / gen / getgrent.c
blob783446528f8d930e06321d8a60af7d96377aef61
1 /* $NetBSD: getgrent.c,v 1.67 2012/08/29 18:50:35 dholland Exp $ */
2
3 /*-
4 * Copyright (c) 1999-2000, 2004-2005 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Luke Mewburn.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * Copyright (c) 1989, 1993
34 * The Regents of the University of California. All rights reserved.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 * 1. Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
41 * 2. Redistributions in binary form must reproduce the above copyright
42 * notice, this list of conditions and the following disclaimer in the
43 * documentation and/or other materials provided with the distribution.
44 * 3. Neither the name of the University nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 * SUCH DAMAGE.
59 */
60
61 /*
62 * Portions Copyright (c) 1994, Jason Downs. All Rights Reserved.
63 *
64 * Redistribution and use in source and binary forms, with or without
65 * modification, are permitted provided that the following conditions
66 * are met:
67 * 1. Redistributions of source code must retain the above copyright
68 * notice, this list of conditions and the following disclaimer.
69 * 2. Redistributions in binary form must reproduce the above copyright
70 * notice, this list of conditions and the following disclaimer in the
71 * documentation and/or other materials provided with the distribution.
72 *
73 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS
74 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
75 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
76 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT,
77 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
78 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
79 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
80 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
81 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
82 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
83 * SUCH DAMAGE.
84 */
85
86 #include <sys/cdefs.h>
87 #if defined(LIBC_SCCS) && !defined(lint)
88 #if 0
89 static char sccsid[] = "@(#)getgrent.c 8.2 (Berkeley) 3/21/94";
90 #else
91 __RCSID("$NetBSD: getgrent.c,v 1.67 2012/08/29 18:50:35 dholland Exp $");
92 #endif
93 #endif /* LIBC_SCCS and not lint */
94
95 #include "namespace.h"
96 #include "reentrant.h"
97
98 #include <sys/param.h>
99
100 #include <assert.h>
101 #include <errno.h>
102 #include <grp.h>
103 #include <limits.h>
104 #include <nsswitch.h>
105 #include <stdarg.h>
106 #include <stdio.h>
107 #include <stdlib.h>
108 #include <string.h>
109 #include <syslog.h>
110
111 #ifdef HESIOD
112 #include <hesiod.h>
113 #endif
114
115 #ifdef YP
116 #include <rpc/rpc.h>
117 #include <rpcsvc/yp_prot.h>
118 #include <rpcsvc/ypclnt.h>
119 #endif
120
121 #include "gr_private.h"
122
123 #ifdef __weak_alias
124 __weak_alias(endgrent,_endgrent)
125 __weak_alias(getgrent,_getgrent)
126 __weak_alias(getgrent_r,_getgrent_r)
127 __weak_alias(getgrgid,_getgrgid)
128 __weak_alias(getgrgid_r,_getgrgid_r)
129 __weak_alias(getgrnam,_getgrnam)
130 __weak_alias(getgrnam_r,_getgrnam_r)
131 __weak_alias(setgrent,_setgrent)
132 __weak_alias(setgroupent,_setgroupent)
133 #endif
134
135 #ifdef _REENTRANT
136 mutex_t __grmutex = MUTEX_INITIALIZER;
137 #endif
138
139 /*
140 * _gr_memfrombuf
141 * Obtain want bytes from buffer (of size buflen) and return a pointer
142 * to the available memory after adjusting buffer/buflen.
143 * Returns NULL if there is insufficient space.
144 */
145 static char *
146 _gr_memfrombuf(size_t want, char **buffer, size_t *buflen)
147 {
148 char *rv;
149
150 if (want > *buflen) {
151 errno = ERANGE;
152 return NULL;
153 }
154 rv = *buffer;
155 *buffer += want;
156 *buflen -= want;
157 return rv;
158 }
159
160 /*
161 * _gr_parse
162 * Parses entry as a line per group(5) (without the trailing \n)
163 * and fills in grp with corresponding values; memory for strings
164 * and arrays will be allocated from buf (of size buflen).
165 * Returns 1 if parsed successfully, 0 on parse failure.
166 */
167 static int
168 _gr_parse(const char *entry, struct group *grp, char *buf, size_t buflen)
169 {
170 unsigned long id;
171 const char *bp;
172 char *ep;
173 size_t count;
174 int memc;
175
176 _DIAGASSERT(entry != NULL);
177 _DIAGASSERT(grp != NULL);
178 _DIAGASSERT(buf != NULL);
179
180 #define COPYTOBUF(to) \
181 do { \
182 (to) = _gr_memfrombuf(count+1, &buf, &buflen); \
183 if ((to) == NULL) \
184 return 0; \
185 memmove((to), entry, count); \
186 to[count] = '\0'; \
187 } while (0) /* LINTED */
188
189 #if 0
190 if (*entry == '+') /* fail on compat `+' token */
191 return 0;
192 #endif
193
194 count = strcspn(entry, ":"); /* parse gr_name */
195 if (entry[count] == '\0')
196 return 0;
197 COPYTOBUF(grp->gr_name);
198 entry += count + 1;
199
200 count = strcspn(entry, ":"); /* parse gr_passwd */
201 if (entry[count] == '\0')
202 return 0;
203 COPYTOBUF(grp->gr_passwd);
204 entry += count + 1;
205
206 count = strcspn(entry, ":"); /* parse gr_gid */
207 if (entry[count] == '\0')
208 return 0;
209 id = strtoul(entry, &ep, 10);
210 if (id > GID_MAX || *ep != ':')
211 return 0;
212 grp->gr_gid = (gid_t)id;
213 entry += count + 1;
214
215 memc = 1; /* for final NULL */
216 if (*entry != '\0')
217 memc++; /* for first item */
218 for (bp = entry; *bp != '\0'; bp++) {
219 if (*bp == ',')
220 memc++;
221 }
222 /* grab ALIGNed char **gr_mem from buf */
223 ep = _gr_memfrombuf(memc * sizeof(char *) + ALIGNBYTES, &buf, &buflen);
224 if (ep == NULL)
225 return 0;
226 grp->gr_mem = (char **)ALIGN(ep);
227
228 for (memc = 0; *entry != '\0'; memc++) {
229 count = strcspn(entry, ","); /* parse member */
230 COPYTOBUF(grp->gr_mem[memc]);
231 entry += count;
232 if (*entry == ',')
233 entry++;
234 }
235
236 #undef COPYTOBUF
237
238 grp->gr_mem[memc] = NULL;
239 return 1;
240 }
241
242 /*
243 * _gr_copy
244 * Copy the contents of fromgrp to grp; memory for strings
245 * and arrays will be allocated from buf (of size buflen).
246 * Returns 1 if copied successfully, 0 on copy failure.
247 * NOTE: fromgrp must not use buf for its own pointers.
248 */
249 static int
250 _gr_copy(struct group *fromgrp, struct group *grp, char *buf, size_t buflen)
251 {
252 char *ep;
253 int memc;
254
255 _DIAGASSERT(fromgrp != NULL);
256 _DIAGASSERT(grp != NULL);
257 _DIAGASSERT(buf != NULL);
258
259 #define COPYSTR(to, from) \
260 do { \
261 size_t count = strlen((from)); \
262 (to) = _gr_memfrombuf(count+1, &buf, &buflen); \
263 if ((to) == NULL) \
264 return 0; \
265 memmove((to), (from), count); \
266 to[count] = '\0'; \
267 } while (0) /* LINTED */
268
269 COPYSTR(grp->gr_name, fromgrp->gr_name);
270 COPYSTR(grp->gr_passwd, fromgrp->gr_passwd);
271 grp->gr_gid = fromgrp->gr_gid;
272
273 if (fromgrp->gr_mem == NULL)
274 return 0;
275
276 for (memc = 0; fromgrp->gr_mem[memc]; memc++)
277 continue;
278 memc++; /* for final NULL */
279
280 /* grab ALIGNed char **gr_mem from buf */
281 ep = _gr_memfrombuf(memc * sizeof(char *) + ALIGNBYTES, &buf, &buflen);
282 grp->gr_mem = (char **)ALIGN(ep);
283 if (grp->gr_mem == NULL)
284 return 0;
285
286 for (memc = 0; fromgrp->gr_mem[memc]; memc++) {
287 COPYSTR(grp->gr_mem[memc], fromgrp->gr_mem[memc]);
288 }
289
290 #undef COPYSTR
291
292 grp->gr_mem[memc] = NULL;
293 return 1;
294 }
295
296 /*
297 * files methods
298 */
299
300 int
301 __grstart_files(struct __grstate_files *state)
302 {
303
304 _DIAGASSERT(state != NULL);
305
306 if (state->fp == NULL) {
307 state->fp = fopen(_PATH_GROUP, "re");
308 if (state->fp == NULL)
309 return NS_UNAVAIL;
310 } else {
311 rewind(state->fp);
312 }
313 return NS_SUCCESS;
314 }
315
316 int
317 __grend_files(struct __grstate_files *state)
318 {
319
320 _DIAGASSERT(state != NULL);
321
322 if (state->fp) {
323 (void) fclose(state->fp);
324 state->fp = NULL;
325 }
326 return NS_SUCCESS;
327 }
328
329 /*
330 * __grscan_files
331 * Scan state->fp for the next desired entry.
332 * If search is zero, return the next entry.
333 * If search is non-zero, look for a specific name (if name != NULL),
334 * or a specific gid (if name == NULL).
335 * Sets *retval to the errno if the result is not NS_SUCCESS
336 * or NS_NOTFOUND.
337 */
338 int
339 __grscan_files(int *retval, struct group *grp, char *buffer, size_t buflen,
340 struct __grstate_files *state, int search, const char *name, gid_t gid)
341 {
342 int rv;
343 char filebuf[_GETGR_R_SIZE_MAX], *ep;
344
345 _DIAGASSERT(retval != NULL);
346 _DIAGASSERT(grp != NULL);
347 _DIAGASSERT(buffer != NULL);
348 _DIAGASSERT(state != NULL);
349 /* name is NULL to indicate searching for gid */
350
351 *retval = 0;
352
353 if (state->fp == NULL) { /* only start if file not open yet */
354 rv = __grstart_files(state);
355 if (rv != NS_SUCCESS)
356 goto filesgrscan_out;
357 }
358
359 rv = NS_NOTFOUND;
360
361 /* scan line by line */
362 while (fgets(filebuf, (int)sizeof(filebuf), state->fp) != NULL) {
363 ep = strchr(filebuf, '\n');
364 if (ep == NULL) { /* skip lines that are too big */
365 int ch;
366
367 while ((ch = getc(state->fp)) != '\n' && ch != EOF)
368 continue;
369 continue;
370 }
371 *ep = '\0'; /* clear trailing \n */
372
373 if (filebuf[0] == '+') /* skip compat line */
374 continue;
375
376 /* validate line */
377 if (! _gr_parse(filebuf, grp, buffer, buflen)) {
378 continue; /* skip bad lines */
379 }
380 if (! search) { /* just want this one */
381 rv = NS_SUCCESS;
382 break;
383 }
384 /* want specific */
385 if ((name && strcmp(name, grp->gr_name) == 0) ||
386 (!name && gid == grp->gr_gid)) {
387 rv = NS_SUCCESS;
388 break;
389 }
390 }
391
392 filesgrscan_out:
393 if (rv != NS_SUCCESS && rv != NS_NOTFOUND)
394 *retval = errno;
395 return rv;
396 }
397
398
399 static struct __grstate_files _files_state;
400 /* storage for non _r functions */
401 static struct group _files_group;
402 static char _files_groupbuf[_GETGR_R_SIZE_MAX];
403
404 /*ARGSUSED*/
405 static int
406 _files_setgrent(void *nsrv, void *nscb, va_list ap)
407 {
408
409 _files_state.stayopen = 0;
410 return __grstart_files(&_files_state);
411 }
412
413 /*ARGSUSED*/
414 static int
415 _files_setgroupent(void *nsrv, void *nscb, va_list ap)
416 {
417 int *retval = va_arg(ap, int *);
418 int stayopen = va_arg(ap, int);
419
420 int rv;
421
422 _files_state.stayopen = stayopen;
423 rv = __grstart_files(&_files_state);
424 *retval = (rv == NS_SUCCESS);
425 return rv;
426 }
427
428 /*ARGSUSED*/
429 static int
430 _files_endgrent(void *nsrv, void *nscb, va_list ap)
431 {
432
433 _files_state.stayopen = 0;
434 return __grend_files(&_files_state);
435 }
436
437 /*ARGSUSED*/
438 static int
439 _files_getgrent(void *nsrv, void *nscb, va_list ap)
440 {
441 struct group **retval = va_arg(ap, struct group **);
442
443 int rv, rerror;
444
445 _DIAGASSERT(retval != NULL);
446
447 *retval = NULL;
448 rv = __grscan_files(&rerror, &_files_group,
449 _files_groupbuf, sizeof(_files_groupbuf),
450 &_files_state, 0, NULL, 0);
451 if (rv == NS_SUCCESS)
452 *retval = &_files_group;
453 return rv;
454 }
455
456 /*ARGSUSED*/
457 static int
458 _files_getgrent_r(void *nsrv, void *nscb, va_list ap)
459 {
460 int *retval = va_arg(ap, int *);
461 struct group *grp = va_arg(ap, struct group *);
462 char *buffer = va_arg(ap, char *);
463 size_t buflen = va_arg(ap, size_t);
464 struct group **result = va_arg(ap, struct group **);
465
466 int rv;
467
468 _DIAGASSERT(retval != NULL);
469 _DIAGASSERT(grp != NULL);
470 _DIAGASSERT(buffer != NULL);
471 _DIAGASSERT(result != NULL);
472
473 rv = __grscan_files(retval, grp, buffer, buflen,
474 &_files_state, 0, NULL, 0);
475 if (rv == NS_SUCCESS)
476 *result = grp;
477 else
478 *result = NULL;
479 return rv;
480 }
481
482 /*ARGSUSED*/
483 static int
484 _files_getgrgid(void *nsrv, void *nscb, va_list ap)
485 {
486 struct group **retval = va_arg(ap, struct group **);
487 gid_t gid = va_arg(ap, gid_t);
488
489 int rv, rerror;
490
491 _DIAGASSERT(retval != NULL);
492
493 *retval = NULL;
494 rv = __grstart_files(&_files_state);
495 if (rv != NS_SUCCESS)
496 return rv;
497 rv = __grscan_files(&rerror, &_files_group,
498 _files_groupbuf, sizeof(_files_groupbuf),
499 &_files_state, 1, NULL, gid);
500 if (!_files_state.stayopen)
501 __grend_files(&_files_state);
502 if (rv == NS_SUCCESS)
503 *retval = &_files_group;
504 return rv;
505 }
506
507 /*ARGSUSED*/
508 static int
509 _files_getgrgid_r(void *nsrv, void *nscb, va_list ap)
510 {
511 int *retval = va_arg(ap, int *);
512 gid_t gid = va_arg(ap, gid_t);
513 struct group *grp = va_arg(ap, struct group *);
514 char *buffer = va_arg(ap, char *);
515 size_t buflen = va_arg(ap, size_t);
516 struct group **result = va_arg(ap, struct group **);
517
518 struct __grstate_files state;
519 int rv;
520
521 _DIAGASSERT(retval != NULL);
522 _DIAGASSERT(grp != NULL);
523 _DIAGASSERT(buffer != NULL);
524 _DIAGASSERT(result != NULL);
525
526 *result = NULL;
527 memset(&state, 0, sizeof(state));
528 rv = __grscan_files(retval, grp, buffer, buflen, &state, 1, NULL, gid);
529 __grend_files(&state);
530 if (rv == NS_SUCCESS)
531 *result = grp;
532 return rv;
533 }
534
535 /*ARGSUSED*/
536 static int
537 _files_getgrnam(void *nsrv, void *nscb, va_list ap)
538 {
539 struct group **retval = va_arg(ap, struct group **);
540 const char *name = va_arg(ap, const char *);
541
542 int rv, rerror;
543
544 _DIAGASSERT(retval != NULL);
545
546 *retval = NULL;
547 rv = __grstart_files(&_files_state);
548 if (rv != NS_SUCCESS)
549 return rv;
550 rv = __grscan_files(&rerror, &_files_group,
551 _files_groupbuf, sizeof(_files_groupbuf),
552 &_files_state, 1, name, 0);
553 if (!_files_state.stayopen)
554 __grend_files(&_files_state);
555 if (rv == NS_SUCCESS)
556 *retval = &_files_group;
557 return rv;
558 }
559
560 /*ARGSUSED*/
561 static int
562 _files_getgrnam_r(void *nsrv, void *nscb, va_list ap)
563 {
564 int *retval = va_arg(ap, int *);
565 const char *name = va_arg(ap, const char *);
566 struct group *grp = va_arg(ap, struct group *);
567 char *buffer = va_arg(ap, char *);
568 size_t buflen = va_arg(ap, size_t);
569 struct group **result = va_arg(ap, struct group **);
570
571 struct __grstate_files state;
572 int rv;
573
574 _DIAGASSERT(retval != NULL);
575 _DIAGASSERT(grp != NULL);
576 _DIAGASSERT(buffer != NULL);
577 _DIAGASSERT(result != NULL);
578
579 *result = NULL;
580 memset(&state, 0, sizeof(state));
581 rv = __grscan_files(retval, grp, buffer, buflen, &state, 1, name, 0);
582 __grend_files(&state);
583 if (rv == NS_SUCCESS)
584 *result = grp;
585 return rv;
586 }
587
588
589 #ifdef HESIOD
590 /*
591 * dns methods
592 */
593
594 int
595 __grstart_dns(struct __grstate_dns *state)
596 {
597
598 _DIAGASSERT(state != NULL);
599
600 state->num = 0;
601 if (state->context == NULL) { /* setup Hesiod */
602 if (hesiod_init(&state->context) == -1)
603 return NS_UNAVAIL;
604 }
605
606 return NS_SUCCESS;
607 }
608
609 int
610 __grend_dns(struct __grstate_dns *state)
611 {
612
613 _DIAGASSERT(state != NULL);
614
615 state->num = 0;
616 if (state->context) {
617 hesiod_end(state->context);
618 state->context = NULL;
619 }
620 return NS_SUCCESS;
621 }
622
623 /*
624 * __grscan_dns
625 * Search Hesiod for the next desired entry.
626 * If search is zero, return the next entry.
627 * If search is non-zero, look for a specific name (if name != NULL),
628 * or a specific gid (if name == NULL).
629 */
630 int
631 __grscan_dns(int *retval, struct group *grp, char *buffer, size_t buflen,
632 struct __grstate_dns *state, int search, const char *name, gid_t gid)
633 {
634 const char **curzone;
635 char **hp, *ep;
636 int rv;
637
638 static const char *zones_gid_group[] = {
639 "gid",
640 "group",
641 NULL
642 };
643
644 static const char *zones_group[] = {
645 "group",
646 NULL
647 };
648
649 _DIAGASSERT(retval != NULL);
650 _DIAGASSERT(grp != NULL);
651 _DIAGASSERT(buffer != NULL);
652 _DIAGASSERT(state != NULL);
653 /* name is NULL to indicate searching for gid */
654
655 *retval = 0;
656
657 if (state->context == NULL) { /* only start if Hesiod not setup */
658 rv = __grstart_dns(state);
659 if (rv != NS_SUCCESS)
660 return rv;
661 }
662
663 next_dns_entry:
664 hp = NULL;
665 rv = NS_NOTFOUND;
666
667 if (! search) { /* find next entry */
668 if (state->num == -1) /* exhausted search */
669 return NS_NOTFOUND;
670 /* find group-NNN */
671 snprintf(buffer, buflen, "group-%u", state->num);
672 state->num++;
673 curzone = zones_group;
674 } else if (name) { /* find group name */
675 snprintf(buffer, buflen, "%s", name);
676 curzone = zones_group;
677 } else { /* find gid */
678 snprintf(buffer, buflen, "%u", (unsigned int)gid);
679 curzone = zones_gid_group;
680 }
681
682 for (; *curzone; curzone++) { /* search zones */
683 hp = hesiod_resolve(state->context, buffer, *curzone);
684 if (hp != NULL)
685 break;
686 if (errno != ENOENT) {
687 rv = NS_UNAVAIL;
688 goto dnsgrscan_out;
689 }
690 }
691 if (*curzone == NULL) {
692 if (! search)
693 state->num = -1;
694 goto dnsgrscan_out;
695 }
696
697 if ((ep = strchr(hp[0], '\n')) != NULL)
698 *ep = '\0'; /* clear trailing \n */
699 if (_gr_parse(hp[0], grp, buffer, buflen)) { /* validate line */
700 if (! search) { /* just want this one */
701 rv = NS_SUCCESS;
702 } else if ((name && strcmp(name, grp->gr_name) == 0) ||
703 (!name && gid == grp->gr_gid)) { /* want specific */
704 rv = NS_SUCCESS;
705 }
706 } else { /* dodgy entry */
707 if (!search) { /* try again if ! searching */
708 hesiod_free_list(state->context, hp);
709 goto next_dns_entry;
710 }
711 }
712
713 dnsgrscan_out:
714 if (rv != NS_SUCCESS && rv != NS_NOTFOUND)
715 *retval = errno;
716 if (hp)
717 hesiod_free_list(state->context, hp);
718 return rv;
719 }
720
721 static struct __grstate_dns _dns_state;
722 /* storage for non _r functions */
723 static struct group _dns_group;
724 static char _dns_groupbuf[_GETGR_R_SIZE_MAX];
725
726 /*ARGSUSED*/
727 static int
728 _dns_setgrent(void *nsrv, void *nscb, va_list ap)
729 {
730
731 _dns_state.stayopen = 0;
732 return __grstart_dns(&_dns_state);
733 }
734
735 /*ARGSUSED*/
736 static int
737 _dns_setgroupent(void *nsrv, void *nscb, va_list ap)
738 {
739 int *retval = va_arg(ap, int *);
740 int stayopen = va_arg(ap, int);
741
742 int rv;
743
744 _dns_state.stayopen = stayopen;
745 rv = __grstart_dns(&_dns_state);
746 *retval = (rv == NS_SUCCESS);
747 return rv;
748 }
749
750 /*ARGSUSED*/
751 static int
752 _dns_endgrent(void *nsrv, void *nscb, va_list ap)
753 {
754
755 _dns_state.stayopen = 0;
756 return __grend_dns(&_dns_state);
757 }
758
759 /*ARGSUSED*/
760 static int
761 _dns_getgrent(void *nsrv, void *nscb, va_list ap)
762 {
763 struct group **retval = va_arg(ap, struct group **);
764
765 int rv, rerror;
766
767 _DIAGASSERT(retval != NULL);
768
769 *retval = NULL;
770 rv = __grscan_dns(&rerror, &_dns_group,
771 _dns_groupbuf, sizeof(_dns_groupbuf), &_dns_state, 0, NULL, 0);
772 if (rv == NS_SUCCESS)
773 *retval = &_dns_group;
774 return rv;
775 }
776
777 /*ARGSUSED*/
778 static int
779 _dns_getgrent_r(void *nsrv, void *nscb, va_list ap)
780 {
781 int *retval = va_arg(ap, int *);
782 struct group *grp = va_arg(ap, struct group *);
783 char *buffer = va_arg(ap, char *);
784 size_t buflen = va_arg(ap, size_t);
785 struct group **result = va_arg(ap, struct group **);
786
787 int rv;
788
789 _DIAGASSERT(retval != NULL);
790 _DIAGASSERT(grp != NULL);
791 _DIAGASSERT(buffer != NULL);
792 _DIAGASSERT(result != NULL);
793
794 rv = __grscan_dns(retval, grp, buffer, buflen,
795 &_dns_state, 0, NULL, 0);
796 if (rv == NS_SUCCESS)
797 *result = grp;
798 else
799 *result = NULL;
800 return rv;
801 }
802 /*ARGSUSED*/
803 static int
804 _dns_getgrgid(void *nsrv, void *nscb, va_list ap)
805 {
806 struct group **retval = va_arg(ap, struct group **);
807 gid_t gid = va_arg(ap, gid_t);
808
809 int rv, rerror;
810
811 _DIAGASSERT(retval != NULL);
812
813 *retval = NULL;
814 rv = __grstart_dns(&_dns_state);
815 if (rv != NS_SUCCESS)
816 return rv;
817 rv = __grscan_dns(&rerror, &_dns_group,
818 _dns_groupbuf, sizeof(_dns_groupbuf), &_dns_state, 1, NULL, gid);
819 if (!_dns_state.stayopen)
820 __grend_dns(&_dns_state);
821 if (rv == NS_SUCCESS)
822 *retval = &_dns_group;
823 return rv;
824 }
825
826 /*ARGSUSED*/
827 static int
828 _dns_getgrgid_r(void *nsrv, void *nscb, va_list ap)
829 {
830 int *retval = va_arg(ap, int *);
831 gid_t gid = va_arg(ap, gid_t);
832 struct group *grp = va_arg(ap, struct group *);
833 char *buffer = va_arg(ap, char *);
834 size_t buflen = va_arg(ap, size_t);
835 struct group **result = va_arg(ap, struct group **);
836
837 struct __grstate_dns state;
838 int rv;
839
840 _DIAGASSERT(retval != NULL);
841 _DIAGASSERT(grp != NULL);
842 _DIAGASSERT(buffer != NULL);
843 _DIAGASSERT(result != NULL);
844
845 *result = NULL;
846 memset(&state, 0, sizeof(state));
847 rv = __grscan_dns(retval, grp, buffer, buflen, &state, 1, NULL, gid);
848 __grend_dns(&state);
849 if (rv == NS_SUCCESS)
850 *result = grp;
851 return rv;
852 }
853
854 /*ARGSUSED*/
855 static int
856 _dns_getgrnam(void *nsrv, void *nscb, va_list ap)
857 {
858 struct group **retval = va_arg(ap, struct group **);
859 const char *name = va_arg(ap, const char *);
860
861 int rv, rerror;
862
863 _DIAGASSERT(retval != NULL);
864
865 *retval = NULL;
866 rv = __grstart_dns(&_dns_state);
867 if (rv != NS_SUCCESS)
868 return rv;
869 rv = __grscan_dns(&rerror, &_dns_group,
870 _dns_groupbuf, sizeof(_dns_groupbuf), &_dns_state, 1, name, 0);
871 if (!_dns_state.stayopen)
872 __grend_dns(&_dns_state);
873 if (rv == NS_SUCCESS)
874 *retval = &_dns_group;
875 return rv;
876 }
877
878 /*ARGSUSED*/
879 static int
880 _dns_getgrnam_r(void *nsrv, void *nscb, va_list ap)
881 {
882 int *retval = va_arg(ap, int *);
883 const char *name = va_arg(ap, const char *);
884 struct group *grp = va_arg(ap, struct group *);
885 char *buffer = va_arg(ap, char *);
886 size_t buflen = va_arg(ap, size_t);
887 struct group **result = va_arg(ap, struct group **);
888
889 struct __grstate_dns state;
890 int rv;
891
892 _DIAGASSERT(retval != NULL);
893 _DIAGASSERT(grp != NULL);
894 _DIAGASSERT(buffer != NULL);
895 _DIAGASSERT(result != NULL);
896
897 *result = NULL;
898 memset(&state, 0, sizeof(state));
899 rv = __grscan_dns(retval, grp, buffer, buflen, &state, 1, name, 0);
900 __grend_dns(&state);
901 if (rv == NS_SUCCESS)
902 *result = grp;
903 return rv;
904 }
905
906 #endif /* HESIOD */
907
908
909 #ifdef YP
910 /*
911 * nis methods
912 */
913
914 int
915 __grstart_nis(struct __grstate_nis *state)
916 {
917
918 _DIAGASSERT(state != NULL);
919
920 state->done = 0;
921 if (state->current) {
922 free(state->current);
923 state->current = NULL;
924 }
925 if (state->domain == NULL) { /* setup NIS */
926 switch (yp_get_default_domain(&state->domain)) {
927 case 0:
928 break;
929 case YPERR_RESRC:
930 return NS_TRYAGAIN;
931 default:
932 return NS_UNAVAIL;
933 }
934 }
935 return NS_SUCCESS;
936 }
937
938 int
939 __grend_nis(struct __grstate_nis *state)
940 {
941
942 _DIAGASSERT(state != NULL);
943
944 if (state->domain) {
945 state->domain = NULL;
946 }
947 state->done = 0;
948 if (state->current) {
949 free(state->current);
950 state->current = NULL;
951 }
952 return NS_SUCCESS;
953 }
954
955 /*
956 * __grscan_nis
957 * Search NIS for the next desired entry.
958 * If search is zero, return the next entry.
959 * If search is non-zero, look for a specific name (if name != NULL),
960 * or a specific gid (if name == NULL).
961 */
962 int
963 __grscan_nis(int *retval, struct group *grp, char *buffer, size_t buflen,
964 struct __grstate_nis *state, int search, const char *name, gid_t gid)
965 {
966 const char *map;
967 char *key, *data;
968 int nisr, rv, keylen, datalen;
969
970 _DIAGASSERT(retval != NULL);
971 _DIAGASSERT(grp != NULL);
972 _DIAGASSERT(buffer != NULL);
973 _DIAGASSERT(state != NULL);
974 /* name is NULL to indicate searching for gid */
975
976 *retval = 0;
977
978 if (state->domain == NULL) { /* only start if NIS not setup */
979 rv = __grstart_nis(state);
980 if (rv != NS_SUCCESS)
981 return rv;
982 }
983
984 next_nis_entry:
985 key = NULL;
986 data = NULL;
987 rv = NS_SUCCESS;
988
989 if (! search) { /* find next entry */
990 if (state->done) /* exhausted search */
991 return NS_NOTFOUND;
992 map = "group.byname";
993 if (state->current) { /* already searching */
994 nisr = yp_next(state->domain, map,
995 state->current, state->currentlen,
996 &key, &keylen, &data, &datalen);
997 free(state->current);
998 state->current = NULL;
999 switch (nisr) {
1000 case 0:
1001 state->current = key;
1002 state->currentlen = keylen;
1003 key = NULL;
1004 break;
1005 case YPERR_NOMORE:
1006 rv = NS_NOTFOUND;
1007 state->done = 1;
1008 break;
1009 default:
1010 rv = NS_UNAVAIL;
1011 break;
1012 }
1013 } else { /* new search */
1014 if (yp_first(state->domain, map,
1015 &state->current, &state->currentlen,
1016 &data, &datalen)) {
1017 rv = NS_UNAVAIL;
1018 }
1019 }
1020 } else { /* search for specific item */
1021 if (name) { /* find group name */
1022 snprintf(buffer, buflen, "%s", name);
1023 map = "group.byname";
1024 } else { /* find gid */
1025 snprintf(buffer, buflen, "%u", (unsigned int)gid);
1026 map = "group.bygid";
1027 }
1028 nisr = yp_match(state->domain, map, buffer, (int)strlen(buffer),
1029 &data, &datalen);
1030 switch (nisr) {
1031 case 0:
1032 break;
1033 case YPERR_KEY:
1034 rv = NS_NOTFOUND;
1035 break;
1036 default:
1037 rv = NS_UNAVAIL;
1038 break;
1039 }
1040 }
1041 if (rv == NS_SUCCESS) { /* validate data */
1042 data[datalen] = '\0'; /* clear trailing \n */
1043 if (_gr_parse(data, grp, buffer, buflen)) {
1044 if (! search) { /* just want this one */
1045 rv = NS_SUCCESS;
1046 } else if ((name && strcmp(name, grp->gr_name) == 0) ||
1047 (!name && gid == grp->gr_gid)) {
1048 /* want specific */
1049 rv = NS_SUCCESS;
1050 }
1051 } else { /* dodgy entry */
1052 if (!search) { /* try again if ! searching */
1053 free(data);
1054 goto next_nis_entry;
1055 }
1056 }
1057 }
1058
1059 if (rv != NS_SUCCESS && rv != NS_NOTFOUND)
1060 *retval = errno;
1061 if (key)
1062 free(key);
1063 if (data)
1064 free(data);
1065 return rv;
1066 }
1067
1068 static struct __grstate_nis _nis_state;
1069 /* storage for non _r functions */
1070 static struct group _nis_group;
1071 static char _nis_groupbuf[_GETGR_R_SIZE_MAX];
1072
1073 /*ARGSUSED*/
1074 static int
1075 _nis_setgrent(void *nsrv, void *nscb, va_list ap)
1076 {
1077
1078 _nis_state.stayopen = 0;
1079 return __grstart_nis(&_nis_state);
1080 }
1081
1082 /*ARGSUSED*/
1083 static int
1084 _nis_setgroupent(void *nsrv, void *nscb, va_list ap)
1085 {
1086 int *retval = va_arg(ap, int *);
1087 int stayopen = va_arg(ap, int);
1088
1089 int rv;
1090
1091 _nis_state.stayopen = stayopen;
1092 rv = __grstart_nis(&_nis_state);
1093 *retval = (rv == NS_SUCCESS);
1094 return rv;
1095 }
1096
1097 /*ARGSUSED*/
1098 static int
1099 _nis_endgrent(void *nsrv, void *nscb, va_list ap)
1100 {
1101
1102 return __grend_nis(&_nis_state);
1103 }
1104
1105 /*ARGSUSED*/
1106 static int
1107 _nis_getgrent(void *nsrv, void *nscb, va_list ap)
1108 {
1109 struct group **retval = va_arg(ap, struct group **);
1110
1111 int rv, rerror;
1112
1113 _DIAGASSERT(retval != NULL);
1114
1115 *retval = NULL;
1116 rv = __grscan_nis(&rerror, &_nis_group,
1117 _nis_groupbuf, sizeof(_nis_groupbuf), &_nis_state, 0, NULL, 0);
1118 if (rv == NS_SUCCESS)
1119 *retval = &_nis_group;
1120 return rv;
1121 }
1122
1123 /*ARGSUSED*/
1124 static int
1125 _nis_getgrent_r(void *nsrv, void *nscb, va_list ap)
1126 {
1127 int *retval = va_arg(ap, int *);
1128 struct group *grp = va_arg(ap, struct group *);
1129 char *buffer = va_arg(ap, char *);
1130 size_t buflen = va_arg(ap, size_t);
1131 struct group **result = va_arg(ap, struct group **);
1132
1133 int rv;
1134
1135 _DIAGASSERT(retval != NULL);
1136 _DIAGASSERT(grp != NULL);
1137 _DIAGASSERT(buffer != NULL);
1138 _DIAGASSERT(result != NULL);
1139
1140 rv = __grscan_nis(retval, grp, buffer, buflen,
1141 &_nis_state, 0, NULL, 0);
1142 if (rv == NS_SUCCESS)
1143 *result = grp;
1144 else
1145 *result = NULL;
1146 return rv;
1147 }
1148
1149 /*ARGSUSED*/
1150 static int
1151 _nis_getgrgid(void *nsrv, void *nscb, va_list ap)
1152 {
1153 struct group **retval = va_arg(ap, struct group **);
1154 gid_t gid = va_arg(ap, gid_t);
1155
1156 int rv, rerror;
1157
1158 _DIAGASSERT(retval != NULL);
1159
1160 *retval = NULL;
1161 rv = __grstart_nis(&_nis_state);
1162 if (rv != NS_SUCCESS)
1163 return rv;
1164 rv = __grscan_nis(&rerror, &_nis_group,
1165 _nis_groupbuf, sizeof(_nis_groupbuf), &_nis_state, 1, NULL, gid);
1166 if (!_nis_state.stayopen)
1167 __grend_nis(&_nis_state);
1168 if (rv == NS_SUCCESS)
1169 *retval = &_nis_group;
1170 return rv;
1171 }
1172
1173 /*ARGSUSED*/
1174 static int
1175 _nis_getgrgid_r(void *nsrv, void *nscb, va_list ap)
1176 {
1177 int *retval = va_arg(ap, int *);
1178 gid_t gid = va_arg(ap, gid_t);
1179 struct group *grp = va_arg(ap, struct group *);
1180 char *buffer = va_arg(ap, char *);
1181 size_t buflen = va_arg(ap, size_t);
1182 struct group **result = va_arg(ap, struct group **);
1183
1184 struct __grstate_nis state;
1185 int rv;
1186
1187 _DIAGASSERT(retval != NULL);
1188 _DIAGASSERT(grp != NULL);
1189 _DIAGASSERT(buffer != NULL);
1190 _DIAGASSERT(result != NULL);
1191
1192 *result = NULL;
1193 /* remark: we run under a global mutex inside of this module ... */
1194 if (_nis_state.stayopen)
1195 { /* use global state only if stayopen is set - otherwiese we would blow up getgrent_r() ... */
1196 rv = __grscan_nis(retval, grp, buffer, buflen, &_nis_state, 1, NULL, gid);
1197 }
1198 else
1199 {
1200 memset(&state, 0, sizeof(state));
1201 rv = __grscan_nis(retval, grp, buffer, buflen, &state, 1, NULL, gid);
1202 __grend_nis(&state);
1203 }
1204 if (rv == NS_SUCCESS)
1205 *result = grp;
1206 return rv;
1207 }
1208
1209 /*ARGSUSED*/
1210 static int
1211 _nis_getgrnam(void *nsrv, void *nscb, va_list ap)
1212 {
1213 struct group **retval = va_arg(ap, struct group **);
1214 const char *name = va_arg(ap, const char *);
1215
1216 int rv, rerror;
1217
1218 _DIAGASSERT(retval != NULL);
1219
1220 *retval = NULL;
1221 rv = __grstart_nis(&_nis_state);
1222 if (rv != NS_SUCCESS)
1223 return rv;
1224 rv = __grscan_nis(&rerror, &_nis_group,
1225 _nis_groupbuf, sizeof(_nis_groupbuf), &_nis_state, 1, name, 0);
1226 if (!_nis_state.stayopen)
1227 __grend_nis(&_nis_state);
1228 if (rv == NS_SUCCESS)
1229 *retval = &_nis_group;
1230 return rv;
1231 }
1232
1233 /*ARGSUSED*/
1234 static int
1235 _nis_getgrnam_r(void *nsrv, void *nscb, va_list ap)
1236 {
1237 int *retval = va_arg(ap, int *);
1238 const char *name = va_arg(ap, const char *);
1239 struct group *grp = va_arg(ap, struct group *);
1240 char *buffer = va_arg(ap, char *);
1241 size_t buflen = va_arg(ap, size_t);
1242 struct group **result = va_arg(ap, struct group **);
1243
1244 struct __grstate_nis state;
1245 int rv;
1246
1247 _DIAGASSERT(retval != NULL);
1248 _DIAGASSERT(grp != NULL);
1249 _DIAGASSERT(buffer != NULL);
1250 _DIAGASSERT(result != NULL);
1251
1252 *result = NULL;
1253 /* remark: we run under a global mutex inside of this module ... */
1254 if (_nis_state.stayopen)
1255 { /* use global state only if stayopen is set - otherwiese we would blow up getgrent_r() ... */
1256 rv = __grscan_nis(retval, grp, buffer, buflen, &_nis_state, 1, name, 0);
1257 }
1258 else
1259 {
1260 memset(&state, 0, sizeof(state));
1261 rv = __grscan_nis(retval, grp, buffer, buflen, &state, 1, name, 0);
1262 __grend_nis(&state);
1263 }
1264 if (rv == NS_SUCCESS)
1265 *result = grp;
1266 return rv;
1267 }
1268
1269 #endif /* YP */
1270
1271
1272 #ifdef _GROUP_COMPAT
1273 /*
1274 * compat methods
1275 */
1276
1277 int
1278 __grstart_compat(struct __grstate_compat *state)
1279 {
1280
1281 _DIAGASSERT(state != NULL);
1282
1283 if (state->fp == NULL) {
1284 state->fp = fopen(_PATH_GROUP, "re");
1285 if (state->fp == NULL)
1286 return NS_UNAVAIL;
1287 } else {
1288 rewind(state->fp);
1289 }
1290 return NS_SUCCESS;
1291 }
1292
1293 int
1294 __grend_compat(struct __grstate_compat *state)
1295 {
1296
1297 _DIAGASSERT(state != NULL);
1298
1299 if (state->name) {
1300 free(state->name);
1301 state->name = NULL;
1302 }
1303 if (state->fp) {
1304 (void) fclose(state->fp);
1305 state->fp = NULL;
1306 }
1307 return NS_SUCCESS;
1308 }
1309
1310
1311 /*
1312 * __grbad_compat
1313 * log an error if "files" or "compat" is specified in
1314 * group_compat database
1315 */
1316 /*ARGSUSED*/
1317 int
1318 __grbad_compat(void *nsrv, void *nscb, va_list ap)
1319 {
1320 static int warned;
1321
1322 _DIAGASSERT(nsrv != NULL);
1323 _DIAGASSERT(nscb != NULL);
1324
1325 if (!warned) {
1326 syslog(LOG_ERR,
1327 "nsswitch.conf group_compat database can't use '%s'",
1328 (const char *)nscb);
1329 }
1330 warned = 1;
1331 return NS_UNAVAIL;
1332 }
1333
1334 /*
1335 * __grscan_compat
1336 * Scan state->fp for the next desired entry.
1337 * If search is zero, return the next entry.
1338 * If search is non-zero, look for a specific name (if name != NULL),
1339 * or a specific gid (if name == NULL).
1340 * Sets *retval to the errno if the result is not NS_SUCCESS or
1341 * NS_NOTFOUND.
1342 *
1343 * searchfunc is invoked when a compat "+" lookup is required;
1344 * searchcookie is passed as the first argument to searchfunc,
1345 * the second argument is the group result.
1346 * This should return NS_NOTFOUND when "no more groups" from compat src.
1347 * If searchfunc is NULL then nsdispatch of getgrent is used.
1348 * This is primarily intended for getgroupmembership(3)'s compat backend.
1349 */
1350 int
1351 __grscan_compat(int *retval, struct group *grp, char *buffer, size_t buflen,
1352 struct __grstate_compat *state, int search, const char *name, gid_t gid,
1353 int (*searchfunc)(void *, struct group **), void *searchcookie)
1354 {
1355 int rv;
1356 char filebuf[_GETGR_R_SIZE_MAX], *ep;
1357
1358 static const ns_dtab compatentdtab[] = {
1359 NS_FILES_CB(__grbad_compat, "files")
1360 NS_DNS_CB(_dns_getgrent_r, NULL)
1361 NS_NIS_CB(_nis_getgrent_r, NULL)
1362 NS_COMPAT_CB(__grbad_compat, "compat")
1363 NS_NULL_CB
1364 };
1365 static const ns_dtab compatgiddtab[] = {
1366 NS_FILES_CB(__grbad_compat, "files")
1367 NS_DNS_CB(_dns_getgrgid_r, NULL)
1368 NS_NIS_CB(_nis_getgrgid_r, NULL)
1369 NS_COMPAT_CB(__grbad_compat, "compat")
1370 NS_NULL_CB
1371 };
1372 static const ns_dtab compatnamdtab[] = {
1373 NS_FILES_CB(__grbad_compat, "files")
1374 NS_DNS_CB(_dns_getgrnam_r, NULL)
1375 NS_NIS_CB(_nis_getgrnam_r, NULL)
1376 NS_COMPAT_CB(__grbad_compat, "compat")
1377 NS_NULL_CB
1378 };
1379
1380 _DIAGASSERT(retval != NULL);
1381 _DIAGASSERT(grp != NULL);
1382 _DIAGASSERT(buffer != NULL);
1383 _DIAGASSERT(state != NULL);
1384 /* name is NULL to indicate searching for gid */
1385
1386 *retval = 0;
1387
1388 if (state->fp == NULL) { /* only start if file not open yet */
1389 rv = __grstart_compat(state);
1390 if (rv != NS_SUCCESS)
1391 goto compatgrscan_out;
1392 }
1393 rv = NS_NOTFOUND;
1394
1395 for (;;) { /* loop through file */
1396 if (state->name != NULL) {
1397 /* processing compat entry */
1398 int crv, cretval;
1399 struct group cgrp, *cgrpres;
1400
1401 if (state->name[0]) { /* specific +group: */
1402 crv = nsdispatch(NULL, compatnamdtab,
1403 NSDB_GROUP_COMPAT, "getgrnam_r",
1404 __nsdefaultnis,
1405 &cretval, state->name,
1406 &cgrp, filebuf, sizeof(filebuf), &cgrpres);
1407 free(state->name); /* (only check 1 grp) */
1408 state->name = NULL;
1409 } else if (!search) { /* any group */
1410 if (searchfunc) {
1411 crv = searchfunc(searchcookie,
1412 &cgrpres);
1413 } else {
1414 crv = nsdispatch(NULL, compatentdtab,
1415 NSDB_GROUP_COMPAT, "getgrent_r",
1416 __nsdefaultnis,
1417 &cretval, &cgrp, filebuf,
1418 sizeof(filebuf), &cgrpres);
1419 }
1420 } else if (name) { /* specific group */
1421 crv = nsdispatch(NULL, compatnamdtab,
1422 NSDB_GROUP_COMPAT, "getgrnam_r",
1423 __nsdefaultnis,
1424 &cretval, name,
1425 &cgrp, filebuf, sizeof(filebuf), &cgrpres);
1426 } else { /* specific gid */
1427 crv = nsdispatch(NULL, compatgiddtab,
1428 NSDB_GROUP_COMPAT, "getgrgid_r",
1429 __nsdefaultnis,
1430 &cretval, gid,
1431 &cgrp, filebuf, sizeof(filebuf), &cgrpres);
1432 }
1433 if (crv != NS_SUCCESS) { /* not found */
1434 free(state->name);
1435 state->name = NULL;
1436 continue; /* try next line */
1437 }
1438 if (!_gr_copy(cgrpres, grp, buffer, buflen)) {
1439 rv = NS_UNAVAIL;
1440 break;
1441 }
1442 goto compatgrscan_cmpgrp; /* skip to grp test */
1443 }
1444
1445 /* get next file line */
1446 if (fgets(filebuf, (int)sizeof(filebuf), state->fp) == NULL)
1447 break;
1448
1449 ep = strchr(filebuf, '\n');
1450 if (ep == NULL) { /* skip lines that are too big */
1451 int ch;
1452
1453 while ((ch = getc(state->fp)) != '\n' && ch != EOF)
1454 continue;
1455 continue;
1456 }
1457 *ep = '\0'; /* clear trailing \n */
1458
1459 if (filebuf[0] == '+') { /* parse compat line */
1460 if (state->name)
1461 free(state->name);
1462 state->name = NULL;
1463 switch(filebuf[1]) {
1464 case ':':
1465 case '\0':
1466 state->name = strdup("");
1467 break;
1468 default:
1469 ep = strchr(filebuf + 1, ':');
1470 if (ep == NULL)
1471 break;
1472 *ep = '\0';
1473 state->name = strdup(filebuf + 1);
1474 break;
1475 }
1476 if (state->name == NULL) {
1477 rv = NS_UNAVAIL;
1478 break;
1479 }
1480 continue;
1481 }
1482
1483 /* validate line */
1484 if (! _gr_parse(filebuf, grp, buffer, buflen)) {
1485 continue; /* skip bad lines */
1486 }
1487
1488 compatgrscan_cmpgrp:
1489 if (! search) { /* just want this one */
1490 rv = NS_SUCCESS;
1491 break;
1492 }
1493 /* want specific */
1494 if ((name && strcmp(name, grp->gr_name) == 0) ||
1495 (!name && gid == grp->gr_gid)) {
1496 rv = NS_SUCCESS;
1497 break;
1498 }
1499
1500 }
1501
1502 compatgrscan_out:
1503 if (rv != NS_SUCCESS && rv != NS_NOTFOUND)
1504 *retval = errno;
1505 return rv;
1506 }
1507
1508 static struct __grstate_compat _compat_state;
1509 /* storage for non _r functions */
1510 static struct group _compat_group;
1511 static char _compat_groupbuf[_GETGR_R_SIZE_MAX];
1512
1513 /*ARGSUSED*/
1514 static int
1515 _compat_setgrent(void *nsrv, void *nscb, va_list ap)
1516 {
1517 static const ns_dtab dtab[] = {
1518 NS_FILES_CB(__grbad_compat, "files")
1519 NS_DNS_CB(_dns_setgrent, NULL)
1520 NS_NIS_CB(_nis_setgrent, NULL)
1521 NS_COMPAT_CB(__grbad_compat, "compat")
1522 NS_NULL_CB
1523 };
1524
1525 /* force group_compat setgrent() */
1526 (void) nsdispatch(NULL, dtab, NSDB_GROUP_COMPAT, "setgrent",
1527 __nsdefaultnis_forceall);
1528
1529 /* reset state, keep fp open */
1530 _compat_state.stayopen = 0;
1531 return __grstart_compat(&_compat_state);
1532 }
1533
1534 /*ARGSUSED*/
1535 static int
1536 _compat_setgroupent(void *nsrv, void *nscb, va_list ap)
1537 {
1538 int *retval = va_arg(ap, int *);
1539 int stayopen = va_arg(ap, int);
1540
1541 int rv;
1542
1543 static const ns_dtab dtab[] = {
1544 NS_FILES_CB(__grbad_compat, "files")
1545 NS_DNS_CB(_dns_setgroupent, NULL)
1546 NS_NIS_CB(_nis_setgroupent, NULL)
1547 NS_COMPAT_CB(__grbad_compat, "compat")
1548 NS_NULL_CB
1549 };
1550
1551 /* force group_compat setgroupent() */
1552 (void) nsdispatch(NULL, dtab, NSDB_GROUP_COMPAT, "setgroupent",
1553 __nsdefaultnis_forceall, &rv, stayopen);
1554
1555 _compat_state.stayopen = stayopen;
1556 rv = __grstart_compat(&_compat_state);
1557 *retval = (rv == NS_SUCCESS);
1558 return rv;
1559 }
1560
1561 /*ARGSUSED*/
1562 static int
1563 _compat_endgrent(void *nsrv, void *nscb, va_list ap)
1564 {
1565 static const ns_dtab dtab[] = {
1566 NS_FILES_CB(__grbad_compat, "files")
1567 NS_DNS_CB(_dns_endgrent, NULL)
1568 NS_NIS_CB(_nis_endgrent, NULL)
1569 NS_COMPAT_CB(__grbad_compat, "compat")
1570 NS_NULL_CB
1571 };
1572
1573 /* force group_compat endgrent() */
1574 (void) nsdispatch(NULL, dtab, NSDB_GROUP_COMPAT, "endgrent",
1575 __nsdefaultnis_forceall);
1576
1577 /* reset state, close fp */
1578 _compat_state.stayopen = 0;
1579 return __grend_compat(&_compat_state);
1580 }
1581
1582 /*ARGSUSED*/
1583 static int
1584 _compat_getgrent(void *nsrv, void *nscb, va_list ap)
1585 {
1586 struct group **retval = va_arg(ap, struct group **);
1587
1588 int rv, rerror;
1589
1590 _DIAGASSERT(retval != NULL);
1591
1592 *retval = NULL;
1593 rv = __grscan_compat(&rerror, &_compat_group,
1594 _compat_groupbuf, sizeof(_compat_groupbuf),
1595 &_compat_state, 0, NULL, 0, NULL, NULL);
1596 if (rv == NS_SUCCESS)
1597 *retval = &_compat_group;
1598 return rv;
1599 }
1600
1601 /*ARGSUSED*/
1602 static int
1603 _compat_getgrent_r(void *nsrv, void *nscb, va_list ap)
1604 {
1605 int *retval = va_arg(ap, int *);
1606 struct group *grp = va_arg(ap, struct group *);
1607 char *buffer = va_arg(ap, char *);
1608 size_t buflen = va_arg(ap, size_t);
1609 struct group **result = va_arg(ap, struct group **);
1610
1611 int rv;
1612
1613 _DIAGASSERT(retval != NULL);
1614 _DIAGASSERT(grp != NULL);
1615 _DIAGASSERT(buffer != NULL);
1616 _DIAGASSERT(result != NULL);
1617
1618 rv = __grscan_compat(retval, grp, buffer, buflen,
1619 &_compat_state, 0, NULL, 0, NULL, NULL);
1620 if (rv == NS_SUCCESS)
1621 *result = grp;
1622 else
1623 *result = NULL;
1624 return rv;
1625 }
1626
1627 /*ARGSUSED*/
1628 static int
1629 _compat_getgrgid(void *nsrv, void *nscb, va_list ap)
1630 {
1631 struct group **retval = va_arg(ap, struct group **);
1632 gid_t gid = va_arg(ap, gid_t);
1633
1634 int rv, rerror;
1635
1636 _DIAGASSERT(retval != NULL);
1637
1638 *retval = NULL;
1639 rv = __grstart_compat(&_compat_state);
1640 if (rv != NS_SUCCESS)
1641 return rv;
1642 rv = __grscan_compat(&rerror, &_compat_group,
1643 _compat_groupbuf, sizeof(_compat_groupbuf),
1644 &_compat_state, 1, NULL, gid, NULL, NULL);
1645 if (!_compat_state.stayopen)
1646 __grend_compat(&_compat_state);
1647 if (rv == NS_SUCCESS)
1648 *retval = &_compat_group;
1649 return rv;
1650 }
1651
1652 /*ARGSUSED*/
1653 static int
1654 _compat_getgrgid_r(void *nsrv, void *nscb, va_list ap)
1655 {
1656 int *retval = va_arg(ap, int *);
1657 gid_t gid = va_arg(ap, gid_t);
1658 struct group *grp = va_arg(ap, struct group *);
1659 char *buffer = va_arg(ap, char *);
1660 size_t buflen = va_arg(ap, size_t);
1661 struct group **result = va_arg(ap, struct group **);
1662
1663 struct __grstate_compat state;
1664 int rv;
1665
1666 _DIAGASSERT(retval != NULL);
1667 _DIAGASSERT(grp != NULL);
1668 _DIAGASSERT(buffer != NULL);
1669 _DIAGASSERT(result != NULL);
1670
1671 *result = NULL;
1672 memset(&state, 0, sizeof(state));
1673 rv = __grscan_compat(retval, grp, buffer, buflen, &state,
1674 1, NULL, gid, NULL, NULL);
1675 __grend_compat(&state);
1676 if (rv == NS_SUCCESS)
1677 *result = grp;
1678 return rv;
1679 }
1680
1681 /*ARGSUSED*/
1682 static int
1683 _compat_getgrnam(void *nsrv, void *nscb, va_list ap)
1684 {
1685 struct group **retval = va_arg(ap, struct group **);
1686 const char *name = va_arg(ap, const char *);
1687
1688 int rv, rerror;
1689
1690 _DIAGASSERT(retval != NULL);
1691
1692 *retval = NULL;
1693 rv = __grstart_compat(&_compat_state);
1694 if (rv != NS_SUCCESS)
1695 return rv;
1696 rv = __grscan_compat(&rerror, &_compat_group,
1697 _compat_groupbuf, sizeof(_compat_groupbuf),
1698 &_compat_state, 1, name, 0, NULL, NULL);
1699 if (!_compat_state.stayopen)
1700 __grend_compat(&_compat_state);
1701 if (rv == NS_SUCCESS)
1702 *retval = &_compat_group;
1703 return rv;
1704 }
1705
1706 /*ARGSUSED*/
1707 static int
1708 _compat_getgrnam_r(void *nsrv, void *nscb, va_list ap)
1709 {
1710 int *retval = va_arg(ap, int *);
1711 const char *name = va_arg(ap, const char *);
1712 struct group *grp = va_arg(ap, struct group *);
1713 char *buffer = va_arg(ap, char *);
1714 size_t buflen = va_arg(ap, size_t);
1715 struct group **result = va_arg(ap, struct group **);
1716
1717 struct __grstate_compat state;
1718 int rv;
1719
1720 _DIAGASSERT(retval != NULL);
1721 _DIAGASSERT(grp != NULL);
1722 _DIAGASSERT(buffer != NULL);
1723 _DIAGASSERT(result != NULL);
1724
1725 *result = NULL;
1726 memset(&state, 0, sizeof(state));
1727 rv = __grscan_compat(retval, grp, buffer, buflen, &state,
1728 1, name, 0, NULL, NULL);
1729 __grend_compat(&state);
1730 if (rv == NS_SUCCESS)
1731 *result = grp;
1732 return rv;
1733 }
1734
1735 #endif /* _GROUP_COMPAT */
1736
1737
1738 /*
1739 * public functions
1740 */
1741
1742 struct group *
1743 getgrent(void)
1744 {
1745 int rv;
1746 struct group *retval;
1747
1748 static const ns_dtab dtab[] = {
1749 NS_FILES_CB(_files_getgrent, NULL)
1750 NS_DNS_CB(_dns_getgrent, NULL)
1751 NS_NIS_CB(_nis_getgrent, NULL)
1752 NS_COMPAT_CB(_compat_getgrent, NULL)
1753 NS_NULL_CB
1754 };
1755
1756 mutex_lock(&__grmutex);
1757 rv = nsdispatch(NULL, dtab, NSDB_GROUP, "getgrent", __nsdefaultcompat,
1758 &retval);
1759 mutex_unlock(&__grmutex);
1760 return (rv == NS_SUCCESS) ? retval : NULL;
1761 }
1762
1763 int
1764 getgrent_r(struct group *grp, char *buffer, size_t buflen,
1765 struct group **result)
1766 {
1767 int rv, retval;
1768
1769 static const ns_dtab dtab[] = {
1770 NS_FILES_CB(_files_getgrent_r, NULL)
1771 NS_DNS_CB(_dns_getgrent_r, NULL)
1772 NS_NIS_CB(_nis_getgrent_r, NULL)
1773 NS_COMPAT_CB(_compat_getgrent_r, NULL)
1774 NS_NULL_CB
1775 };
1776
1777 mutex_lock(&__grmutex);
1778 rv = nsdispatch(NULL, dtab, NSDB_GROUP, "getgrent_r", __nsdefaultcompat,
1779 &retval, grp, buffer, buflen, result);
1780 mutex_unlock(&__grmutex);
1781 switch (rv) {
1782 case NS_SUCCESS:
1783 case NS_NOTFOUND:
1784 return 0;
1785 default:
1786 return retval;
1787 }
1788 }
1789
1790
1791 struct group *
1792 getgrgid(gid_t gid)
1793 {
1794 int rv;
1795 struct group *retval;
1796
1797 static const ns_dtab dtab[] = {
1798 NS_FILES_CB(_files_getgrgid, NULL)
1799 NS_DNS_CB(_dns_getgrgid, NULL)
1800 NS_NIS_CB(_nis_getgrgid, NULL)
1801 NS_COMPAT_CB(_compat_getgrgid, NULL)
1802 NS_NULL_CB
1803 };
1804
1805 mutex_lock(&__grmutex);
1806 rv = nsdispatch(NULL, dtab, NSDB_GROUP, "getgrgid", __nsdefaultcompat,
1807 &retval, gid);
1808 mutex_unlock(&__grmutex);
1809 return (rv == NS_SUCCESS) ? retval : NULL;
1810 }
1811
1812 int
1813 getgrgid_r(gid_t gid, struct group *grp, char *buffer, size_t buflen,
1814 struct group **result)
1815 {
1816 int rv, retval;
1817
1818 static const ns_dtab dtab[] = {
1819 NS_FILES_CB(_files_getgrgid_r, NULL)
1820 NS_DNS_CB(_dns_getgrgid_r, NULL)
1821 NS_NIS_CB(_nis_getgrgid_r, NULL)
1822 NS_COMPAT_CB(_compat_getgrgid_r, NULL)
1823 NS_NULL_CB
1824 };
1825
1826 _DIAGASSERT(grp != NULL);
1827 _DIAGASSERT(buffer != NULL);
1828 _DIAGASSERT(result != NULL);
1829
1830 *result = NULL;
1831 retval = 0;
1832 mutex_lock(&__grmutex);
1833 rv = nsdispatch(NULL, dtab, NSDB_GROUP, "getgrgid_r", __nsdefaultcompat,
1834 &retval, gid, grp, buffer, buflen, result);
1835 mutex_unlock(&__grmutex);
1836 switch (rv) {
1837 case NS_SUCCESS:
1838 case NS_NOTFOUND:
1839 return 0;
1840 default:
1841 return retval;
1842 }
1843 }
1844
1845 struct group *
1846 getgrnam(const char *name)
1847 {
1848 int rv;
1849 struct group *retval;
1850
1851 static const ns_dtab dtab[] = {
1852 NS_FILES_CB(_files_getgrnam, NULL)
1853 NS_DNS_CB(_dns_getgrnam, NULL)
1854 NS_NIS_CB(_nis_getgrnam, NULL)
1855 NS_COMPAT_CB(_compat_getgrnam, NULL)
1856 NS_NULL_CB
1857 };
1858
1859 mutex_lock(&__grmutex);
1860 rv = nsdispatch(NULL, dtab, NSDB_GROUP, "getgrnam", __nsdefaultcompat,
1861 &retval, name);
1862 mutex_unlock(&__grmutex);
1863 return (rv == NS_SUCCESS) ? retval : NULL;
1864 }
1865
1866 int
1867 getgrnam_r(const char *name, struct group *grp, char *buffer, size_t buflen,
1868 struct group **result)
1869 {
1870 int rv, retval;
1871
1872 static const ns_dtab dtab[] = {
1873 NS_FILES_CB(_files_getgrnam_r, NULL)
1874 NS_DNS_CB(_dns_getgrnam_r, NULL)
1875 NS_NIS_CB(_nis_getgrnam_r, NULL)
1876 NS_COMPAT_CB(_compat_getgrnam_r, NULL)
1877 NS_NULL_CB
1878 };
1879
1880 _DIAGASSERT(name != NULL);
1881 _DIAGASSERT(grp != NULL);
1882 _DIAGASSERT(buffer != NULL);
1883 _DIAGASSERT(result != NULL);
1884
1885 *result = NULL;
1886 retval = 0;
1887 mutex_lock(&__grmutex);
1888 rv = nsdispatch(NULL, dtab, NSDB_GROUP, "getgrnam_r", __nsdefaultcompat,
1889 &retval, name, grp, buffer, buflen, result);
1890 mutex_unlock(&__grmutex);
1891 switch (rv) {
1892 case NS_SUCCESS:
1893 case NS_NOTFOUND:
1894 return 0;
1895 default:
1896 return retval;
1897 }
1898 }
1899
1900 void
1901 endgrent(void)
1902 {
1903 static const ns_dtab dtab[] = {
1904 NS_FILES_CB(_files_endgrent, NULL)
1905 NS_DNS_CB(_dns_endgrent, NULL)
1906 NS_NIS_CB(_nis_endgrent, NULL)
1907 NS_COMPAT_CB(_compat_endgrent, NULL)
1908 NS_NULL_CB
1909 };
1910
1911 mutex_lock(&__grmutex);
1912 /* force all endgrent() methods */
1913 (void) nsdispatch(NULL, dtab, NSDB_GROUP, "endgrent",
1914 __nsdefaultcompat_forceall);
1915 mutex_unlock(&__grmutex);
1916 }
1917
1918 int
1919 setgroupent(int stayopen)
1920 {
1921 static const ns_dtab dtab[] = {
1922 NS_FILES_CB(_files_setgroupent, NULL)
1923 NS_DNS_CB(_dns_setgroupent, NULL)
1924 NS_NIS_CB(_nis_setgroupent, NULL)
1925 NS_COMPAT_CB(_compat_setgroupent, NULL)
1926 NS_NULL_CB
1927 };
1928 int rv, retval;
1929
1930 mutex_lock(&__grmutex);
1931 /* force all setgroupent() methods */
1932 rv = nsdispatch(NULL, dtab, NSDB_GROUP, "setgroupent",
1933 __nsdefaultcompat_forceall, &retval, stayopen);
1934 mutex_unlock(&__grmutex);
1935 return (rv == NS_SUCCESS) ? retval : 0;
1936 }
1937
1938 void
1939 setgrent(void)
1940 {
1941 static const ns_dtab dtab[] = {
1942 NS_FILES_CB(_files_setgrent, NULL)
1943 NS_DNS_CB(_dns_setgrent, NULL)
1944 NS_NIS_CB(_nis_setgrent, NULL)
1945 NS_COMPAT_CB(_compat_setgrent, NULL)
1946 NS_NULL_CB
1947 };
1948
1949 mutex_lock(&__grmutex);
1950 /* force all setgrent() methods */
1951 (void) nsdispatch(NULL, dtab, NSDB_GROUP, "setgrent",
1952 __nsdefaultcompat_forceall);
1953 mutex_unlock(&__grmutex);
1954 }
MINIX 3 (repo.or.cz mirror)