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