libc: Fix some more -Wmissing-prototype.
[dragonfly.git] / lib / libc / gen / getgrent.c
1 /*-
2  * Copyright (c) 2003 Networks Associates Technology, Inc.
3  * All rights reserved.
4  *
5  * This software was developed for the FreeBSD Project by
6  * Jacques A. Vidrine, Safeport Network Services, and Network
7  * Associates Laboratories, the Security Research Division of Network
8  * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035
9  * ("CBOSS"), as part of the DARPA CHATS research program.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  * $FreeBSD: src/lib/libc/gen/getgrent.c,v 1.37 2007/12/12 10:08:02 bushman Exp $
33  */
34
35 #include "namespace.h"
36 #include <sys/param.h>
37 #ifdef YP
38 #include <rpc/rpc.h>
39 #include <rpcsvc/yp_prot.h>
40 #include <rpcsvc/ypclnt.h>
41 #endif
42 #include <assert.h>
43 #include <ctype.h>
44 #include <errno.h>
45 #ifdef HESIOD
46 #include <hesiod.h>
47 #endif
48 #include <grp.h>
49 #include <nsswitch.h>
50 #include <pthread.h>
51 #include <pthread_np.h>
52 #include <stdio.h>
53 #include <stdlib.h>
54 #include <string.h>
55 #include <syslog.h>
56 #include <unistd.h>
57 #include "un-namespace.h"
58 #include "libc_private.h"
59 #include "nss_tls.h"
60 #ifdef NS_CACHING
61 #include "nscache.h"
62 #endif
63
64 enum constants {
65         GRP_STORAGE_INITIAL     = 1 << 10, /* 1 KByte */
66         GRP_STORAGE_MAX         = 1 << 20, /* 1 MByte */
67         SETGRENT                = 1,
68         ENDGRENT                = 2,
69         HESIOD_NAME_MAX         = 256,
70 };
71
72 static const ns_src defaultsrc[] = {
73         { NSSRC_COMPAT, NS_SUCCESS },
74         { NULL, 0 }
75 };
76
77 int      __getgroupmembership(const char *, gid_t, gid_t *, int, int *);
78 int      __gr_match_entry(const char *, size_t, enum nss_lookup_type,
79             const char *, gid_t);
80 int      __gr_parse_entry(char *, size_t, struct group *, char *, size_t,
81             int *);
82
83 static  int      is_comment_line(const char *, size_t);
84
85 union key {
86         const char      *name;
87         gid_t            gid;
88 };
89 static  struct group *getgr(int (*)(union key, struct group *, char *, size_t,
90                     struct group **), union key);
91 static  int      wrap_getgrnam_r(union key, struct group *, char *, size_t,
92                     struct group **);
93 static  int      wrap_getgrgid_r(union key, struct group *, char *, size_t,
94                     struct group **);
95 static  int      wrap_getgrent_r(union key, struct group *, char *, size_t,
96                     struct group **);
97
98 struct files_state {
99         FILE    *fp;
100         int      stayopen;
101 };
102 static  void     files_endstate(void *);
103 NSS_TLS_HANDLING(files);
104 static  int      files_setgrent(void *, void *, va_list);
105 static  int      files_group(void *, void *, va_list);
106
107
108 #ifdef HESIOD
109 struct dns_state {
110         long    counter;
111 };
112 static  void     dns_endstate(void *);
113 NSS_TLS_HANDLING(dns);
114 static  int      dns_setgrent(void *, void *, va_list);
115 static  int      dns_group(void *, void *, va_list);
116 #endif
117
118
119 #ifdef YP
120 struct nis_state {
121         char     domain[MAXHOSTNAMELEN];
122         int      done;
123         char    *key;
124         int      keylen;
125 };
126 static  void     nis_endstate(void *);
127 NSS_TLS_HANDLING(nis);
128 static  int      nis_setgrent(void *, void *, va_list);
129 static  int      nis_group(void *, void *, va_list);
130 #endif
131
132 struct compat_state {
133         FILE    *fp;
134         int      stayopen;
135         char    *name;
136         enum _compat {
137                 COMPAT_MODE_OFF = 0,
138                 COMPAT_MODE_ALL,
139                 COMPAT_MODE_NAME
140         }        compat;
141 };
142 static  void     compat_endstate(void *);
143 NSS_TLS_HANDLING(compat);
144 static  int      compat_setgrent(void *, void *, va_list);
145 static  int      compat_group(void *, void *, va_list);
146
147 static  int     gr_addgid(gid_t, gid_t *, int, int *);
148 static  int     getgroupmembership_fallback(void *, void *, va_list);
149
150 #ifdef NS_CACHING
151 static  int      grp_id_func(char *, size_t *, va_list, void *);
152 static  int      grp_marshal_func(char *, size_t *, void *, va_list, void *);
153 static  int      grp_unmarshal_func(char *, size_t, void *, va_list, void *);
154
155 static int
156 grp_id_func(char *buffer, size_t *buffer_size, va_list ap, void *cache_mdata)
157 {
158         char    *name;
159         gid_t   gid;
160
161         size_t  desired_size, size;
162         int     res = NS_UNAVAIL;
163         enum nss_lookup_type lookup_type;
164
165
166         lookup_type = (enum nss_lookup_type)cache_mdata;
167         switch (lookup_type) {
168         case nss_lt_name:
169                 name = va_arg(ap, char *);
170                 size = strlen(name);
171                 desired_size = sizeof(enum nss_lookup_type) + size + 1;
172                 if (desired_size > *buffer_size) {
173                         res = NS_RETURN;
174                         goto fin;
175                 }
176
177                 memcpy(buffer, &lookup_type, sizeof(enum nss_lookup_type));
178                 memcpy(buffer + sizeof(enum nss_lookup_type), name, size + 1);
179
180                 res = NS_SUCCESS;
181                 break;
182         case nss_lt_id:
183                 gid = va_arg(ap, gid_t);
184                 desired_size = sizeof(enum nss_lookup_type) + sizeof(gid_t);
185                 if (desired_size > *buffer_size) {
186                         res = NS_RETURN;
187                         goto fin;
188                 }
189
190                 memcpy(buffer, &lookup_type, sizeof(enum nss_lookup_type));
191                 memcpy(buffer + sizeof(enum nss_lookup_type), &gid,
192                     sizeof(gid_t));
193
194                 res = NS_SUCCESS;
195                 break;
196         default:
197                 /* should be unreachable */
198                 return (NS_UNAVAIL);
199         }
200
201 fin:
202         *buffer_size = desired_size;
203         return (res);
204 }
205
206 static int
207 grp_marshal_func(char *buffer, size_t *buffer_size, void *retval __unused,
208     va_list ap, void *cache_mdata)
209 {
210         char *name __unused;
211         gid_t gid __unused;
212         struct group *grp;
213         char *orig_buf __unused;
214         size_t orig_buf_size __unused;
215
216         struct group new_grp;
217         size_t desired_size, size, mem_size;
218         char *p, **mem;
219
220         switch ((enum nss_lookup_type)cache_mdata) {
221         case nss_lt_name:
222                 name = va_arg(ap, char *);
223                 break;
224         case nss_lt_id:
225                 gid = va_arg(ap, gid_t);
226                 break;
227         case nss_lt_all:
228                 break;
229         default:
230                 /* should be unreachable */
231                 return (NS_UNAVAIL);
232         }
233
234         grp = va_arg(ap, struct group *);
235         orig_buf = va_arg(ap, char *);
236         orig_buf_size = va_arg(ap, size_t);
237
238         desired_size = _ALIGNBYTES + sizeof(struct group) + sizeof(char *);
239
240         if (grp->gr_name != NULL)
241                 desired_size += strlen(grp->gr_name) + 1;
242         if (grp->gr_passwd != NULL)
243                 desired_size += strlen(grp->gr_passwd) + 1;
244
245         if (grp->gr_mem != NULL) {
246                 mem_size = 0;
247                 for (mem = grp->gr_mem; *mem; ++mem) {
248                         desired_size += strlen(*mem) + 1;
249                         ++mem_size;
250                 }
251
252                 desired_size += _ALIGNBYTES + (mem_size + 1) * sizeof(char *);
253         }
254
255         if (desired_size > *buffer_size) {
256                 /* this assignment is here for future use */
257                 *buffer_size = desired_size;
258                 return (NS_RETURN);
259         }
260
261         memcpy(&new_grp, grp, sizeof(struct group));
262         memset(buffer, 0, desired_size);
263
264         *buffer_size = desired_size;
265         p = buffer + sizeof(struct group) + sizeof(char *);
266         memcpy(buffer + sizeof(struct group), &p, sizeof(char *));
267         p = (char *)_ALIGN(p);
268
269         if (new_grp.gr_name != NULL) {
270                 size = strlen(new_grp.gr_name);
271                 memcpy(p, new_grp.gr_name, size);
272                 new_grp.gr_name = p;
273                 p += size + 1;
274         }
275
276         if (new_grp.gr_passwd != NULL) {
277                 size = strlen(new_grp.gr_passwd);
278                 memcpy(p, new_grp.gr_passwd, size);
279                 new_grp.gr_passwd = p;
280                 p += size + 1;
281         }
282
283         if (new_grp.gr_mem != NULL) {
284                 p = (char *)_ALIGN(p);
285                 memcpy(p, new_grp.gr_mem, sizeof(char *) * mem_size);
286                 new_grp.gr_mem = (char **)p;
287                 p += sizeof(char *) * (mem_size + 1);
288
289                 for (mem = new_grp.gr_mem; *mem; ++mem) {
290                         size = strlen(*mem);
291                         memcpy(p, *mem, size);
292                         *mem = p;
293                         p += size + 1;
294                 }
295         }
296
297         memcpy(buffer, &new_grp, sizeof(struct group));
298         return (NS_SUCCESS);
299 }
300
301 static int
302 grp_unmarshal_func(char *buffer, size_t buffer_size, void *retval, va_list ap,
303     void *cache_mdata)
304 {
305         char *name __unused;
306         gid_t gid __unused;
307         struct group *grp;
308         char *orig_buf;
309         size_t orig_buf_size;
310         int *ret_errno;
311
312         char *p;
313         char **mem;
314
315         switch ((enum nss_lookup_type)cache_mdata) {
316         case nss_lt_name:
317                 name = va_arg(ap, char *);
318                 break;
319         case nss_lt_id:
320                 gid = va_arg(ap, gid_t);
321                 break;
322         case nss_lt_all:
323                 break;
324         default:
325                 /* should be unreachable */
326                 return (NS_UNAVAIL);
327         }
328
329         grp = va_arg(ap, struct group *);
330         orig_buf = va_arg(ap, char *);
331         orig_buf_size = va_arg(ap, size_t);
332         ret_errno = va_arg(ap, int *);
333
334         if (orig_buf_size <
335             buffer_size - sizeof(struct group) - sizeof(char *)) {
336                 *ret_errno = ERANGE;
337                 return (NS_RETURN);
338         }
339
340         memcpy(grp, buffer, sizeof(struct group));
341         memcpy(&p, buffer + sizeof(struct group), sizeof(char *));
342
343         orig_buf = (char *)_ALIGN(orig_buf);
344         memcpy(orig_buf, buffer + sizeof(struct group) + sizeof(char *) +
345             _ALIGN(p) - (size_t)p,
346             buffer_size - sizeof(struct group) - sizeof(char *) -
347             _ALIGN(p) + (size_t)p);
348         p = (char *)_ALIGN(p);
349
350         NS_APPLY_OFFSET(grp->gr_name, orig_buf, p, char *);
351         NS_APPLY_OFFSET(grp->gr_passwd, orig_buf, p, char *);
352         if (grp->gr_mem != NULL) {
353                 NS_APPLY_OFFSET(grp->gr_mem, orig_buf, p, char **);
354
355                 for (mem = grp->gr_mem; *mem; ++mem)
356                         NS_APPLY_OFFSET(*mem, orig_buf, p, char *);
357         }
358
359         if (retval != NULL)
360                 *((struct group **)retval) = grp;
361
362         return (NS_SUCCESS);
363 }
364
365 NSS_MP_CACHE_HANDLING(group);
366 #endif /* NS_CACHING */
367
368 #ifdef NS_CACHING
369 static const nss_cache_info setgrent_cache_info = NS_MP_CACHE_INFO_INITIALIZER(
370         group, (void *)nss_lt_all,
371         NULL, NULL);
372 #endif
373
374 static const ns_dtab setgrent_dtab[] = {
375         { NSSRC_FILES, files_setgrent, (void *)SETGRENT },
376 #ifdef HESIOD
377         { NSSRC_DNS, dns_setgrent, (void *)SETGRENT },
378 #endif
379 #ifdef YP
380         { NSSRC_NIS, nis_setgrent, (void *)SETGRENT },
381 #endif
382         { NSSRC_COMPAT, compat_setgrent, (void *)SETGRENT },
383 #ifdef NS_CACHING
384         NS_CACHE_CB(&setgrent_cache_info)
385 #endif
386         { NULL, NULL, NULL }
387 };
388
389 #ifdef NS_CACHING
390 static const nss_cache_info endgrent_cache_info = NS_MP_CACHE_INFO_INITIALIZER(
391         group, (void *)nss_lt_all,
392         NULL, NULL);
393 #endif
394
395 static const ns_dtab endgrent_dtab[] = {
396         { NSSRC_FILES, files_setgrent, (void *)ENDGRENT },
397 #ifdef HESIOD
398         { NSSRC_DNS, dns_setgrent, (void *)ENDGRENT },
399 #endif
400 #ifdef YP
401         { NSSRC_NIS, nis_setgrent, (void *)ENDGRENT },
402 #endif
403         { NSSRC_COMPAT, compat_setgrent, (void *)ENDGRENT },
404 #ifdef NS_CACHING
405         NS_CACHE_CB(&endgrent_cache_info)
406 #endif
407         { NULL, NULL, NULL }
408 };
409
410 #ifdef NS_CACHING
411 static const nss_cache_info getgrent_r_cache_info = NS_MP_CACHE_INFO_INITIALIZER(
412         group, (void *)nss_lt_all,
413         grp_marshal_func, grp_unmarshal_func);
414 #endif
415
416 static const ns_dtab getgrent_r_dtab[] = {
417         { NSSRC_FILES, files_group, (void *)nss_lt_all },
418 #ifdef HESIOD
419         { NSSRC_DNS, dns_group, (void *)nss_lt_all },
420 #endif
421 #ifdef YP
422         { NSSRC_NIS, nis_group, (void *)nss_lt_all },
423 #endif
424         { NSSRC_COMPAT, compat_group, (void *)nss_lt_all },
425 #ifdef NS_CACHING
426         NS_CACHE_CB(&getgrent_r_cache_info)
427 #endif
428         { NULL, NULL, NULL }
429 };
430
431 static int
432 gr_addgid(gid_t gid, gid_t *groups, int maxgrp, int *grpcnt)
433 {
434         int     ret, dupc;
435
436         for (dupc = 0; dupc < MIN(maxgrp, *grpcnt); dupc++) {
437                 if (groups[dupc] == gid)
438                         return 1;
439         }
440
441         ret = 1;
442         if (*grpcnt < maxgrp)
443                 groups[*grpcnt] = gid;
444         else
445                 ret = 0;
446
447         (*grpcnt)++;
448
449         return ret;
450 }
451
452 static int
453 getgroupmembership_fallback(void *retval __unused, void *mdata, va_list ap)
454 {
455         const ns_src src[] = {
456                 { mdata, NS_SUCCESS },
457                 { NULL, 0}
458         };
459         struct group    grp;
460         struct group    *grp_p;
461         char            *buf;
462         size_t          bufsize;
463         const char      *uname;
464         gid_t           *groups;
465         gid_t           agroup;
466         int             maxgrp, *grpcnt;
467         int             i, rv, ret_errno;
468
469         /*
470          * As this is a fallback method, only provided src
471          * list will be respected during methods search.
472          */
473         assert(src[0].name != NULL);
474
475         uname = va_arg(ap, const char *);
476         agroup = va_arg(ap, gid_t);
477         groups = va_arg(ap, gid_t *);
478         maxgrp = va_arg(ap, int);
479         grpcnt = va_arg(ap, int *);
480
481         rv = NS_UNAVAIL;
482
483         buf = malloc(GRP_STORAGE_INITIAL);
484         if (buf == NULL)
485                 goto out;
486
487         bufsize = GRP_STORAGE_INITIAL;
488
489         gr_addgid(agroup, groups, maxgrp, grpcnt);
490
491         _nsdispatch(NULL, setgrent_dtab, NSDB_GROUP, "setgrent", src, 0);
492         for (;;) {
493                 do {
494                         ret_errno = 0;
495                         grp_p = NULL;
496                         rv = _nsdispatch(&grp_p, getgrent_r_dtab, NSDB_GROUP,
497                             "getgrent_r", src, &grp, buf, bufsize, &ret_errno);
498
499                         if (grp_p == NULL && ret_errno == ERANGE) {
500                                 free(buf);
501                                 if ((bufsize << 1) > GRP_STORAGE_MAX) {
502                                         buf = NULL;
503                                         errno = ERANGE;
504                                         goto out;
505                                 }
506
507                                 bufsize <<= 1;
508                                 buf = malloc(bufsize);
509                                 if (buf == NULL) {
510                                         goto out;
511                                 }
512                         }
513                 } while (grp_p == NULL && ret_errno == ERANGE);
514
515                 if (ret_errno != 0) {
516                         errno = ret_errno;
517                         goto out;
518                 }
519
520                 if (grp_p == NULL)
521                         break;
522
523                 for (i = 0; grp.gr_mem[i]; i++) {
524                         if (strcmp(grp.gr_mem[i], uname) == 0)
525                             gr_addgid(grp.gr_gid, groups, maxgrp, grpcnt);
526                 }
527         }
528
529         _nsdispatch(NULL, endgrent_dtab, NSDB_GROUP, "endgrent", src);
530 out:
531         free(buf);
532         return (rv);
533 }
534
535 void
536 setgrent(void)
537 {
538         _nsdispatch(NULL, setgrent_dtab, NSDB_GROUP, "setgrent", defaultsrc, 0);
539 }
540
541
542 int
543 setgroupent(int stayopen)
544 {
545         _nsdispatch(NULL, setgrent_dtab, NSDB_GROUP, "setgrent", defaultsrc,
546             stayopen);
547         return (1);
548 }
549
550
551 void
552 endgrent(void)
553 {
554         _nsdispatch(NULL, endgrent_dtab, NSDB_GROUP, "endgrent", defaultsrc);
555 }
556
557
558 int
559 getgrent_r(struct group *grp, char *buffer, size_t bufsize,
560     struct group **result)
561 {
562         int     rv, ret_errno;
563
564         ret_errno = 0;
565         *result = NULL;
566         rv = _nsdispatch(result, getgrent_r_dtab, NSDB_GROUP, "getgrent_r", defaultsrc,
567             grp, buffer, bufsize, &ret_errno);
568         if (rv == NS_SUCCESS)
569                 return (0);
570         else
571                 return (ret_errno);
572 }
573
574
575 int
576 getgrnam_r(const char *name, struct group *grp, char *buffer, size_t bufsize,
577     struct group **result)
578 {
579 #ifdef NS_CACHING
580         static const nss_cache_info cache_info =
581                 NS_COMMON_CACHE_INFO_INITIALIZER(
582                 group, (void *)nss_lt_name,
583                 grp_id_func, grp_marshal_func, grp_unmarshal_func);
584 #endif
585
586         static const ns_dtab dtab[] = {
587                 { NSSRC_FILES, files_group, (void *)nss_lt_name },
588 #ifdef HESIOD
589                 { NSSRC_DNS, dns_group, (void *)nss_lt_name },
590 #endif
591 #ifdef YP
592                 { NSSRC_NIS, nis_group, (void *)nss_lt_name },
593 #endif
594                 { NSSRC_COMPAT, compat_group, (void *)nss_lt_name },
595 #ifdef NS_CACHING
596                 NS_CACHE_CB(&cache_info)
597 #endif
598                 { NULL, NULL, NULL }
599         };
600         int     rv, ret_errno;
601
602         ret_errno = 0;
603         *result = NULL;
604         rv = _nsdispatch(result, dtab, NSDB_GROUP, "getgrnam_r", defaultsrc,
605             name, grp, buffer, bufsize, &ret_errno);
606         if (rv == NS_SUCCESS)
607                 return (0);
608         else
609                 return (ret_errno);
610 }
611
612
613 int
614 getgrgid_r(gid_t gid, struct group *grp, char *buffer, size_t bufsize,
615     struct group **result)
616 {
617 #ifdef NS_CACHING
618         static const nss_cache_info cache_info =
619                 NS_COMMON_CACHE_INFO_INITIALIZER(
620                 group, (void *)nss_lt_id,
621                 grp_id_func, grp_marshal_func, grp_unmarshal_func);
622 #endif
623
624         static const ns_dtab dtab[] = {
625                 { NSSRC_FILES, files_group, (void *)nss_lt_id },
626 #ifdef HESIOD
627                 { NSSRC_DNS, dns_group, (void *)nss_lt_id },
628 #endif
629 #ifdef YP
630                 { NSSRC_NIS, nis_group, (void *)nss_lt_id },
631 #endif
632                 { NSSRC_COMPAT, compat_group, (void *)nss_lt_id },
633 #ifdef NS_CACHING
634                 NS_CACHE_CB(&cache_info)
635 #endif
636                 { NULL, NULL, NULL }
637         };
638         int     rv, ret_errno;
639
640         ret_errno = 0;
641         *result = NULL;
642         rv = _nsdispatch(result, dtab, NSDB_GROUP, "getgrgid_r", defaultsrc,
643             gid, grp, buffer, bufsize, &ret_errno);
644         if (rv == NS_SUCCESS)
645                 return (0);
646         else
647                 return (ret_errno);
648 }
649
650
651
652 int
653 __getgroupmembership(const char *uname, gid_t agroup, gid_t *groups,
654         int maxgrp, int *grpcnt)
655 {
656         static const ns_dtab dtab[] = {
657                 NS_FALLBACK_CB(getgroupmembership_fallback)
658                 { NULL, NULL, NULL }
659         };
660         int rv __unused;
661
662         assert(uname != NULL);
663         /* groups may be NULL if just sizing when invoked with maxgrp = 0 */
664         assert(grpcnt != NULL);
665
666         *grpcnt = 0;
667         rv = _nsdispatch(NULL, dtab, NSDB_GROUP, "getgroupmembership",
668             defaultsrc, uname, agroup, groups, maxgrp, grpcnt);
669
670         /* too many groups found? */
671         return (*grpcnt > maxgrp ? -1 : 0);
672 }
673
674
675 static struct group      grp;
676 static char             *grp_storage;
677 static size_t            grp_storage_size;
678
679 static struct group *
680 getgr(int (*fn)(union key, struct group *, char *, size_t, struct group **),
681     union key key)
682 {
683         int              rv;
684         struct group    *res;
685
686         if (grp_storage == NULL) {
687                 grp_storage = malloc(GRP_STORAGE_INITIAL);
688                 if (grp_storage == NULL)
689                         return (NULL);
690                 grp_storage_size = GRP_STORAGE_INITIAL;
691         }
692         do {
693                 rv = fn(key, &grp, grp_storage, grp_storage_size, &res);
694                 if (res == NULL && rv == ERANGE) {
695                         free(grp_storage);
696                         if ((grp_storage_size << 1) > GRP_STORAGE_MAX) {
697                                 grp_storage = NULL;
698                                 errno = ERANGE;
699                                 return (NULL);
700                         }
701                         grp_storage_size <<= 1;
702                         grp_storage = malloc(grp_storage_size);
703                         if (grp_storage == NULL)
704                                 return (NULL);
705                 }
706         } while (res == NULL && rv == ERANGE);
707         if (rv != 0)
708                 errno = rv;
709         return (res);
710 }
711
712
713 static int
714 wrap_getgrnam_r(union key key, struct group *grp, char *buffer, size_t bufsize,
715     struct group **res)
716 {
717         return (getgrnam_r(key.name, grp, buffer, bufsize, res));
718 }
719
720
721 static int
722 wrap_getgrgid_r(union key key, struct group *grp, char *buffer, size_t bufsize,
723     struct group **res)
724 {
725         return (getgrgid_r(key.gid, grp, buffer, bufsize, res));
726 }
727
728
729 static int
730 wrap_getgrent_r(union key key __unused, struct group *grp, char *buffer,
731     size_t bufsize, struct group **res)
732 {
733         return (getgrent_r(grp, buffer, bufsize, res));
734 }
735
736
737 struct group *
738 getgrnam(const char *name)
739 {
740         union key key;
741
742         key.name = name;
743         return (getgr(wrap_getgrnam_r, key));
744 }
745
746
747 struct group *
748 getgrgid(gid_t gid)
749 {
750         union key key;
751
752         key.gid = gid;
753         return (getgr(wrap_getgrgid_r, key));
754 }
755
756
757 struct group *
758 getgrent(void)
759 {
760         union key key;
761
762         key.gid = 0; /* not used */
763         return (getgr(wrap_getgrent_r, key));
764 }
765
766
767 static int
768 is_comment_line(const char *s, size_t n)
769 {
770         const char      *eom;
771
772         eom = &s[n];
773
774         for (; s < eom; s++)
775                 if (*s == '#' || !isspace((unsigned char)*s))
776                         break;
777         return (*s == '#' || s == eom);
778 }
779
780
781 /*
782  * files backend
783  */
784 static void
785 files_endstate(void *p)
786 {
787
788         if (p == NULL)
789                 return;
790         if (((struct files_state *)p)->fp != NULL)
791                 fclose(((struct files_state *)p)->fp);
792         free(p);
793 }
794
795
796 static int
797 files_setgrent(void *retval __unused, void *mdata, va_list ap)
798 {
799         struct files_state *st;
800         int              rv, stayopen;
801
802         rv = files_getstate(&st);
803         if (rv != 0)
804                 return (NS_UNAVAIL);
805         switch ((enum constants)mdata) {
806         case SETGRENT:
807                 stayopen = va_arg(ap, int);
808                 if (st->fp != NULL)
809                         rewind(st->fp);
810                 else if (stayopen)
811                         st->fp = fopen(_PATH_GROUP, "r");
812                 break;
813         case ENDGRENT:
814                 if (st->fp != NULL) {
815                         fclose(st->fp);
816                         st->fp = NULL;
817                 }
818                 break;
819         default:
820                 break;
821         }
822         return (NS_UNAVAIL);
823 }
824
825
826 static int
827 files_group(void *retval, void *mdata, va_list ap)
828 {
829         struct files_state      *st;
830         enum nss_lookup_type     how;
831         const char              *name, *line;
832         struct group            *grp;
833         gid_t                    gid;
834         char                    *buffer;
835         size_t                   bufsize, linesize;
836         off_t                    pos;
837         int                      rv, stayopen, *errnop;
838
839         name = NULL;
840         gid = (gid_t)-1;
841         how = (enum nss_lookup_type)mdata;
842         switch (how) {
843         case nss_lt_name:
844                 name = va_arg(ap, const char *);
845                 break;
846         case nss_lt_id:
847                 gid = va_arg(ap, gid_t);
848                 break;
849         case nss_lt_all:
850                 break;
851         default:
852                 return (NS_NOTFOUND);
853         }
854         grp = va_arg(ap, struct group *);
855         buffer = va_arg(ap, char *);
856         bufsize = va_arg(ap, size_t);
857         errnop = va_arg(ap, int *);
858         *errnop = files_getstate(&st);
859         if (*errnop != 0)
860                 return (NS_UNAVAIL);
861         if (st->fp == NULL &&
862             ((st->fp = fopen(_PATH_GROUP, "r")) == NULL)) {
863                 *errnop = errno;
864                 return (NS_UNAVAIL);
865         }
866         if (how == nss_lt_all)
867                 stayopen = 1;
868         else {
869                 rewind(st->fp);
870                 stayopen = st->stayopen;
871         }
872         rv = NS_NOTFOUND;
873         pos = ftello(st->fp);
874         while ((line = fgetln(st->fp, &linesize)) != NULL) {
875                 if (line[linesize-1] == '\n')
876                         linesize--;
877                 rv = __gr_match_entry(line, linesize, how, name, gid);
878                 if (rv != NS_SUCCESS)
879                         continue;
880                 /* We need room at least for the line, a string NUL
881                  * terminator, alignment padding, and one (char *)
882                  * pointer for the member list terminator.
883                  */
884                 if (bufsize <= linesize + _ALIGNBYTES + sizeof(char *)) {
885                         *errnop = ERANGE;
886                         rv = NS_RETURN;
887                         break;
888                 }
889                 memcpy(buffer, line, linesize);
890                 buffer[linesize] = '\0';
891                 rv = __gr_parse_entry(buffer, linesize, grp,
892                     &buffer[linesize + 1], bufsize - linesize - 1, errnop);
893                 if (rv & NS_TERMINATE)
894                         break;
895                 pos = ftello(st->fp);
896         }
897         if (!stayopen && st->fp != NULL) {
898                 fclose(st->fp);
899                 st->fp = NULL;
900         }
901         if (rv == NS_SUCCESS && retval != NULL)
902                 *(struct group **)retval = grp;
903         else if (rv == NS_RETURN && *errnop == ERANGE && st->fp != NULL)
904                 fseeko(st->fp, pos, SEEK_SET);
905         return (rv);
906 }
907
908
909 #ifdef HESIOD
910 /*
911  * dns backend
912  */
913 static void
914 dns_endstate(void *p)
915 {
916
917         free(p);
918 }
919
920
921 static int
922 dns_setgrent(void *retval __unused, void *cb_data __unused, va_list ap __unused)
923 {
924         struct dns_state        *st;
925         int                      rv;
926
927         rv = dns_getstate(&st);
928         if (rv != 0)
929                 return (NS_UNAVAIL);
930         st->counter = 0;
931         return (NS_UNAVAIL);
932 }
933
934
935 static int
936 dns_group(void *retval, void *mdata, va_list ap)
937 {
938         char                     buf[HESIOD_NAME_MAX];
939         struct dns_state        *st;
940         struct group            *grp;
941         const char              *name, *label;
942         void                    *ctx;
943         char                    *buffer, **hes;
944         size_t                   bufsize, adjsize, linesize;
945         gid_t                    gid;
946         enum nss_lookup_type     how;
947         int                      rv, *errnop;
948
949         ctx = NULL;
950         hes = NULL;
951         name = NULL;
952         gid = (gid_t)-1;
953         how = (enum nss_lookup_type)mdata;
954         switch (how) {
955         case nss_lt_name:
956                 name = va_arg(ap, const char *);
957                 break;
958         case nss_lt_id:
959                 gid = va_arg(ap, gid_t);
960                 break;
961         case nss_lt_all:
962                 break;
963         }
964         grp     = va_arg(ap, struct group *);
965         buffer  = va_arg(ap, char *);
966         bufsize = va_arg(ap, size_t);
967         errnop  = va_arg(ap, int *);
968         *errnop = dns_getstate(&st);
969         if (*errnop != 0)
970                 return (NS_UNAVAIL);
971         if (hesiod_init(&ctx) != 0) {
972                 *errnop = errno;
973                 rv = NS_UNAVAIL;
974                 goto fin;
975         }
976         do {
977                 rv = NS_NOTFOUND;
978                 switch (how) {
979                 case nss_lt_name:
980                         label = name;
981                         break;
982                 case nss_lt_id:
983                         if (snprintf(buf, sizeof(buf), "%lu",
984                             (unsigned long)gid) >= sizeof(buf))
985                                 goto fin;
986                         label = buf;
987                         break;
988                 case nss_lt_all:
989                         if (st->counter < 0)
990                                 goto fin;
991                         if (snprintf(buf, sizeof(buf), "group-%ld",
992                             st->counter++) >= sizeof(buf))
993                                 goto fin;
994                         label = buf;
995                         break;
996                 }
997                 hes = hesiod_resolve(ctx, label,
998                     how == nss_lt_id ? "gid" : "group");
999                 if ((how == nss_lt_id && hes == NULL &&
1000                     (hes = hesiod_resolve(ctx, buf, "group")) == NULL) ||
1001                     hes == NULL) {
1002                         if (how == nss_lt_all)
1003                                 st->counter = -1;
1004                         if (errno != ENOENT)
1005                                 *errnop = errno;
1006                         goto fin;
1007                 }
1008                 rv = __gr_match_entry(hes[0], strlen(hes[0]), how, name, gid);
1009                 if (rv != NS_SUCCESS) {
1010                         hesiod_free_list(ctx, hes);
1011                         hes = NULL;
1012                         continue;
1013                 }
1014                 /* We need room at least for the line, a string NUL
1015                  * terminator, alignment padding, and one (char *)
1016                  * pointer for the member list terminator.
1017                  */
1018                 adjsize = bufsize - _ALIGNBYTES - sizeof(char *);
1019                 linesize = strlcpy(buffer, hes[0], adjsize);
1020                 if (linesize >= adjsize) {
1021                         *errnop = ERANGE;
1022                         rv = NS_RETURN;
1023                         goto fin;
1024                 }
1025                 hesiod_free_list(ctx, hes);
1026                 hes = NULL;
1027                 rv = __gr_parse_entry(buffer, linesize, grp,
1028                     &buffer[linesize + 1], bufsize - linesize - 1, errnop);
1029         } while (how == nss_lt_all && !(rv & NS_TERMINATE));
1030 fin:
1031         if (hes != NULL)
1032                 hesiod_free_list(ctx, hes);
1033         if (ctx != NULL)
1034                 hesiod_end(ctx);
1035         if (rv == NS_SUCCESS && retval != NULL)
1036                 *(struct group **)retval = grp;
1037         return (rv);
1038 }
1039 #endif /* HESIOD */
1040
1041
1042 #ifdef YP
1043 /*
1044  * nis backend
1045  */
1046 static void
1047 nis_endstate(void *p)
1048 {
1049
1050         if (p == NULL)
1051                 return;
1052         free(((struct nis_state *)p)->key);
1053         free(p);
1054 }
1055
1056
1057 static int
1058 nis_setgrent(void *retval __unused, void *cb_data __unused, va_list ap __unused)
1059 {
1060         struct nis_state        *st;
1061         int                      rv;
1062
1063         rv = nis_getstate(&st);
1064         if (rv != 0)
1065                 return (NS_UNAVAIL);
1066         st->done = 0;
1067         free(st->key);
1068         st->key = NULL;
1069         return (NS_UNAVAIL);
1070 }
1071
1072
1073 static int
1074 nis_group(void *retval, void *mdata, va_list ap)
1075 {
1076         char             *map;
1077         struct nis_state *st;
1078         struct group    *grp;
1079         const char      *name;
1080         char            *buffer, *key, *result;
1081         size_t           bufsize;
1082         gid_t            gid;
1083         enum nss_lookup_type how;
1084         int             *errnop, keylen, resultlen, rv;
1085
1086         name = NULL;
1087         gid = (gid_t)-1;
1088         how = (enum nss_lookup_type)mdata;
1089         switch (how) {
1090         case nss_lt_name:
1091                 name = va_arg(ap, const char *);
1092                 map = "group.byname";
1093                 break;
1094         case nss_lt_id:
1095                 gid = va_arg(ap, gid_t);
1096                 map = "group.bygid";
1097                 break;
1098         case nss_lt_all:
1099                 map = "group.byname";
1100                 break;
1101         }
1102         grp     = va_arg(ap, struct group *);
1103         buffer  = va_arg(ap, char *);
1104         bufsize = va_arg(ap, size_t);
1105         errnop  = va_arg(ap, int *);
1106         *errnop = nis_getstate(&st);
1107         if (*errnop != 0)
1108                 return (NS_UNAVAIL);
1109         if (st->domain[0] == '\0') {
1110                 if (getdomainname(st->domain, sizeof(st->domain)) != 0) {
1111                         *errnop = errno;
1112                         return (NS_UNAVAIL);
1113                 }
1114         }
1115         result = NULL;
1116         do {
1117                 rv = NS_NOTFOUND;
1118                 switch (how) {
1119                 case nss_lt_name:
1120                         if (strlcpy(buffer, name, bufsize) >= bufsize)
1121                                 goto erange;
1122                         break;
1123                 case nss_lt_id:
1124                         if (snprintf(buffer, bufsize, "%lu",
1125                             (unsigned long)gid) >= bufsize)
1126                                 goto erange;
1127                         break;
1128                 case nss_lt_all:
1129                         if (st->done)
1130                                 goto fin;
1131                         break;
1132                 }
1133                 result = NULL;
1134                 if (how == nss_lt_all) {
1135                         if (st->key == NULL)
1136                                 rv = yp_first(st->domain, map, &st->key,
1137                                     &st->keylen, &result, &resultlen);
1138                         else {
1139                                 key = st->key;
1140                                 keylen = st->keylen;
1141                                 st->key = NULL;
1142                                 rv = yp_next(st->domain, map, key, keylen,
1143                                     &st->key, &st->keylen, &result,
1144                                     &resultlen);
1145                                 free(key);
1146                         }
1147                         if (rv != 0) {
1148                                 free(result);
1149                                 free(st->key);
1150                                 st->key = NULL;
1151                                 if (rv == YPERR_NOMORE) {
1152                                         st->done = 1;
1153                                         rv = NS_NOTFOUND;
1154                                 } else
1155                                         rv = NS_UNAVAIL;
1156                                 goto fin;
1157                         }
1158                 } else {
1159                         rv = yp_match(st->domain, map, buffer, strlen(buffer),
1160                             &result, &resultlen);
1161                         if (rv == YPERR_KEY) {
1162                                 rv = NS_NOTFOUND;
1163                                 continue;
1164                         } else if (rv != 0) {
1165                                 free(result);
1166                                 rv = NS_UNAVAIL;
1167                                 continue;
1168                         }
1169                 }
1170                 /* We need room at least for the line, a string NUL
1171                  * terminator, alignment padding, and one (char *)
1172                  * pointer for the member list terminator.
1173                  */
1174                 if (resultlen >= bufsize - _ALIGNBYTES - sizeof(char *))
1175                         goto erange;
1176                 memcpy(buffer, result, resultlen);
1177                 buffer[resultlen] = '\0';
1178                 free(result);
1179                 rv = __gr_match_entry(buffer, resultlen, how, name, gid);
1180                 if (rv == NS_SUCCESS)
1181                         rv = __gr_parse_entry(buffer, resultlen, grp,
1182                             &buffer[resultlen+1], bufsize - resultlen - 1,
1183                             errnop);
1184         } while (how == nss_lt_all && !(rv & NS_TERMINATE));
1185 fin:
1186         if (rv == NS_SUCCESS && retval != NULL)
1187                 *(struct group **)retval = grp;
1188         return (rv);
1189 erange:
1190         *errnop = ERANGE;
1191         return (NS_RETURN);
1192 }
1193 #endif /* YP */
1194
1195
1196
1197 /*
1198  * compat backend
1199  */
1200 static void
1201 compat_endstate(void *p)
1202 {
1203         struct compat_state *st;
1204
1205         if (p == NULL)
1206                 return;
1207         st = (struct compat_state *)p;
1208         free(st->name);
1209         if (st->fp != NULL)
1210                 fclose(st->fp);
1211         free(p);
1212 }
1213
1214
1215 static int
1216 compat_setgrent(void *retval __unused, void *mdata, va_list ap)
1217 {
1218         static const ns_src compatsrc[] = {
1219 #ifdef YP
1220                 { NSSRC_NIS, NS_SUCCESS },
1221 #endif
1222                 { NULL, 0 }
1223         };
1224         ns_dtab dtab[] = {
1225 #ifdef HESIOD
1226                 { NSSRC_DNS, dns_setgrent, NULL },
1227 #endif
1228 #ifdef YP
1229                 { NSSRC_NIS, nis_setgrent, NULL },
1230 #endif
1231                 { NULL, NULL, NULL }
1232         };
1233         struct compat_state *st;
1234         int              rv, stayopen;
1235
1236 #define set_setent(x, y) do {                                   \
1237         int i;                                                  \
1238                                                                 \
1239         for (i = 0; i < (sizeof(x)/sizeof(x[0])) - 1; i++)      \
1240                 x[i].mdata = (void *)y;                         \
1241 } while (0)
1242
1243         rv = compat_getstate(&st);
1244         if (rv != 0)
1245                 return (NS_UNAVAIL);
1246         switch ((enum constants)mdata) {
1247         case SETGRENT:
1248                 stayopen = va_arg(ap, int);
1249                 if (st->fp != NULL)
1250                         rewind(st->fp);
1251                 else if (stayopen)
1252                         st->fp = fopen(_PATH_GROUP, "r");
1253                 set_setent(dtab, mdata);
1254                 _nsdispatch(NULL, dtab, NSDB_GROUP_COMPAT, "setgrent",
1255                     compatsrc, 0);
1256                 break;
1257         case ENDGRENT:
1258                 if (st->fp != NULL) {
1259                         fclose(st->fp);
1260                         st->fp = NULL;
1261                 }
1262                 set_setent(dtab, mdata);
1263                 _nsdispatch(NULL, dtab, NSDB_GROUP_COMPAT, "endgrent",
1264                     compatsrc, 0);
1265                 break;
1266         default:
1267                 break;
1268         }
1269         st->compat = COMPAT_MODE_OFF;
1270         free(st->name);
1271         st->name = NULL;
1272         return (NS_UNAVAIL);
1273 #undef set_setent
1274 }
1275
1276
1277 static int
1278 compat_group(void *retval, void *mdata, va_list ap)
1279 {
1280         static const ns_src compatsrc[] = {
1281 #ifdef YP
1282                 { NSSRC_NIS, NS_SUCCESS },
1283 #endif
1284                 { NULL, 0 }
1285         };
1286         ns_dtab dtab[] = {
1287 #ifdef YP
1288                 { NSSRC_NIS, nis_group, NULL },
1289 #endif
1290 #ifdef HESIOD
1291                 { NSSRC_DNS, dns_group, NULL },
1292 #endif
1293                 { NULL, NULL, NULL }
1294         };
1295         struct compat_state     *st;
1296         enum nss_lookup_type     how;
1297         const char              *name, *line;
1298         struct group            *grp;
1299         gid_t                    gid;
1300         char                    *buffer, *p;
1301         void                    *discard;
1302         size_t                   bufsize, linesize;
1303         off_t                    pos;
1304         int                      rv, stayopen, *errnop;
1305
1306 #define set_lookup_type(x, y) do {                              \
1307         int i;                                                  \
1308                                                                 \
1309         for (i = 0; i < (sizeof(x)/sizeof(x[0])) - 1; i++)      \
1310                 x[i].mdata = (void *)y;                         \
1311 } while (0)
1312
1313         name = NULL;
1314         gid = (gid_t)-1;
1315         how = (enum nss_lookup_type)mdata;
1316         switch (how) {
1317         case nss_lt_name:
1318                 name = va_arg(ap, const char *);
1319                 break;
1320         case nss_lt_id:
1321                 gid = va_arg(ap, gid_t);
1322                 break;
1323         case nss_lt_all:
1324                 break;
1325         default:
1326                 return (NS_NOTFOUND);
1327         }
1328         grp = va_arg(ap, struct group *);
1329         buffer = va_arg(ap, char *);
1330         bufsize = va_arg(ap, size_t);
1331         errnop = va_arg(ap, int *);
1332         *errnop = compat_getstate(&st);
1333         if (*errnop != 0)
1334                 return (NS_UNAVAIL);
1335         if (st->fp == NULL &&
1336             ((st->fp = fopen(_PATH_GROUP, "r")) == NULL)) {
1337                 *errnop = errno;
1338                 rv = NS_UNAVAIL;
1339                 goto fin;
1340         }
1341         if (how == nss_lt_all)
1342                 stayopen = 1;
1343         else {
1344                 rewind(st->fp);
1345                 stayopen = st->stayopen;
1346         }
1347 docompat:
1348         switch (st->compat) {
1349         case COMPAT_MODE_ALL:
1350                 set_lookup_type(dtab, how);
1351                 switch (how) {
1352                 case nss_lt_all:
1353                         rv = _nsdispatch(&discard, dtab, NSDB_GROUP_COMPAT,
1354                             "getgrent_r", compatsrc, grp, buffer, bufsize,
1355                             errnop);
1356                         break;
1357                 case nss_lt_id:
1358                         rv = _nsdispatch(&discard, dtab, NSDB_GROUP_COMPAT,
1359                             "getgrgid_r", compatsrc, gid, grp, buffer, bufsize,
1360                             errnop);
1361                         break;
1362                 case nss_lt_name:
1363                         rv = _nsdispatch(&discard, dtab, NSDB_GROUP_COMPAT,
1364                             "getgrnam_r", compatsrc, name, grp, buffer,
1365                             bufsize, errnop);
1366                         break;
1367                 }
1368                 if (rv & NS_TERMINATE)
1369                         goto fin;
1370                 st->compat = COMPAT_MODE_OFF;
1371                 break;
1372         case COMPAT_MODE_NAME:
1373                 set_lookup_type(dtab, nss_lt_name);
1374                 rv = _nsdispatch(&discard, dtab, NSDB_GROUP_COMPAT,
1375                     "getgrnam_r", compatsrc, st->name, grp, buffer, bufsize,
1376                     errnop);
1377                 switch (rv) {
1378                 case NS_SUCCESS:
1379                         switch (how) {
1380                         case nss_lt_name:
1381                                 if (strcmp(name, grp->gr_name) != 0)
1382                                         rv = NS_NOTFOUND;
1383                                 break;
1384                         case nss_lt_id:
1385                                 if (gid != grp->gr_gid)
1386                                         rv = NS_NOTFOUND;
1387                                 break;
1388                         default:
1389                                 break;
1390                         }
1391                         break;
1392                 case NS_RETURN:
1393                         goto fin;
1394                 default:
1395                         break;
1396                 }
1397                 free(st->name);
1398                 st->name = NULL;
1399                 st->compat = COMPAT_MODE_OFF;
1400                 if (rv == NS_SUCCESS)
1401                         goto fin;
1402                 break;
1403         default:
1404                 break;
1405         }
1406         rv = NS_NOTFOUND;
1407         pos = ftello(st->fp);
1408         while ((line = fgetln(st->fp, &linesize)) != NULL) {
1409                 if (line[linesize-1] == '\n')
1410                         linesize--;
1411                 if (linesize > 2 && line[0] == '+') {
1412                         p = memchr(&line[1], ':', linesize);
1413                         if (p == NULL || p == &line[1])
1414                                 st->compat = COMPAT_MODE_ALL;
1415                         else {
1416                                 st->name = malloc(p - line);
1417                                 if (st->name == NULL) {
1418                                         syslog(LOG_ERR,
1419                                          "getgrent memory allocation failure");
1420                                         *errnop = ENOMEM;
1421                                         rv = NS_UNAVAIL;
1422                                         break;
1423                                 }
1424                                 memcpy(st->name, &line[1], p - line - 1);
1425                                 st->name[p - line - 1] = '\0';
1426                                 st->compat = COMPAT_MODE_NAME;
1427                         }
1428                         goto docompat;
1429                 }
1430                 rv = __gr_match_entry(line, linesize, how, name, gid);
1431                 if (rv != NS_SUCCESS)
1432                         continue;
1433                 /* We need room at least for the line, a string NUL
1434                  * terminator, alignment padding, and one (char *)
1435                  * pointer for the member list terminator.
1436                  */
1437                 if (bufsize <= linesize + _ALIGNBYTES + sizeof(char *)) {
1438                         *errnop = ERANGE;
1439                         rv = NS_RETURN;
1440                         break;
1441                 }
1442                 memcpy(buffer, line, linesize);
1443                 buffer[linesize] = '\0';
1444                 rv = __gr_parse_entry(buffer, linesize, grp,
1445                     &buffer[linesize + 1], bufsize - linesize - 1, errnop);
1446                 if (rv & NS_TERMINATE)
1447                         break;
1448                 pos = ftello(st->fp);
1449         }
1450 fin:
1451         if (!stayopen && st->fp != NULL) {
1452                 fclose(st->fp);
1453                 st->fp = NULL;
1454         }
1455         if (rv == NS_SUCCESS && retval != NULL)
1456                 *(struct group **)retval = grp;
1457         else if (rv == NS_RETURN && *errnop == ERANGE && st->fp != NULL)
1458                 fseeko(st->fp, pos, SEEK_SET);
1459         return (rv);
1460 #undef set_lookup_type
1461 }
1462
1463
1464 /*
1465  * common group line matching and parsing
1466  */
1467 int
1468 __gr_match_entry(const char *line, size_t linesize, enum nss_lookup_type how,
1469     const char *name, gid_t gid)
1470 {
1471         size_t           namesize;
1472         const char      *p, *eol;
1473         char            *q;
1474         unsigned long    n;
1475         int              i, needed;
1476
1477         if (linesize == 0 || is_comment_line(line, linesize))
1478                 return (NS_NOTFOUND);
1479         switch (how) {
1480         case nss_lt_name:       needed = 1; break;
1481         case nss_lt_id:         needed = 2; break;
1482         default:                needed = 2; break;
1483         }
1484         eol = &line[linesize];
1485         for (p = line, i = 0; i < needed && p < eol; p++)
1486                 if (*p == ':')
1487                         i++;
1488         if (i < needed)
1489                 return (NS_NOTFOUND);
1490         switch (how) {
1491         case nss_lt_name:
1492                 namesize = strlen(name);
1493                 if (namesize + 1 == (size_t)(p - line) &&
1494                     memcmp(line, name, namesize) == 0)
1495                         return (NS_SUCCESS);
1496                 break;
1497         case nss_lt_id:
1498                 n = strtoul(p, &q, 10);
1499                 if (q < eol && *q == ':' && gid == (gid_t)n)
1500                         return (NS_SUCCESS);
1501                 break;
1502         case nss_lt_all:
1503                 return (NS_SUCCESS);
1504         default:
1505                 break;
1506         }
1507         return (NS_NOTFOUND);
1508 }
1509
1510
1511 int
1512 __gr_parse_entry(char *line, size_t linesize __unused, struct group *grp,
1513     char *membuf, size_t membufsize, int *errnop)
1514 {
1515         char           *s_gid, *s_mem, *p, **members;
1516         unsigned long   n;
1517         int             maxmembers;
1518
1519         memset(grp, 0, sizeof(*grp));
1520         members = (char **)_ALIGN(membuf);
1521         membufsize -= (char *)members - membuf;
1522         maxmembers = membufsize / sizeof(*members);
1523         if (maxmembers <= 0 ||
1524             (grp->gr_name = strsep(&line, ":")) == NULL ||
1525             grp->gr_name[0] == '\0' ||
1526             (grp->gr_passwd = strsep(&line, ":")) == NULL ||
1527             (s_gid = strsep(&line, ":")) == NULL ||
1528             s_gid[0] == '\0')
1529                 return (NS_NOTFOUND);
1530         s_mem = line;
1531         n = strtoul(s_gid, &s_gid, 10);
1532         if (s_gid[0] != '\0')
1533                 return (NS_NOTFOUND);
1534         grp->gr_gid = (gid_t)n;
1535         grp->gr_mem = members;
1536         while (maxmembers > 1 && s_mem != NULL) {
1537                 p = strsep(&s_mem, ",");
1538                 if (p != NULL && *p != '\0') {
1539                         *members++ = p;
1540                         maxmembers--;
1541                 }
1542         }
1543         *members = NULL;
1544         if (s_mem == NULL)
1545                 return (NS_SUCCESS);
1546         else {
1547                 *errnop = ERANGE;
1548                 return (NS_RETURN);
1549         }
1550 }