?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
coverity appeasement
[minix.git] / lib / libc / gen / getgrent.c
blob9e2b6957fa5d7087ed5b2dcbd1fd1d1022bcfb7b
1 /* $NetBSD: getgrent.c,v 1.62 2008/04/28 20:22:59 martin 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.62 2008/04/28 20:22:59 martin 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 grp->gr_mem = (char **)ALIGN(ep);
225 if (grp->gr_mem == NULL)
226 return 0;
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 for (memc = 0; fromgrp->gr_mem[memc]; memc++)
274 continue;
275 memc++; /* for final NULL */
276
277 /* grab ALIGNed char **gr_mem from buf */
278 ep = _gr_memfrombuf(memc * sizeof(char *) + ALIGNBYTES, &buf, &buflen);
279 grp->gr_mem = (char **)ALIGN(ep);
280 if (grp->gr_mem == NULL)
281 return 0;
282
283 for (memc = 0; fromgrp->gr_mem[memc]; memc++) {
284 COPYSTR(grp->gr_mem[memc], fromgrp->gr_mem[memc]);
285 }
286
287 #undef COPYSTR
288
289 grp->gr_mem[memc] = NULL;
290 return 1;
291 }
292
293 /*
294 * files methods
295 */
296
297 int
298 __grstart_files(struct __grstate_files *state)
299 {
300
301 _DIAGASSERT(state != NULL);
302
303 if (state->fp == NULL) {
304 state->fp = fopen(_PATH_GROUP, "r");
305 if (state->fp == NULL)
306 return NS_UNAVAIL;
307 } else {
308 rewind(state->fp);
309 }
310 return NS_SUCCESS;
311 }
312
313 int
314 __grend_files(struct __grstate_files *state)
315 {
316
317 _DIAGASSERT(state != NULL);
318
319 if (state->fp) {
320 (void) fclose(state->fp);
321 state->fp = NULL;
322 }
323 return NS_SUCCESS;
324 }
325
326 /*
327 * __grscan_files
328 * Scan state->fp for the next desired entry.
329 * If search is zero, return the next entry.
330 * If search is non-zero, look for a specific name (if name != NULL),
331 * or a specific gid (if name == NULL).
332 * Sets *retval to the errno if the result is not NS_SUCCESS
333 * or NS_NOTFOUND.
334 */
335 int
336 __grscan_files(int *retval, struct group *grp, char *buffer, size_t buflen,
337 struct __grstate_files *state, int search, const char *name, gid_t gid)
338 {
339 int rv;
340 char filebuf[_GETGR_R_SIZE_MAX], *ep;
341
342 _DIAGASSERT(retval != NULL);
343 _DIAGASSERT(grp != NULL);
344 _DIAGASSERT(buffer != NULL);
345 _DIAGASSERT(state != NULL);
346 /* name is NULL to indicate searching for gid */
347
348 *retval = 0;
349
350 if (state->fp == NULL) { /* only start if file not open yet */
351 rv = __grstart_files(state);
352 if (rv != NS_SUCCESS)
353 goto filesgrscan_out;
354 }
355
356 rv = NS_NOTFOUND;
357
358 /* scan line by line */
359 while (fgets(filebuf, sizeof(filebuf), state->fp) != NULL) {
360 ep = strchr(filebuf, '\n');
361 if (ep == NULL) { /* skip lines that are too big */
362 int ch;
363
364 while ((ch = getc(state->fp)) != '\n' && ch != EOF)
365 continue;
366 continue;
367 }
368 *ep = '\0'; /* clear trailing \n */
369
370 if (filebuf[0] == '+') /* skip compat line */
371 continue;
372
373 /* validate line */
374 if (! _gr_parse(filebuf, grp, buffer, buflen)) {
375 continue; /* skip bad lines */
376 }
377 if (! search) { /* just want this one */
378 rv = NS_SUCCESS;
379 break;
380 }
381 /* want specific */
382 if ((name && strcmp(name, grp->gr_name) == 0) ||
383 (!name && gid == grp->gr_gid)) {
384 rv = NS_SUCCESS;
385 break;
386 }
387 }
388
389 filesgrscan_out:
390 if (rv != NS_SUCCESS && rv != NS_NOTFOUND)
391 *retval = errno;
392 return rv;
393 }
394
395
396 static struct __grstate_files _files_state;
397 /* storage for non _r functions */
398 static struct group _files_group;
399 static char _files_groupbuf[_GETGR_R_SIZE_MAX];
400
401 /*ARGSUSED*/
402 static int
403 _files_setgrent(void *nsrv, void *nscb, va_list ap)
404 {
405
406 _files_state.stayopen = 0;
407 return __grstart_files(&_files_state);
408 }
409
410 /*ARGSUSED*/
411 static int
412 _files_setgroupent(void *nsrv, void *nscb, va_list ap)
413 {
414 int *retval = va_arg(ap, int *);
415 int stayopen = va_arg(ap, int);
416
417 int rv;
418
419 _files_state.stayopen = stayopen;
420 rv = __grstart_files(&_files_state);
421 *retval = (rv == NS_SUCCESS);
422 return rv;
423 }
424
425 /*ARGSUSED*/
426 static int
427 _files_endgrent(void *nsrv, void *nscb, va_list ap)
428 {
429
430 _files_state.stayopen = 0;
431 return __grend_files(&_files_state);
432 }
433
434 /*ARGSUSED*/
435 static int
436 _files_getgrent(void *nsrv, void *nscb, va_list ap)
437 {
438 struct group **retval = va_arg(ap, struct group **);
439
440 int rv, rerror;
441
442 _DIAGASSERT(retval != NULL);
443
444 *retval = NULL;
445 rv = __grscan_files(&rerror, &_files_group,
446 _files_groupbuf, sizeof(_files_groupbuf),
447 &_files_state, 0, NULL, 0);
448 if (rv == NS_SUCCESS)
449 *retval = &_files_group;
450 return rv;
451 }
452
453 /*ARGSUSED*/
454 static int
455 _files_getgrent_r(void *nsrv, void *nscb, va_list ap)
456 {
457 int *retval = va_arg(ap, int *);
458 struct group *grp = va_arg(ap, struct group *);
459 char *buffer = va_arg(ap, char *);
460 size_t buflen = va_arg(ap, size_t);
461 struct group **result = va_arg(ap, struct group **);
462
463 int rv;
464
465 _DIAGASSERT(retval != NULL);
466 _DIAGASSERT(grp != NULL);
467 _DIAGASSERT(buffer != NULL);
468 _DIAGASSERT(result != NULL);
469
470 rv = __grscan_files(retval, grp, buffer, buflen,
471 &_files_state, 0, NULL, 0);
472 if (rv == NS_SUCCESS)
473 *result = grp;
474 else
475 *result = NULL;
476 return rv;
477 }
478
479 /*ARGSUSED*/
480 static int
481 _files_getgrgid(void *nsrv, void *nscb, va_list ap)
482 {
483 struct group **retval = va_arg(ap, struct group **);
484 gid_t gid = va_arg(ap, gid_t);
485
486 int rv, rerror;
487
488 _DIAGASSERT(retval != NULL);
489
490 *retval = NULL;
491 rv = __grstart_files(&_files_state);
492 if (rv != NS_SUCCESS)
493 return rv;
494 rv = __grscan_files(&rerror, &_files_group,
495 _files_groupbuf, sizeof(_files_groupbuf),
496 &_files_state, 1, NULL, gid);
497 if (!_files_state.stayopen)
498 __grend_files(&_files_state);
499 if (rv == NS_SUCCESS)
500 *retval = &_files_group;
501 return rv;
502 }
503
504 /*ARGSUSED*/
505 static int
506 _files_getgrgid_r(void *nsrv, void *nscb, va_list ap)
507 {
508 int *retval = va_arg(ap, int *);
509 gid_t gid = va_arg(ap, gid_t);
510 struct group *grp = va_arg(ap, struct group *);
511 char *buffer = va_arg(ap, char *);
512 size_t buflen = va_arg(ap, size_t);
513 struct group **result = va_arg(ap, struct group **);
514
515 struct __grstate_files state;
516 int rv;
517
518 _DIAGASSERT(retval != NULL);
519 _DIAGASSERT(grp != NULL);
520 _DIAGASSERT(buffer != NULL);
521 _DIAGASSERT(result != NULL);
522
523 *result = NULL;
524 memset(&state, 0, sizeof(state));
525 rv = __grscan_files(retval, grp, buffer, buflen, &state, 1, NULL, gid);
526 __grend_files(&state);
527 if (rv == NS_SUCCESS)
528 *result = grp;
529 return rv;
530 }
531
532 /*ARGSUSED*/
533 static int
534 _files_getgrnam(void *nsrv, void *nscb, va_list ap)
535 {
536 struct group **retval = va_arg(ap, struct group **);
537 const char *name = va_arg(ap, const char *);
538
539 int rv, rerror;
540
541 _DIAGASSERT(retval != NULL);
542
543 *retval = NULL;
544 rv = __grstart_files(&_files_state);
545 if (rv != NS_SUCCESS)
546 return rv;
547 rv = __grscan_files(&rerror, &_files_group,
548 _files_groupbuf, sizeof(_files_groupbuf),
549 &_files_state, 1, name, 0);
550 if (!_files_state.stayopen)
551 __grend_files(&_files_state);
552 if (rv == NS_SUCCESS)
553 *retval = &_files_group;
554 return rv;
555 }
556
557 /*ARGSUSED*/
558 static int
559 _files_getgrnam_r(void *nsrv, void *nscb, va_list ap)
560 {
561 int *retval = va_arg(ap, int *);
562 const char *name = va_arg(ap, const char *);
563 struct group *grp = va_arg(ap, struct group *);
564 char *buffer = va_arg(ap, char *);
565 size_t buflen = va_arg(ap, size_t);
566 struct group **result = va_arg(ap, struct group **);
567
568 struct __grstate_files state;
569 int rv;
570
571 _DIAGASSERT(retval != NULL);
572 _DIAGASSERT(grp != NULL);
573 _DIAGASSERT(buffer != NULL);
574 _DIAGASSERT(result != NULL);
575
576 *result = NULL;
577 memset(&state, 0, sizeof(state));
578 rv = __grscan_files(retval, grp, buffer, buflen, &state, 1, name, 0);
579 __grend_files(&state);
580 if (rv == NS_SUCCESS)
581 *result = grp;
582 return rv;
583 }
584
585
586 #ifdef HESIOD
587 /*
588 * dns methods
589 */
590
591 int
592 __grstart_dns(struct __grstate_dns *state)
593 {
594
595 _DIAGASSERT(state != NULL);
596
597 state->num = 0;
598 if (state->context == NULL) { /* setup Hesiod */
599 if (hesiod_init(&state->context) == -1)
600 return NS_UNAVAIL;
601 }
602
603 return NS_SUCCESS;
604 }
605
606 int
607 __grend_dns(struct __grstate_dns *state)
608 {
609
610 _DIAGASSERT(state != NULL);
611
612 state->num = 0;
613 if (state->context) {
614 hesiod_end(state->context);
615 state->context = NULL;
616 }
617 return NS_SUCCESS;
618 }
619
620 /*
621 * __grscan_dns
622 * Search Hesiod for the next desired entry.
623 * If search is zero, return the next entry.
624 * If search is non-zero, look for a specific name (if name != NULL),
625 * or a specific gid (if name == NULL).
626 */
627 int
628 __grscan_dns(int *retval, struct group *grp, char *buffer, size_t buflen,
629 struct __grstate_dns *state, int search, const char *name, gid_t gid)
630 {
631 const char **curzone;
632 char **hp, *ep;
633 int rv;
634
635 static const char *zones_gid_group[] = {
636 "gid",
637 "group",
638 NULL
639 };
640
641 static const char *zones_group[] = {
642 "group",
643 NULL
644 };
645
646 _DIAGASSERT(retval != NULL);
647 _DIAGASSERT(grp != NULL);
648 _DIAGASSERT(buffer != NULL);
649 _DIAGASSERT(state != NULL);
650 /* name is NULL to indicate searching for gid */
651
652 *retval = 0;
653
654 if (state->context == NULL) { /* only start if Hesiod not setup */
655 rv = __grstart_dns(state);
656 if (rv != NS_SUCCESS)
657 return rv;
658 }
659
660 next_dns_entry:
661 hp = NULL;
662 rv = NS_NOTFOUND;
663
664 if (! search) { /* find next entry */
665 if (state->num == -1) /* exhausted search */
666 return NS_NOTFOUND;
667 /* find group-NNN */
668 snprintf(buffer, buflen, "group-%u", state->num);
669 state->num++;
670 curzone = zones_group;
671 } else if (name) { /* find group name */
672 snprintf(buffer, buflen, "%s", name);
673 curzone = zones_group;
674 } else { /* find gid */
675 snprintf(buffer, buflen, "%u", (unsigned int)gid);
676 curzone = zones_gid_group;
677 }
678
679 for (; *curzone; curzone++) { /* search zones */
680 hp = hesiod_resolve(state->context, buffer, *curzone);
681 if (hp != NULL)
682 break;
683 if (errno != ENOENT) {
684 rv = NS_UNAVAIL;
685 goto dnsgrscan_out;
686 }
687 }
688 if (*curzone == NULL) {
689 if (! search)
690 state->num = -1;
691 goto dnsgrscan_out;
692 }
693
694 if ((ep = strchr(hp[0], '\n')) != NULL)
695 *ep = '\0'; /* clear trailing \n */
696 if (_gr_parse(hp[0], grp, buffer, buflen)) { /* validate line */
697 if (! search) { /* just want this one */
698 rv = NS_SUCCESS;
699 } else if ((name && strcmp(name, grp->gr_name) == 0) ||
700 (!name && gid == grp->gr_gid)) { /* want specific */
701 rv = NS_SUCCESS;
702 }
703 } else { /* dodgy entry */
704 if (!search) { /* try again if ! searching */
705 hesiod_free_list(state->context, hp);
706 goto next_dns_entry;
707 }
708 }
709
710 dnsgrscan_out:
711 if (rv != NS_SUCCESS && rv != NS_NOTFOUND)
712 *retval = errno;
713 if (hp)
714 hesiod_free_list(state->context, hp);
715 return rv;
716 }
717
718 static struct __grstate_dns _dns_state;
719 /* storage for non _r functions */
720 static struct group _dns_group;
721 static char _dns_groupbuf[_GETGR_R_SIZE_MAX];
722
723 /*ARGSUSED*/
724 static int
725 _dns_setgrent(void *nsrv, void *nscb, va_list ap)
726 {
727
728 _dns_state.stayopen = 0;
729 return __grstart_dns(&_dns_state);
730 }
731
732 /*ARGSUSED*/
733 static int
734 _dns_setgroupent(void *nsrv, void *nscb, va_list ap)
735 {
736 int *retval = va_arg(ap, int *);
737 int stayopen = va_arg(ap, int);
738
739 int rv;
740
741 _dns_state.stayopen = stayopen;
742 rv = __grstart_dns(&_dns_state);
743 *retval = (rv == NS_SUCCESS);
744 return rv;
745 }
746
747 /*ARGSUSED*/
748 static int
749 _dns_endgrent(void *nsrv, void *nscb, va_list ap)
750 {
751
752 _dns_state.stayopen = 0;
753 return __grend_dns(&_dns_state);
754 }
755
756 /*ARGSUSED*/
757 static int
758 _dns_getgrent(void *nsrv, void *nscb, va_list ap)
759 {
760 struct group **retval = va_arg(ap, struct group **);
761
762 int rv, rerror;
763
764 _DIAGASSERT(retval != NULL);
765
766 *retval = NULL;
767 rv = __grscan_dns(&rerror, &_dns_group,
768 _dns_groupbuf, sizeof(_dns_groupbuf), &_dns_state, 0, NULL, 0);
769 if (rv == NS_SUCCESS)
770 *retval = &_dns_group;
771 return rv;
772 }
773
774 /*ARGSUSED*/
775 static int
776 _dns_getgrent_r(void *nsrv, void *nscb, va_list ap)
777 {
778 int *retval = va_arg(ap, int *);
779 struct group *grp = va_arg(ap, struct group *);
780 char *buffer = va_arg(ap, char *);
781 size_t buflen = va_arg(ap, size_t);
782 struct group **result = va_arg(ap, struct group **);
783
784 int rv;
785
786 _DIAGASSERT(retval != NULL);
787 _DIAGASSERT(grp != NULL);
788 _DIAGASSERT(buffer != NULL);
789 _DIAGASSERT(result != NULL);
790
791 rv = __grscan_dns(retval, grp, buffer, buflen,
792 &_dns_state, 0, NULL, 0);
793 if (rv == NS_SUCCESS)
794 *result = grp;
795 else
796 *result = NULL;
797 return rv;
798 }
799 /*ARGSUSED*/
800 static int
801 _dns_getgrgid(void *nsrv, void *nscb, va_list ap)
802 {
803 struct group **retval = va_arg(ap, struct group **);
804 gid_t gid = va_arg(ap, gid_t);
805
806 int rv, rerror;
807
808 _DIAGASSERT(retval != NULL);
809
810 *retval = NULL;
811 rv = __grstart_dns(&_dns_state);
812 if (rv != NS_SUCCESS)
813 return rv;
814 rv = __grscan_dns(&rerror, &_dns_group,
815 _dns_groupbuf, sizeof(_dns_groupbuf), &_dns_state, 1, NULL, gid);
816 if (!_dns_state.stayopen)
817 __grend_dns(&_dns_state);
818 if (rv == NS_SUCCESS)
819 *retval = &_dns_group;
820 return rv;
821 }
822
823 /*ARGSUSED*/
824 static int
825 _dns_getgrgid_r(void *nsrv, void *nscb, va_list ap)
826 {
827 int *retval = va_arg(ap, int *);
828 gid_t gid = va_arg(ap, gid_t);
829 struct group *grp = va_arg(ap, struct group *);
830 char *buffer = va_arg(ap, char *);
831 size_t buflen = va_arg(ap, size_t);
832 struct group **result = va_arg(ap, struct group **);
833
834 struct __grstate_dns state;
835 int rv;
836
837 _DIAGASSERT(retval != NULL);
838 _DIAGASSERT(grp != NULL);
839 _DIAGASSERT(buffer != NULL);
840 _DIAGASSERT(result != NULL);
841
842 *result = NULL;
843 memset(&state, 0, sizeof(state));
844 rv = __grscan_dns(retval, grp, buffer, buflen, &state, 1, NULL, gid);
845 __grend_dns(&state);
846 if (rv == NS_SUCCESS)
847 *result = grp;
848 return rv;
849 }
850
851 /*ARGSUSED*/
852 static int
853 _dns_getgrnam(void *nsrv, void *nscb, va_list ap)
854 {
855 struct group **retval = va_arg(ap, struct group **);
856 const char *name = va_arg(ap, const char *);
857
858 int rv, rerror;
859
860 _DIAGASSERT(retval != NULL);
861
862 *retval = NULL;
863 rv = __grstart_dns(&_dns_state);
864 if (rv != NS_SUCCESS)
865 return rv;
866 rv = __grscan_dns(&rerror, &_dns_group,
867 _dns_groupbuf, sizeof(_dns_groupbuf), &_dns_state, 1, name, 0);
868 if (!_dns_state.stayopen)
869 __grend_dns(&_dns_state);
870 if (rv == NS_SUCCESS)
871 *retval = &_dns_group;
872 return rv;
873 }
874
875 /*ARGSUSED*/
876 static int
877 _dns_getgrnam_r(void *nsrv, void *nscb, va_list ap)
878 {
879 int *retval = va_arg(ap, int *);
880 const char *name = va_arg(ap, const char *);
881 struct group *grp = va_arg(ap, struct group *);
882 char *buffer = va_arg(ap, char *);
883 size_t buflen = va_arg(ap, size_t);
884 struct group **result = va_arg(ap, struct group **);
885
886 struct __grstate_dns state;
887 int rv;
888
889 _DIAGASSERT(retval != NULL);
890 _DIAGASSERT(grp != NULL);
891 _DIAGASSERT(buffer != NULL);
892 _DIAGASSERT(result != NULL);
893
894 *result = NULL;
895 memset(&state, 0, sizeof(state));
896 rv = __grscan_dns(retval, grp, buffer, buflen, &state, 1, name, 0);
897 __grend_dns(&state);
898 if (rv == NS_SUCCESS)
899 *result = grp;
900 return rv;
901 }
902
903 #endif /* HESIOD */
904
905
906 #ifdef YP
907 /*
908 * nis methods
909 */
910
911 int
912 __grstart_nis(struct __grstate_nis *state)
913 {
914
915 _DIAGASSERT(state != NULL);
916
917 state->done = 0;
918 if (state->current) {
919 free(state->current);
920 state->current = NULL;
921 }
922 if (state->domain == NULL) { /* setup NIS */
923 switch (yp_get_default_domain(&state->domain)) {
924 case 0:
925 break;
926 case YPERR_RESRC:
927 return NS_TRYAGAIN;
928 default:
929 return NS_UNAVAIL;
930 }
931 }
932 return NS_SUCCESS;
933 }
934
935 int
936 __grend_nis(struct __grstate_nis *state)
937 {
938
939 _DIAGASSERT(state != NULL);
940
941 if (state->domain) {
942 state->domain = NULL;
943 }
944 state->done = 0;
945 if (state->current) {
946 free(state->current);
947 state->current = NULL;
948 }
949 return NS_SUCCESS;
950 }
951
952 /*
953 * __grscan_nis
954 * Search NIS for the next desired entry.
955 * If search is zero, return the next entry.
956 * If search is non-zero, look for a specific name (if name != NULL),
957 * or a specific gid (if name == NULL).
958 */
959 int
960 __grscan_nis(int *retval, struct group *grp, char *buffer, size_t buflen,
961 struct __grstate_nis *state, int search, const char *name, gid_t gid)
962 {
963 const char *map;
964 char *key, *data;
965 int nisr, rv, keylen, datalen;
966
967 _DIAGASSERT(retval != NULL);
968 _DIAGASSERT(grp != NULL);
969 _DIAGASSERT(buffer != NULL);
970 _DIAGASSERT(state != NULL);
971 /* name is NULL to indicate searching for gid */
972
973 *retval = 0;
974
975 if (state->domain == NULL) { /* only start if NIS not setup */
976 rv = __grstart_nis(state);
977 if (rv != NS_SUCCESS)
978 return rv;
979 }
980
981 next_nis_entry:
982 key = NULL;
983 data = NULL;
984 rv = NS_SUCCESS;
985
986 if (! search) { /* find next entry */
987 if (state->done) /* exhausted search */
988 return NS_NOTFOUND;
989 map = "group.byname";
990 if (state->current) { /* already searching */
991 nisr = yp_next(state->domain, map,
992 state->current, state->currentlen,
993 &key, &keylen, &data, &datalen);
994 free(state->current);
995 state->current = NULL;
996 switch (nisr) {
997 case 0:
998 state->current = key;
999 state->currentlen = keylen;
1000 key = NULL;
1001 break;
1002 case YPERR_NOMORE:
1003 rv = NS_NOTFOUND;
1004 state->done = 1;
1005 break;
1006 default:
1007 rv = NS_UNAVAIL;
1008 break;
1009 }
1010 } else { /* new search */
1011 if (yp_first(state->domain, map,
1012 &state->current, &state->currentlen,
1013 &data, &datalen)) {
1014 rv = NS_UNAVAIL;
1015 }
1016 }
1017 } else { /* search for specific item */
1018 if (name) { /* find group name */
1019 snprintf(buffer, buflen, "%s", name);
1020 map = "group.byname";
1021 } else { /* find gid */
1022 snprintf(buffer, buflen, "%u", (unsigned int)gid);
1023 map = "group.bygid";
1024 }
1025 nisr = yp_match(state->domain, map, buffer, (int)strlen(buffer),
1026 &data, &datalen);
1027 switch (nisr) {
1028 case 0:
1029 break;
1030 case YPERR_KEY:
1031 rv = NS_NOTFOUND;
1032 break;
1033 default:
1034 rv = NS_UNAVAIL;
1035 break;
1036 }
1037 }
1038 if (rv == NS_SUCCESS) { /* validate data */
1039 data[datalen] = '\0'; /* clear trailing \n */
1040 if (_gr_parse(data, grp, buffer, buflen)) {
1041 if (! search) { /* just want this one */
1042 rv = NS_SUCCESS;
1043 } else if ((name && strcmp(name, grp->gr_name) == 0) ||
1044 (!name && gid == grp->gr_gid)) {
1045 /* want specific */
1046 rv = NS_SUCCESS;
1047 }
1048 } else { /* dodgy entry */
1049 if (!search) { /* try again if ! searching */
1050 free(data);
1051 goto next_nis_entry;
1052 }
1053 }
1054 }
1055
1056 if (rv != NS_SUCCESS && rv != NS_NOTFOUND)
1057 *retval = errno;
1058 if (key)
1059 free(key);
1060 if (data)
1061 free(data);
1062 return rv;
1063 }
1064
1065 static struct __grstate_nis _nis_state;
1066 /* storage for non _r functions */
1067 static struct group _nis_group;
1068 static char _nis_groupbuf[_GETGR_R_SIZE_MAX];
1069
1070 /*ARGSUSED*/
1071 static int
1072 _nis_setgrent(void *nsrv, void *nscb, va_list ap)
1073 {
1074
1075 _nis_state.stayopen = 0;
1076 return __grstart_nis(&_nis_state);
1077 }
1078
1079 /*ARGSUSED*/
1080 static int
1081 _nis_setgroupent(void *nsrv, void *nscb, va_list ap)
1082 {
1083 int *retval = va_arg(ap, int *);
1084 int stayopen = va_arg(ap, int);
1085
1086 int rv;
1087
1088 _nis_state.stayopen = stayopen;
1089 rv = __grstart_nis(&_nis_state);
1090 *retval = (rv == NS_SUCCESS);
1091 return rv;
1092 }
1093
1094 /*ARGSUSED*/
1095 static int
1096 _nis_endgrent(void *nsrv, void *nscb, va_list ap)
1097 {
1098
1099 return __grend_nis(&_nis_state);
1100 }
1101
1102 /*ARGSUSED*/
1103 static int
1104 _nis_getgrent(void *nsrv, void *nscb, va_list ap)
1105 {
1106 struct group **retval = va_arg(ap, struct group **);
1107
1108 int rv, rerror;
1109
1110 _DIAGASSERT(retval != NULL);
1111
1112 *retval = NULL;
1113 rv = __grscan_nis(&rerror, &_nis_group,
1114 _nis_groupbuf, sizeof(_nis_groupbuf), &_nis_state, 0, NULL, 0);
1115 if (rv == NS_SUCCESS)
1116 *retval = &_nis_group;
1117 return rv;
1118 }
1119
1120 /*ARGSUSED*/
1121 static int
1122 _nis_getgrent_r(void *nsrv, void *nscb, va_list ap)
1123 {
1124 int *retval = va_arg(ap, int *);
1125 struct group *grp = va_arg(ap, struct group *);
1126 char *buffer = va_arg(ap, char *);
1127 size_t buflen = va_arg(ap, size_t);
1128 struct group **result = va_arg(ap, struct group **);
1129
1130 int rv;
1131
1132 _DIAGASSERT(retval != NULL);
1133 _DIAGASSERT(grp != NULL);
1134 _DIAGASSERT(buffer != NULL);
1135 _DIAGASSERT(result != NULL);
1136
1137 rv = __grscan_nis(retval, grp, buffer, buflen,
1138 &_nis_state, 0, NULL, 0);
1139 if (rv == NS_SUCCESS)
1140 *result = grp;
1141 else
1142 *result = NULL;
1143 return rv;
1144 }
1145
1146 /*ARGSUSED*/
1147 static int
1148 _nis_getgrgid(void *nsrv, void *nscb, va_list ap)
1149 {
1150 struct group **retval = va_arg(ap, struct group **);
1151 gid_t gid = va_arg(ap, gid_t);
1152
1153 int rv, rerror;
1154
1155 _DIAGASSERT(retval != NULL);
1156
1157 *retval = NULL;
1158 rv = __grstart_nis(&_nis_state);
1159 if (rv != NS_SUCCESS)
1160 return rv;
1161 rv = __grscan_nis(&rerror, &_nis_group,
1162 _nis_groupbuf, sizeof(_nis_groupbuf), &_nis_state, 1, NULL, gid);
1163 if (!_nis_state.stayopen)
1164 __grend_nis(&_nis_state);
1165 if (rv == NS_SUCCESS)
1166 *retval = &_nis_group;
1167 return rv;
1168 }
1169
1170 /*ARGSUSED*/
1171 static int
1172 _nis_getgrgid_r(void *nsrv, void *nscb, va_list ap)
1173 {
1174 int *retval = va_arg(ap, int *);
1175 gid_t gid = va_arg(ap, gid_t);
1176 struct group *grp = va_arg(ap, struct group *);
1177 char *buffer = va_arg(ap, char *);
1178 size_t buflen = va_arg(ap, size_t);
1179 struct group **result = va_arg(ap, struct group **);
1180
1181 struct __grstate_nis state;
1182 int rv;
1183
1184 _DIAGASSERT(retval != NULL);
1185 _DIAGASSERT(grp != NULL);
1186 _DIAGASSERT(buffer != NULL);
1187 _DIAGASSERT(result != NULL);
1188
1189 *result = NULL;
1190 memset(&state, 0, sizeof(state));
1191 rv = __grscan_nis(retval, grp, buffer, buflen, &state, 1, NULL, gid);
1192 __grend_nis(&state);
1193 if (rv == NS_SUCCESS)
1194 *result = grp;
1195 return rv;
1196 }
1197
1198 /*ARGSUSED*/
1199 static int
1200 _nis_getgrnam(void *nsrv, void *nscb, va_list ap)
1201 {
1202 struct group **retval = va_arg(ap, struct group **);
1203 const char *name = va_arg(ap, const char *);
1204
1205 int rv, rerror;
1206
1207 _DIAGASSERT(retval != NULL);
1208
1209 *retval = NULL;
1210 rv = __grstart_nis(&_nis_state);
1211 if (rv != NS_SUCCESS)
1212 return rv;
1213 rv = __grscan_nis(&rerror, &_nis_group,
1214 _nis_groupbuf, sizeof(_nis_groupbuf), &_nis_state, 1, name, 0);
1215 if (!_nis_state.stayopen)
1216 __grend_nis(&_nis_state);
1217 if (rv == NS_SUCCESS)
1218 *retval = &_nis_group;
1219 return rv;
1220 }
1221
1222 /*ARGSUSED*/
1223 static int
1224 _nis_getgrnam_r(void *nsrv, void *nscb, va_list ap)
1225 {
1226 int *retval = va_arg(ap, int *);
1227 const char *name = va_arg(ap, const char *);
1228 struct group *grp = va_arg(ap, struct group *);
1229 char *buffer = va_arg(ap, char *);
1230 size_t buflen = va_arg(ap, size_t);
1231 struct group **result = va_arg(ap, struct group **);
1232
1233 struct __grstate_nis state;
1234 int rv;
1235
1236 _DIAGASSERT(retval != NULL);
1237 _DIAGASSERT(grp != NULL);
1238 _DIAGASSERT(buffer != NULL);
1239 _DIAGASSERT(result != NULL);
1240
1241 *result = NULL;
1242 memset(&state, 0, sizeof(state));
1243 rv = __grscan_nis(retval, grp, buffer, buflen, &state, 1, name, 0);
1244 __grend_nis(&state);
1245 if (rv == NS_SUCCESS)
1246 *result = grp;
1247 return rv;
1248 }
1249
1250 #endif /* YP */
1251
1252
1253 #ifdef _GROUP_COMPAT
1254 /*
1255 * compat methods
1256 */
1257
1258 int
1259 __grstart_compat(struct __grstate_compat *state)
1260 {
1261
1262 _DIAGASSERT(state != NULL);
1263
1264 if (state->fp == NULL) {
1265 state->fp = fopen(_PATH_GROUP, "r");
1266 if (state->fp == NULL)
1267 return NS_UNAVAIL;
1268 } else {
1269 rewind(state->fp);
1270 }
1271 return NS_SUCCESS;
1272 }
1273
1274 int
1275 __grend_compat(struct __grstate_compat *state)
1276 {
1277
1278 _DIAGASSERT(state != NULL);
1279
1280 if (state->name) {
1281 free(state->name);
1282 state->name = NULL;
1283 }
1284 if (state->fp) {
1285 (void) fclose(state->fp);
1286 state->fp = NULL;
1287 }
1288 return NS_SUCCESS;
1289 }
1290
1291
1292 /*
1293 * __grbad_compat
1294 * log an error if "files" or "compat" is specified in
1295 * group_compat database
1296 */
1297 /*ARGSUSED*/
1298 int
1299 __grbad_compat(void *nsrv, void *nscb, va_list ap)
1300 {
1301 static int warned;
1302
1303 _DIAGASSERT(nsrv != NULL);
1304 _DIAGASSERT(nscb != NULL);
1305
1306 if (!warned) {
1307 syslog(LOG_ERR,
1308 "nsswitch.conf group_compat database can't use '%s'",
1309 (const char *)nscb);
1310 }
1311 warned = 1;
1312 return NS_UNAVAIL;
1313 }
1314
1315 /*
1316 * __grscan_compat
1317 * Scan state->fp for the next desired entry.
1318 * If search is zero, return the next entry.
1319 * If search is non-zero, look for a specific name (if name != NULL),
1320 * or a specific gid (if name == NULL).
1321 * Sets *retval to the errno if the result is not NS_SUCCESS or
1322 * NS_NOTFOUND.
1323 *
1324 * searchfunc is invoked when a compat "+" lookup is required;
1325 * searchcookie is passed as the first argument to searchfunc,
1326 * the second argument is the group result.
1327 * This should return NS_NOTFOUND when "no more groups" from compat src.
1328 * If searchfunc is NULL then nsdispatch of getgrent is used.
1329 * This is primarily intended for getgroupmembership(3)'s compat backend.
1330 */
1331 int
1332 __grscan_compat(int *retval, struct group *grp, char *buffer, size_t buflen,
1333 struct __grstate_compat *state, int search, const char *name, gid_t gid,
1334 int (*searchfunc)(void *, struct group **), void *searchcookie)
1335 {
1336 int rv;
1337 char filebuf[_GETGR_R_SIZE_MAX], *ep;
1338
1339 static const ns_dtab compatentdtab[] = {
1340 NS_FILES_CB(__grbad_compat, "files")
1341 NS_DNS_CB(_dns_getgrent_r, NULL)
1342 NS_NIS_CB(_nis_getgrent_r, NULL)
1343 NS_COMPAT_CB(__grbad_compat, "compat")
1344 NS_NULL_CB
1345 };
1346 static const ns_dtab compatgiddtab[] = {
1347 NS_FILES_CB(__grbad_compat, "files")
1348 NS_DNS_CB(_dns_getgrgid_r, NULL)
1349 NS_NIS_CB(_nis_getgrgid_r, NULL)
1350 NS_COMPAT_CB(__grbad_compat, "compat")
1351 NS_NULL_CB
1352 };
1353 static const ns_dtab compatnamdtab[] = {
1354 NS_FILES_CB(__grbad_compat, "files")
1355 NS_DNS_CB(_dns_getgrnam_r, NULL)
1356 NS_NIS_CB(_nis_getgrnam_r, NULL)
1357 NS_COMPAT_CB(__grbad_compat, "compat")
1358 NS_NULL_CB
1359 };
1360
1361 _DIAGASSERT(retval != NULL);
1362 _DIAGASSERT(grp != NULL);
1363 _DIAGASSERT(buffer != NULL);
1364 _DIAGASSERT(state != NULL);
1365 /* name is NULL to indicate searching for gid */
1366
1367 *retval = 0;
1368
1369 if (state->fp == NULL) { /* only start if file not open yet */
1370 rv = __grstart_compat(state);
1371 if (rv != NS_SUCCESS)
1372 goto compatgrscan_out;
1373 }
1374 rv = NS_NOTFOUND;
1375
1376 for (;;) { /* loop through file */
1377 if (state->name != NULL) {
1378 /* processing compat entry */
1379 int crv, cretval;
1380 struct group cgrp, *cgrpres;
1381
1382 if (state->name[0]) { /* specific +group: */
1383 crv = nsdispatch(NULL, compatnamdtab,
1384 NSDB_GROUP_COMPAT, "getgrnam_r",
1385 __nsdefaultnis,
1386 &cretval, state->name,
1387 &cgrp, filebuf, sizeof(filebuf), &cgrpres);
1388 free(state->name); /* (only check 1 grp) */
1389 state->name = NULL;
1390 } else if (!search) { /* any group */
1391 if (searchfunc) {
1392 crv = searchfunc(searchcookie,
1393 &cgrpres);
1394 } else {
1395 crv = nsdispatch(NULL, compatentdtab,
1396 NSDB_GROUP_COMPAT, "getgrent_r",
1397 __nsdefaultnis,
1398 &cretval, &cgrp, filebuf,
1399 sizeof(filebuf), &cgrpres);
1400 }
1401 } else if (name) { /* specific group */
1402 crv = nsdispatch(NULL, compatnamdtab,
1403 NSDB_GROUP_COMPAT, "getgrnam_r",
1404 __nsdefaultnis,
1405 &cretval, name,
1406 &cgrp, filebuf, sizeof(filebuf), &cgrpres);
1407 } else { /* specific gid */
1408 crv = nsdispatch(NULL, compatgiddtab,
1409 NSDB_GROUP_COMPAT, "getgrgid_r",
1410 __nsdefaultnis,
1411 &cretval, gid,
1412 &cgrp, filebuf, sizeof(filebuf), &cgrpres);
1413 }
1414 if (crv != NS_SUCCESS) { /* not found */
1415 free(state->name);
1416 state->name = NULL;
1417 continue; /* try next line */
1418 }
1419 if (!_gr_copy(cgrpres, grp, buffer, buflen)) {
1420 rv = NS_UNAVAIL;
1421 break;
1422 }
1423 goto compatgrscan_cmpgrp; /* skip to grp test */
1424 }
1425
1426 /* get next file line */
1427 if (fgets(filebuf, sizeof(filebuf), state->fp) == NULL)
1428 break;
1429
1430 ep = strchr(filebuf, '\n');
1431 if (ep == NULL) { /* skip lines that are too big */
1432 int ch;
1433
1434 while ((ch = getc(state->fp)) != '\n' && ch != EOF)
1435 continue;
1436 continue;
1437 }
1438 *ep = '\0'; /* clear trailing \n */
1439
1440 if (filebuf[0] == '+') { /* parse compat line */
1441 if (state->name)
1442 free(state->name);
1443 state->name = NULL;
1444 switch(filebuf[1]) {
1445 case ':':
1446 case '\0':
1447 state->name = strdup("");
1448 break;
1449 default:
1450 ep = strchr(filebuf + 1, ':');
1451 if (ep == NULL)
1452 break;
1453 *ep = '\0';
1454 state->name = strdup(filebuf + 1);
1455 break;
1456 }
1457 if (state->name == NULL) {
1458 rv = NS_UNAVAIL;
1459 break;
1460 }
1461 continue;
1462 }
1463
1464 /* validate line */
1465 if (! _gr_parse(filebuf, grp, buffer, buflen)) {
1466 continue; /* skip bad lines */
1467 }
1468
1469 compatgrscan_cmpgrp:
1470 if (! search) { /* just want this one */
1471 rv = NS_SUCCESS;
1472 break;
1473 }
1474 /* want specific */
1475 if ((name && strcmp(name, grp->gr_name) == 0) ||
1476 (!name && gid == grp->gr_gid)) {
1477 rv = NS_SUCCESS;
1478 break;
1479 }
1480
1481 }
1482
1483 compatgrscan_out:
1484 if (rv != NS_SUCCESS && rv != NS_NOTFOUND)
1485 *retval = errno;
1486 return rv;
1487 }
1488
1489 static struct __grstate_compat _compat_state;
1490 /* storage for non _r functions */
1491 static struct group _compat_group;
1492 static char _compat_groupbuf[_GETGR_R_SIZE_MAX];
1493
1494 /*ARGSUSED*/
1495 static int
1496 _compat_setgrent(void *nsrv, void *nscb, va_list ap)
1497 {
1498 static const ns_dtab dtab[] = {
1499 NS_FILES_CB(__grbad_compat, "files")
1500 NS_DNS_CB(_dns_setgrent, NULL)
1501 NS_NIS_CB(_nis_setgrent, NULL)
1502 NS_COMPAT_CB(__grbad_compat, "compat")
1503 NS_NULL_CB
1504 };
1505
1506 /* force group_compat setgrent() */
1507 (void) nsdispatch(NULL, dtab, NSDB_GROUP_COMPAT, "setgrent",
1508 __nsdefaultnis_forceall);
1509
1510 /* reset state, keep fp open */
1511 _compat_state.stayopen = 0;
1512 return __grstart_compat(&_compat_state);
1513 }
1514
1515 /*ARGSUSED*/
1516 static int
1517 _compat_setgroupent(void *nsrv, void *nscb, va_list ap)
1518 {
1519 int *retval = va_arg(ap, int *);
1520 int stayopen = va_arg(ap, int);
1521
1522 int rv;
1523
1524 static const ns_dtab dtab[] = {
1525 NS_FILES_CB(__grbad_compat, "files")
1526 NS_DNS_CB(_dns_setgroupent, NULL)
1527 NS_NIS_CB(_nis_setgroupent, NULL)
1528 NS_COMPAT_CB(__grbad_compat, "compat")
1529 NS_NULL_CB
1530 };
1531
1532 /* force group_compat setgroupent() */
1533 (void) nsdispatch(NULL, dtab, NSDB_GROUP_COMPAT, "setgroupent",
1534 __nsdefaultnis_forceall, &rv, stayopen);
1535
1536 _compat_state.stayopen = stayopen;
1537 rv = __grstart_compat(&_compat_state);
1538 *retval = (rv == NS_SUCCESS);
1539 return rv;
1540 }
1541
1542 /*ARGSUSED*/
1543 static int
1544 _compat_endgrent(void *nsrv, void *nscb, va_list ap)
1545 {
1546 static const ns_dtab dtab[] = {
1547 NS_FILES_CB(__grbad_compat, "files")
1548 NS_DNS_CB(_dns_endgrent, NULL)
1549 NS_NIS_CB(_nis_endgrent, NULL)
1550 NS_COMPAT_CB(__grbad_compat, "compat")
1551 NS_NULL_CB
1552 };
1553
1554 /* force group_compat endgrent() */
1555 (void) nsdispatch(NULL, dtab, NSDB_GROUP_COMPAT, "endgrent",
1556 __nsdefaultnis_forceall);
1557
1558 /* reset state, close fp */
1559 _compat_state.stayopen = 0;
1560 return __grend_compat(&_compat_state);
1561 }
1562
1563 /*ARGSUSED*/
1564 static int
1565 _compat_getgrent(void *nsrv, void *nscb, va_list ap)
1566 {
1567 struct group **retval = va_arg(ap, struct group **);
1568
1569 int rv, rerror;
1570
1571 _DIAGASSERT(retval != NULL);
1572
1573 *retval = NULL;
1574 rv = __grscan_compat(&rerror, &_compat_group,
1575 _compat_groupbuf, sizeof(_compat_groupbuf),
1576 &_compat_state, 0, NULL, 0, NULL, NULL);
1577 if (rv == NS_SUCCESS)
1578 *retval = &_compat_group;
1579 return rv;
1580 }
1581
1582 /*ARGSUSED*/
1583 static int
1584 _compat_getgrent_r(void *nsrv, void *nscb, va_list ap)
1585 {
1586 int *retval = va_arg(ap, int *);
1587 struct group *grp = va_arg(ap, struct group *);
1588 char *buffer = va_arg(ap, char *);
1589 size_t buflen = va_arg(ap, size_t);
1590 struct group **result = va_arg(ap, struct group **);
1591
1592 int rv;
1593
1594 _DIAGASSERT(retval != NULL);
1595 _DIAGASSERT(grp != NULL);
1596 _DIAGASSERT(buffer != NULL);
1597 _DIAGASSERT(result != NULL);
1598
1599 rv = __grscan_compat(retval, grp, buffer, buflen,
1600 &_compat_state, 0, NULL, 0, NULL, NULL);
1601 if (rv == NS_SUCCESS)
1602 *result = grp;
1603 else
1604 *result = NULL;
1605 return rv;
1606 }
1607
1608 /*ARGSUSED*/
1609 static int
1610 _compat_getgrgid(void *nsrv, void *nscb, va_list ap)
1611 {
1612 struct group **retval = va_arg(ap, struct group **);
1613 gid_t gid = va_arg(ap, gid_t);
1614
1615 int rv, rerror;
1616
1617 _DIAGASSERT(retval != NULL);
1618
1619 *retval = NULL;
1620 rv = __grstart_compat(&_compat_state);
1621 if (rv != NS_SUCCESS)
1622 return rv;
1623 rv = __grscan_compat(&rerror, &_compat_group,
1624 _compat_groupbuf, sizeof(_compat_groupbuf),
1625 &_compat_state, 1, NULL, gid, NULL, NULL);
1626 if (!_compat_state.stayopen)
1627 __grend_compat(&_compat_state);
1628 if (rv == NS_SUCCESS)
1629 *retval = &_compat_group;
1630 return rv;
1631 }
1632
1633 /*ARGSUSED*/
1634 static int
1635 _compat_getgrgid_r(void *nsrv, void *nscb, va_list ap)
1636 {
1637 int *retval = va_arg(ap, int *);
1638 gid_t gid = va_arg(ap, gid_t);
1639 struct group *grp = va_arg(ap, struct group *);
1640 char *buffer = va_arg(ap, char *);
1641 size_t buflen = va_arg(ap, size_t);
1642 struct group **result = va_arg(ap, struct group **);
1643
1644 struct __grstate_compat state;
1645 int rv;
1646
1647 _DIAGASSERT(retval != NULL);
1648 _DIAGASSERT(grp != NULL);
1649 _DIAGASSERT(buffer != NULL);
1650 _DIAGASSERT(result != NULL);
1651
1652 *result = NULL;
1653 memset(&state, 0, sizeof(state));
1654 rv = __grscan_compat(retval, grp, buffer, buflen, &state,
1655 1, NULL, gid, NULL, NULL);
1656 __grend_compat(&state);
1657 if (rv == NS_SUCCESS)
1658 *result = grp;
1659 return rv;
1660 }
1661
1662 /*ARGSUSED*/
1663 static int
1664 _compat_getgrnam(void *nsrv, void *nscb, va_list ap)
1665 {
1666 struct group **retval = va_arg(ap, struct group **);
1667 const char *name = va_arg(ap, const char *);
1668
1669 int rv, rerror;
1670
1671 _DIAGASSERT(retval != NULL);
1672
1673 *retval = NULL;
1674 rv = __grstart_compat(&_compat_state);
1675 if (rv != NS_SUCCESS)
1676 return rv;
1677 rv = __grscan_compat(&rerror, &_compat_group,
1678 _compat_groupbuf, sizeof(_compat_groupbuf),
1679 &_compat_state, 1, name, 0, NULL, NULL);
1680 if (!_compat_state.stayopen)
1681 __grend_compat(&_compat_state);
1682 if (rv == NS_SUCCESS)
1683 *retval = &_compat_group;
1684 return rv;
1685 }
1686
1687 /*ARGSUSED*/
1688 static int
1689 _compat_getgrnam_r(void *nsrv, void *nscb, va_list ap)
1690 {
1691 int *retval = va_arg(ap, int *);
1692 const char *name = va_arg(ap, const char *);
1693 struct group *grp = va_arg(ap, struct group *);
1694 char *buffer = va_arg(ap, char *);
1695 size_t buflen = va_arg(ap, size_t);
1696 struct group **result = va_arg(ap, struct group **);
1697
1698 struct __grstate_compat state;
1699 int rv;
1700
1701 _DIAGASSERT(retval != NULL);
1702 _DIAGASSERT(grp != NULL);
1703 _DIAGASSERT(buffer != NULL);
1704 _DIAGASSERT(result != NULL);
1705
1706 *result = NULL;
1707 memset(&state, 0, sizeof(state));
1708 rv = __grscan_compat(retval, grp, buffer, buflen, &state,
1709 1, name, 0, NULL, NULL);
1710 __grend_compat(&state);
1711 if (rv == NS_SUCCESS)
1712 *result = grp;
1713 return rv;
1714 }
1715
1716 #endif /* _GROUP_COMPAT */
1717
1718
1719 /*
1720 * public functions
1721 */
1722
1723 struct group *
1724 getgrent(void)
1725 {
1726 int rv;
1727 struct group *retval;
1728
1729 static const ns_dtab dtab[] = {
1730 NS_FILES_CB(_files_getgrent, NULL)
1731 NS_DNS_CB(_dns_getgrent, NULL)
1732 NS_NIS_CB(_nis_getgrent, NULL)
1733 NS_COMPAT_CB(_compat_getgrent, NULL)
1734 NS_NULL_CB
1735 };
1736
1737 mutex_lock(&__grmutex);
1738 rv = nsdispatch(NULL, dtab, NSDB_GROUP, "getgrent", __nsdefaultcompat,
1739 &retval);
1740 mutex_unlock(&__grmutex);
1741 return (rv == NS_SUCCESS) ? retval : NULL;
1742 }
1743
1744 int
1745 getgrent_r(struct group *grp, char *buffer, size_t buflen,
1746 struct group **result)
1747 {
1748 int rv, retval;
1749
1750 static const ns_dtab dtab[] = {
1751 NS_FILES_CB(_files_getgrent_r, NULL)
1752 NS_DNS_CB(_dns_getgrent_r, NULL)
1753 NS_NIS_CB(_nis_getgrent_r, NULL)
1754 NS_COMPAT_CB(_compat_getgrent_r, NULL)
1755 NS_NULL_CB
1756 };
1757
1758 mutex_lock(&__grmutex);
1759 rv = nsdispatch(NULL, dtab, NSDB_GROUP, "getgrent_r", __nsdefaultcompat,
1760 &retval, grp, buffer, buflen, result);
1761 mutex_unlock(&__grmutex);
1762 switch (rv) {
1763 case NS_SUCCESS:
1764 case NS_NOTFOUND:
1765 return 0;
1766 default:
1767 return retval;
1768 }
1769 }
1770
1771
1772 struct group *
1773 getgrgid(gid_t gid)
1774 {
1775 int rv;
1776 struct group *retval;
1777
1778 static const ns_dtab dtab[] = {
1779 NS_FILES_CB(_files_getgrgid, NULL)
1780 NS_DNS_CB(_dns_getgrgid, NULL)
1781 NS_NIS_CB(_nis_getgrgid, NULL)
1782 NS_COMPAT_CB(_compat_getgrgid, NULL)
1783 NS_NULL_CB
1784 };
1785
1786 mutex_lock(&__grmutex);
1787 rv = nsdispatch(NULL, dtab, NSDB_GROUP, "getgrgid", __nsdefaultcompat,
1788 &retval, gid);
1789 mutex_unlock(&__grmutex);
1790 return (rv == NS_SUCCESS) ? retval : NULL;
1791 }
1792
1793 int
1794 getgrgid_r(gid_t gid, struct group *grp, char *buffer, size_t buflen,
1795 struct group **result)
1796 {
1797 int rv, retval;
1798
1799 static const ns_dtab dtab[] = {
1800 NS_FILES_CB(_files_getgrgid_r, NULL)
1801 NS_DNS_CB(_dns_getgrgid_r, NULL)
1802 NS_NIS_CB(_nis_getgrgid_r, NULL)
1803 NS_COMPAT_CB(_compat_getgrgid_r, NULL)
1804 NS_NULL_CB
1805 };
1806
1807 _DIAGASSERT(grp != NULL);
1808 _DIAGASSERT(buffer != NULL);
1809 _DIAGASSERT(result != NULL);
1810
1811 *result = NULL;
1812 retval = 0;
1813 mutex_lock(&__grmutex);
1814 rv = nsdispatch(NULL, dtab, NSDB_GROUP, "getgrgid_r", __nsdefaultcompat,
1815 &retval, gid, grp, buffer, buflen, result);
1816 mutex_unlock(&__grmutex);
1817 switch (rv) {
1818 case NS_SUCCESS:
1819 case NS_NOTFOUND:
1820 return 0;
1821 default:
1822 return retval;
1823 }
1824 }
1825
1826 struct group *
1827 getgrnam(const char *name)
1828 {
1829 int rv;
1830 struct group *retval;
1831
1832 static const ns_dtab dtab[] = {
1833 NS_FILES_CB(_files_getgrnam, NULL)
1834 NS_DNS_CB(_dns_getgrnam, NULL)
1835 NS_NIS_CB(_nis_getgrnam, NULL)
1836 NS_COMPAT_CB(_compat_getgrnam, NULL)
1837 NS_NULL_CB
1838 };
1839
1840 mutex_lock(&__grmutex);
1841 rv = nsdispatch(NULL, dtab, NSDB_GROUP, "getgrnam", __nsdefaultcompat,
1842 &retval, name);
1843 mutex_unlock(&__grmutex);
1844 return (rv == NS_SUCCESS) ? retval : NULL;
1845 }
1846
1847 int
1848 getgrnam_r(const char *name, struct group *grp, char *buffer, size_t buflen,
1849 struct group **result)
1850 {
1851 int rv, retval;
1852
1853 static const ns_dtab dtab[] = {
1854 NS_FILES_CB(_files_getgrnam_r, NULL)
1855 NS_DNS_CB(_dns_getgrnam_r, NULL)
1856 NS_NIS_CB(_nis_getgrnam_r, NULL)
1857 NS_COMPAT_CB(_compat_getgrnam_r, NULL)
1858 NS_NULL_CB
1859 };
1860
1861 _DIAGASSERT(name != NULL);
1862 _DIAGASSERT(grp != NULL);
1863 _DIAGASSERT(buffer != NULL);
1864 _DIAGASSERT(result != NULL);
1865
1866 *result = NULL;
1867 retval = 0;
1868 mutex_lock(&__grmutex);
1869 rv = nsdispatch(NULL, dtab, NSDB_GROUP, "getgrnam_r", __nsdefaultcompat,
1870 &retval, name, grp, buffer, buflen, result);
1871 mutex_unlock(&__grmutex);
1872 switch (rv) {
1873 case NS_SUCCESS:
1874 case NS_NOTFOUND:
1875 return 0;
1876 default:
1877 return retval;
1878 }
1879 }
1880
1881 void
1882 endgrent(void)
1883 {
1884 static const ns_dtab dtab[] = {
1885 NS_FILES_CB(_files_endgrent, NULL)
1886 NS_DNS_CB(_dns_endgrent, NULL)
1887 NS_NIS_CB(_nis_endgrent, NULL)
1888 NS_COMPAT_CB(_compat_endgrent, NULL)
1889 NS_NULL_CB
1890 };
1891
1892 mutex_lock(&__grmutex);
1893 /* force all endgrent() methods */
1894 (void) nsdispatch(NULL, dtab, NSDB_GROUP, "endgrent",
1895 __nsdefaultcompat_forceall);
1896 mutex_unlock(&__grmutex);
1897 }
1898
1899 int
1900 setgroupent(int stayopen)
1901 {
1902 static const ns_dtab dtab[] = {
1903 NS_FILES_CB(_files_setgroupent, NULL)
1904 NS_DNS_CB(_dns_setgroupent, NULL)
1905 NS_NIS_CB(_nis_setgroupent, NULL)
1906 NS_COMPAT_CB(_compat_setgroupent, NULL)
1907 NS_NULL_CB
1908 };
1909 int rv, retval;
1910
1911 mutex_lock(&__grmutex);
1912 /* force all setgroupent() methods */
1913 rv = nsdispatch(NULL, dtab, NSDB_GROUP, "setgroupent",
1914 __nsdefaultcompat_forceall, &retval, stayopen);
1915 mutex_unlock(&__grmutex);
1916 return (rv == NS_SUCCESS) ? retval : 0;
1917 }
1918
1919 void
1920 setgrent(void)
1921 {
1922 static const ns_dtab dtab[] = {
1923 NS_FILES_CB(_files_setgrent, NULL)
1924 NS_DNS_CB(_dns_setgrent, NULL)
1925 NS_NIS_CB(_nis_setgrent, NULL)
1926 NS_COMPAT_CB(_compat_setgrent, NULL)
1927 NS_NULL_CB
1928 };
1929
1930 mutex_lock(&__grmutex);
1931 /* force all setgrent() methods */
1932 (void) nsdispatch(NULL, dtab, NSDB_GROUP, "setgrent",
1933 __nsdefaultcompat_forceall);
1934 mutex_unlock(&__grmutex);
1935 }
MINIX 3 (repo.or.cz mirror)