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