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