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