2 * Copyright (c) 2003 Networks Associates Technology, Inc.
5 * This software was developed for the FreeBSD Project by
6 * Jacques A. Vidrine, Safeport Network Services, and Network
7 * Associates Laboratories, the Security Research Division of Network
8 * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035
9 * ("CBOSS"), as part of the DARPA CHATS research program.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
36 #include "namespace.h"
37 #include <sys/param.h>
40 #include <rpcsvc/yp_prot.h>
41 #include <rpcsvc/ypclnt.h>
52 #include <pthread_np.h>
58 #include "un-namespace.h"
59 #include "libc_private.h"
66 GRP_STORAGE_INITIAL = 1 << 10, /* 1 KByte */
67 GRP_STORAGE_MAX = 1 << 20, /* 1 MByte */
70 HESIOD_NAME_MAX = 256,
73 static const ns_src defaultsrc[] = {
74 { NSSRC_COMPAT, NS_SUCCESS },
78 int __gr_match_entry(const char *, size_t, enum nss_lookup_type,
80 int __gr_parse_entry(char *, size_t, struct group *, char *, size_t,
83 static int is_comment_line(const char *, size_t);
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,
93 static int wrap_getgrgid_r(union key, struct group *, char *, size_t,
95 static int wrap_getgrent_r(union key, struct group *, char *, size_t,
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);
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);
121 char domain[MAXHOSTNAMELEN];
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);
132 struct compat_state {
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);
147 static int gr_addgid(gid_t, gid_t *, int, int *);
148 static int getgroupmembership_fallback(void *, void *, va_list);
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 *);
156 grp_id_func(char *buffer, size_t *buffer_size, va_list ap, void *cache_mdata)
161 size_t desired_size, size;
162 int res = NS_UNAVAIL;
163 enum nss_lookup_type lookup_type;
166 lookup_type = (enum nss_lookup_type)cache_mdata;
167 switch (lookup_type) {
169 name = va_arg(ap, char *);
171 desired_size = sizeof(enum nss_lookup_type) + size + 1;
172 if (desired_size > *buffer_size) {
177 memcpy(buffer, &lookup_type, sizeof(enum nss_lookup_type));
178 memcpy(buffer + sizeof(enum nss_lookup_type), name, size + 1);
183 gid = va_arg(ap, gid_t);
184 desired_size = sizeof(enum nss_lookup_type) + sizeof(gid_t);
185 if (desired_size > *buffer_size) {
190 memcpy(buffer, &lookup_type, sizeof(enum nss_lookup_type));
191 memcpy(buffer + sizeof(enum nss_lookup_type), &gid,
197 /* should be unreachable */
202 *buffer_size = desired_size;
207 grp_marshal_func(char *buffer, size_t *buffer_size, void *retval, va_list ap,
214 size_t orig_buf_size;
216 struct group new_grp;
217 size_t desired_size, size, mem_size;
220 switch ((enum nss_lookup_type)cache_mdata) {
222 name = va_arg(ap, char *);
225 gid = va_arg(ap, gid_t);
230 /* should be unreachable */
234 grp = va_arg(ap, struct group *);
235 orig_buf = va_arg(ap, char *);
236 orig_buf_size = va_arg(ap, size_t);
238 desired_size = _ALIGNBYTES + sizeof(struct group) + sizeof(char *);
240 if (grp->gr_name != NULL)
241 desired_size += strlen(grp->gr_name) + 1;
242 if (grp->gr_passwd != NULL)
243 desired_size += strlen(grp->gr_passwd) + 1;
245 if (grp->gr_mem != NULL) {
247 for (mem = grp->gr_mem; *mem; ++mem) {
248 desired_size += strlen(*mem) + 1;
252 desired_size += _ALIGNBYTES + (mem_size + 1) * sizeof(char *);
255 if (desired_size > *buffer_size) {
256 /* this assignment is here for future use */
257 *buffer_size = desired_size;
261 memcpy(&new_grp, grp, sizeof(struct group));
262 memset(buffer, 0, desired_size);
264 *buffer_size = desired_size;
265 p = buffer + sizeof(struct group) + sizeof(char *);
266 memcpy(buffer + sizeof(struct group), &p, sizeof(char *));
267 p = (char *)_ALIGN(p);
269 if (new_grp.gr_name != NULL) {
270 size = strlen(new_grp.gr_name);
271 memcpy(p, new_grp.gr_name, size);
276 if (new_grp.gr_passwd != NULL) {
277 size = strlen(new_grp.gr_passwd);
278 memcpy(p, new_grp.gr_passwd, size);
279 new_grp.gr_passwd = p;
283 if (new_grp.gr_mem != NULL) {
284 p = (char *)_ALIGN(p);
285 memcpy(p, new_grp.gr_mem, sizeof(char *) * mem_size);
286 new_grp.gr_mem = (char **)p;
287 p += sizeof(char *) * (mem_size + 1);
289 for (mem = new_grp.gr_mem; *mem; ++mem) {
291 memcpy(p, *mem, size);
297 memcpy(buffer, &new_grp, sizeof(struct group));
302 grp_unmarshal_func(char *buffer, size_t buffer_size, void *retval, va_list ap,
309 size_t orig_buf_size;
315 switch ((enum nss_lookup_type)cache_mdata) {
317 name = va_arg(ap, char *);
320 gid = va_arg(ap, gid_t);
325 /* should be unreachable */
329 grp = va_arg(ap, struct group *);
330 orig_buf = va_arg(ap, char *);
331 orig_buf_size = va_arg(ap, size_t);
332 ret_errno = va_arg(ap, int *);
335 buffer_size - sizeof(struct group) - sizeof(char *)) {
340 memcpy(grp, buffer, sizeof(struct group));
341 memcpy(&p, buffer + sizeof(struct group), sizeof(char *));
343 orig_buf = (char *)_ALIGN(orig_buf);
344 memcpy(orig_buf, buffer + sizeof(struct group) + sizeof(char *) +
345 _ALIGN(p) - (size_t)p,
346 buffer_size - sizeof(struct group) - sizeof(char *) -
347 _ALIGN(p) + (size_t)p);
348 p = (char *)_ALIGN(p);
350 NS_APPLY_OFFSET(grp->gr_name, orig_buf, p, char *);
351 NS_APPLY_OFFSET(grp->gr_passwd, orig_buf, p, char *);
352 if (grp->gr_mem != NULL) {
353 NS_APPLY_OFFSET(grp->gr_mem, orig_buf, p, char **);
355 for (mem = grp->gr_mem; *mem; ++mem)
356 NS_APPLY_OFFSET(*mem, orig_buf, p, char *);
360 *((struct group **)retval) = grp;
365 NSS_MP_CACHE_HANDLING(group);
366 #endif /* NS_CACHING */
369 static const nss_cache_info setgrent_cache_info = NS_MP_CACHE_INFO_INITIALIZER(
370 group, (void *)nss_lt_all,
374 static const ns_dtab setgrent_dtab[] = {
375 { NSSRC_FILES, files_setgrent, (void *)SETGRENT },
377 { NSSRC_DNS, dns_setgrent, (void *)SETGRENT },
380 { NSSRC_NIS, nis_setgrent, (void *)SETGRENT },
382 { NSSRC_COMPAT, compat_setgrent, (void *)SETGRENT },
384 NS_CACHE_CB(&setgrent_cache_info)
390 static const nss_cache_info endgrent_cache_info = NS_MP_CACHE_INFO_INITIALIZER(
391 group, (void *)nss_lt_all,
395 static const ns_dtab endgrent_dtab[] = {
396 { NSSRC_FILES, files_setgrent, (void *)ENDGRENT },
398 { NSSRC_DNS, dns_setgrent, (void *)ENDGRENT },
401 { NSSRC_NIS, nis_setgrent, (void *)ENDGRENT },
403 { NSSRC_COMPAT, compat_setgrent, (void *)ENDGRENT },
405 NS_CACHE_CB(&endgrent_cache_info)
411 static const nss_cache_info getgrent_r_cache_info = NS_MP_CACHE_INFO_INITIALIZER(
412 group, (void *)nss_lt_all,
413 grp_marshal_func, grp_unmarshal_func);
416 static const ns_dtab getgrent_r_dtab[] = {
417 { NSSRC_FILES, files_group, (void *)nss_lt_all },
419 { NSSRC_DNS, dns_group, (void *)nss_lt_all },
422 { NSSRC_NIS, nis_group, (void *)nss_lt_all },
424 { NSSRC_COMPAT, compat_group, (void *)nss_lt_all },
426 NS_CACHE_CB(&getgrent_r_cache_info)
432 gr_addgid(gid_t gid, gid_t *groups, int maxgrp, int *grpcnt)
436 for (dupc = 0; dupc < MIN(maxgrp, *grpcnt); dupc++) {
437 if (groups[dupc] == gid)
442 if (*grpcnt < maxgrp)
443 groups[*grpcnt] = gid;
453 getgroupmembership_fallback(void *retval, void *mdata, va_list ap)
455 const ns_src src[] = {
456 { mdata, NS_SUCCESS },
467 int i, rv, ret_errno;
470 * As this is a fallback method, only provided src
471 * list will be respected during methods search.
473 assert(src[0].name != NULL);
475 uname = va_arg(ap, const char *);
476 agroup = va_arg(ap, gid_t);
477 groups = va_arg(ap, gid_t *);
478 maxgrp = va_arg(ap, int);
479 grpcnt = va_arg(ap, int *);
483 buf = malloc(GRP_STORAGE_INITIAL);
487 bufsize = GRP_STORAGE_INITIAL;
489 gr_addgid(agroup, groups, maxgrp, grpcnt);
491 _nsdispatch(NULL, setgrent_dtab, NSDB_GROUP, "setgrent", src, 0);
496 rv = _nsdispatch(&grp_p, getgrent_r_dtab, NSDB_GROUP,
497 "getgrent_r", src, &grp, buf, bufsize, &ret_errno);
499 if (grp_p == NULL && ret_errno == ERANGE) {
501 if ((bufsize << 1) > GRP_STORAGE_MAX) {
508 buf = malloc(bufsize);
513 } while (grp_p == NULL && ret_errno == ERANGE);
515 if (ret_errno != 0) {
523 for (i = 0; grp.gr_mem[i]; i++) {
524 if (strcmp(grp.gr_mem[i], uname) == 0)
525 gr_addgid(grp.gr_gid, groups, maxgrp, grpcnt);
529 _nsdispatch(NULL, endgrent_dtab, NSDB_GROUP, "endgrent", src);
535 /* XXX IEEE Std 1003.1, 2003 specifies `void setgrent(void)' */
539 (void)_nsdispatch(NULL, setgrent_dtab, NSDB_GROUP, "setgrent", defaultsrc, 0);
545 setgroupent(int stayopen)
547 (void)_nsdispatch(NULL, setgrent_dtab, NSDB_GROUP, "setgrent", defaultsrc,
556 (void)_nsdispatch(NULL, endgrent_dtab, NSDB_GROUP, "endgrent", defaultsrc);
561 getgrent_r(struct group *grp, char *buffer, size_t bufsize,
562 struct group **result)
568 rv = _nsdispatch(result, getgrent_r_dtab, NSDB_GROUP, "getgrent_r", defaultsrc,
569 grp, buffer, bufsize, &ret_errno);
570 if (rv == NS_SUCCESS)
578 getgrnam_r(const char *name, struct group *grp, char *buffer, size_t bufsize,
579 struct group **result)
582 static const nss_cache_info cache_info =
583 NS_COMMON_CACHE_INFO_INITIALIZER(
584 group, (void *)nss_lt_name,
585 grp_id_func, grp_marshal_func, grp_unmarshal_func);
588 static const ns_dtab dtab[] = {
589 { NSSRC_FILES, files_group, (void *)nss_lt_name },
591 { NSSRC_DNS, dns_group, (void *)nss_lt_name },
594 { NSSRC_NIS, nis_group, (void *)nss_lt_name },
596 { NSSRC_COMPAT, compat_group, (void *)nss_lt_name },
598 NS_CACHE_CB(&cache_info)
606 rv = _nsdispatch(result, dtab, NSDB_GROUP, "getgrnam_r", defaultsrc,
607 name, grp, buffer, bufsize, &ret_errno);
608 if (rv == NS_SUCCESS)
616 getgrgid_r(gid_t gid, struct group *grp, char *buffer, size_t bufsize,
617 struct group **result)
620 static const nss_cache_info cache_info =
621 NS_COMMON_CACHE_INFO_INITIALIZER(
622 group, (void *)nss_lt_id,
623 grp_id_func, grp_marshal_func, grp_unmarshal_func);
626 static const ns_dtab dtab[] = {
627 { NSSRC_FILES, files_group, (void *)nss_lt_id },
629 { NSSRC_DNS, dns_group, (void *)nss_lt_id },
632 { NSSRC_NIS, nis_group, (void *)nss_lt_id },
634 { NSSRC_COMPAT, compat_group, (void *)nss_lt_id },
636 NS_CACHE_CB(&cache_info)
644 rv = _nsdispatch(result, dtab, NSDB_GROUP, "getgrgid_r", defaultsrc,
645 gid, grp, buffer, bufsize, &ret_errno);
646 if (rv == NS_SUCCESS)
655 __getgroupmembership(const char *uname, gid_t agroup, gid_t *groups,
656 int maxgrp, int *grpcnt)
658 static const ns_dtab dtab[] = {
659 NS_FALLBACK_CB(getgroupmembership_fallback)
664 assert(uname != NULL);
665 /* groups may be NULL if just sizing when invoked with maxgrp = 0 */
666 assert(grpcnt != NULL);
669 rv = _nsdispatch(NULL, dtab, NSDB_GROUP, "getgroupmembership",
670 defaultsrc, uname, agroup, groups, maxgrp, grpcnt);
672 /* too many groups found? */
673 return (*grpcnt > maxgrp ? -1 : 0);
677 static struct group grp;
678 static char *grp_storage;
679 static size_t grp_storage_size;
681 static struct group *
682 getgr(int (*fn)(union key, struct group *, char *, size_t, struct group **),
688 if (grp_storage == NULL) {
689 grp_storage = malloc(GRP_STORAGE_INITIAL);
690 if (grp_storage == NULL)
692 grp_storage_size = GRP_STORAGE_INITIAL;
695 rv = fn(key, &grp, grp_storage, grp_storage_size, &res);
696 if (res == NULL && rv == ERANGE) {
698 if ((grp_storage_size << 1) > GRP_STORAGE_MAX) {
703 grp_storage_size <<= 1;
704 grp_storage = malloc(grp_storage_size);
705 if (grp_storage == NULL)
708 } while (res == NULL && rv == ERANGE);
716 wrap_getgrnam_r(union key key, struct group *grp, char *buffer, size_t bufsize,
719 return (getgrnam_r(key.name, grp, buffer, bufsize, res));
724 wrap_getgrgid_r(union key key, struct group *grp, char *buffer, size_t bufsize,
727 return (getgrgid_r(key.gid, grp, buffer, bufsize, res));
732 wrap_getgrent_r(union key key __unused, struct group *grp, char *buffer,
733 size_t bufsize, struct group **res)
735 return (getgrent_r(grp, buffer, bufsize, res));
740 getgrnam(const char *name)
745 return (getgr(wrap_getgrnam_r, key));
755 return (getgr(wrap_getgrgid_r, key));
764 key.gid = 0; /* not used */
765 return (getgr(wrap_getgrent_r, key));
770 is_comment_line(const char *s, size_t n)
777 if (*s == '#' || !isspace((unsigned char)*s))
779 return (*s == '#' || s == eom);
787 files_endstate(void *p)
792 if (((struct files_state *)p)->fp != NULL)
793 fclose(((struct files_state *)p)->fp);
799 files_setgrent(void *retval, void *mdata, va_list ap)
801 struct files_state *st;
804 rv = files_getstate(&st);
807 switch ((enum constants)mdata) {
809 stayopen = va_arg(ap, int);
813 st->fp = fopen(_PATH_GROUP, "r");
816 if (st->fp != NULL) {
829 files_group(void *retval, void *mdata, va_list ap)
831 struct files_state *st;
832 enum nss_lookup_type how;
833 const char *name, *line;
837 size_t bufsize, linesize;
839 int rv, stayopen, *errnop;
843 how = (enum nss_lookup_type)mdata;
846 name = va_arg(ap, const char *);
849 gid = va_arg(ap, gid_t);
854 return (NS_NOTFOUND);
856 grp = va_arg(ap, struct group *);
857 buffer = va_arg(ap, char *);
858 bufsize = va_arg(ap, size_t);
859 errnop = va_arg(ap, int *);
860 *errnop = files_getstate(&st);
863 if (st->fp == NULL &&
864 ((st->fp = fopen(_PATH_GROUP, "r")) == NULL)) {
868 if (how == nss_lt_all)
872 stayopen = st->stayopen;
875 pos = ftello(st->fp);
876 while ((line = fgetln(st->fp, &linesize)) != NULL) {
877 if (line[linesize-1] == '\n')
879 rv = __gr_match_entry(line, linesize, how, name, gid);
880 if (rv != NS_SUCCESS)
882 /* We need room at least for the line, a string NUL
883 * terminator, alignment padding, and one (char *)
884 * pointer for the member list terminator.
886 if (bufsize <= linesize + _ALIGNBYTES + sizeof(char *)) {
891 memcpy(buffer, line, linesize);
892 buffer[linesize] = '\0';
893 rv = __gr_parse_entry(buffer, linesize, grp,
894 &buffer[linesize + 1], bufsize - linesize - 1, errnop);
895 if (rv & NS_TERMINATE)
897 pos = ftello(st->fp);
899 if (!stayopen && st->fp != NULL) {
903 if (rv == NS_SUCCESS && retval != NULL)
904 *(struct group **)retval = grp;
905 else if (rv == NS_RETURN && *errnop == ERANGE && st->fp != NULL)
906 fseeko(st->fp, pos, SEEK_SET);
916 dns_endstate(void *p)
924 dns_setgrent(void *retval, void *cb_data, va_list ap)
926 struct dns_state *st;
929 rv = dns_getstate(&st);
938 dns_group(void *retval, void *mdata, va_list ap)
940 char buf[HESIOD_NAME_MAX];
941 struct dns_state *st;
943 const char *name, *label;
946 size_t bufsize, adjsize, linesize;
948 enum nss_lookup_type how;
955 how = (enum nss_lookup_type)mdata;
958 name = va_arg(ap, const char *);
961 gid = va_arg(ap, gid_t);
966 grp = va_arg(ap, struct group *);
967 buffer = va_arg(ap, char *);
968 bufsize = va_arg(ap, size_t);
969 errnop = va_arg(ap, int *);
970 *errnop = dns_getstate(&st);
973 if (hesiod_init(&ctx) != 0) {
985 if (snprintf(buf, sizeof(buf), "%lu",
986 (unsigned long)gid) >= sizeof(buf))
993 if (snprintf(buf, sizeof(buf), "group-%ld",
994 st->counter++) >= sizeof(buf))
999 hes = hesiod_resolve(ctx, label,
1000 how == nss_lt_id ? "gid" : "group");
1001 if ((how == nss_lt_id && hes == NULL &&
1002 (hes = hesiod_resolve(ctx, buf, "group")) == NULL) ||
1004 if (how == nss_lt_all)
1006 if (errno != ENOENT)
1010 rv = __gr_match_entry(hes[0], strlen(hes[0]), how, name, gid);
1011 if (rv != NS_SUCCESS) {
1012 hesiod_free_list(ctx, hes);
1016 /* We need room at least for the line, a string NUL
1017 * terminator, alignment padding, and one (char *)
1018 * pointer for the member list terminator.
1020 adjsize = bufsize - _ALIGNBYTES - sizeof(char *);
1021 linesize = strlcpy(buffer, hes[0], adjsize);
1022 if (linesize >= adjsize) {
1027 hesiod_free_list(ctx, hes);
1029 rv = __gr_parse_entry(buffer, linesize, grp,
1030 &buffer[linesize + 1], bufsize - linesize - 1, errnop);
1031 } while (how == nss_lt_all && !(rv & NS_TERMINATE));
1034 hesiod_free_list(ctx, hes);
1037 if (rv == NS_SUCCESS && retval != NULL)
1038 *(struct group **)retval = grp;
1049 nis_endstate(void *p)
1054 free(((struct nis_state *)p)->key);
1060 nis_setgrent(void *retval, void *cb_data, va_list ap)
1062 struct nis_state *st;
1065 rv = nis_getstate(&st);
1067 return (NS_UNAVAIL);
1071 return (NS_UNAVAIL);
1076 nis_group(void *retval, void *mdata, va_list ap)
1079 struct nis_state *st;
1082 char *buffer, *key, *result;
1085 enum nss_lookup_type how;
1086 int *errnop, keylen, resultlen, rv;
1090 how = (enum nss_lookup_type)mdata;
1093 name = va_arg(ap, const char *);
1094 map = "group.byname";
1097 gid = va_arg(ap, gid_t);
1098 map = "group.bygid";
1101 map = "group.byname";
1104 grp = va_arg(ap, struct group *);
1105 buffer = va_arg(ap, char *);
1106 bufsize = va_arg(ap, size_t);
1107 errnop = va_arg(ap, int *);
1108 *errnop = nis_getstate(&st);
1110 return (NS_UNAVAIL);
1111 if (st->domain[0] == '\0') {
1112 if (getdomainname(st->domain, sizeof(st->domain)) != 0) {
1114 return (NS_UNAVAIL);
1122 if (strlcpy(buffer, name, bufsize) >= bufsize)
1126 if (snprintf(buffer, bufsize, "%lu",
1127 (unsigned long)gid) >= bufsize)
1136 if (how == nss_lt_all) {
1137 if (st->key == NULL)
1138 rv = yp_first(st->domain, map, &st->key,
1139 &st->keylen, &result, &resultlen);
1142 keylen = st->keylen;
1144 rv = yp_next(st->domain, map, key, keylen,
1145 &st->key, &st->keylen, &result,
1153 if (rv == YPERR_NOMORE) {
1161 rv = yp_match(st->domain, map, buffer, strlen(buffer),
1162 &result, &resultlen);
1163 if (rv == YPERR_KEY) {
1166 } else if (rv != 0) {
1172 /* We need room at least for the line, a string NUL
1173 * terminator, alignment padding, and one (char *)
1174 * pointer for the member list terminator.
1176 if (resultlen >= bufsize - _ALIGNBYTES - sizeof(char *))
1178 memcpy(buffer, result, resultlen);
1179 buffer[resultlen] = '\0';
1181 rv = __gr_match_entry(buffer, resultlen, how, name, gid);
1182 if (rv == NS_SUCCESS)
1183 rv = __gr_parse_entry(buffer, resultlen, grp,
1184 &buffer[resultlen+1], bufsize - resultlen - 1,
1186 } while (how == nss_lt_all && !(rv & NS_TERMINATE));
1188 if (rv == NS_SUCCESS && retval != NULL)
1189 *(struct group **)retval = grp;
1203 compat_endstate(void *p)
1205 struct compat_state *st;
1209 st = (struct compat_state *)p;
1218 compat_setgrent(void *retval, void *mdata, va_list ap)
1220 static const ns_src compatsrc[] = {
1222 { NSSRC_NIS, NS_SUCCESS },
1228 { NSSRC_DNS, dns_setgrent, NULL },
1231 { NSSRC_NIS, nis_setgrent, NULL },
1233 { NULL, NULL, NULL }
1235 struct compat_state *st;
1238 #define set_setent(x, y) do { \
1241 for (i = 0; i < (sizeof(x)/sizeof(x[0])) - 1; i++) \
1242 x[i].mdata = (void *)y; \
1245 rv = compat_getstate(&st);
1247 return (NS_UNAVAIL);
1248 switch ((enum constants)mdata) {
1250 stayopen = va_arg(ap, int);
1254 st->fp = fopen(_PATH_GROUP, "r");
1255 set_setent(dtab, mdata);
1256 (void)_nsdispatch(NULL, dtab, NSDB_GROUP_COMPAT, "setgrent",
1260 if (st->fp != NULL) {
1264 set_setent(dtab, mdata);
1265 (void)_nsdispatch(NULL, dtab, NSDB_GROUP_COMPAT, "endgrent",
1271 st->compat = COMPAT_MODE_OFF;
1274 return (NS_UNAVAIL);
1280 compat_group(void *retval, void *mdata, va_list ap)
1282 static const ns_src compatsrc[] = {
1284 { NSSRC_NIS, NS_SUCCESS },
1290 { NSSRC_NIS, nis_group, NULL },
1293 { NSSRC_DNS, dns_group, NULL },
1295 { NULL, NULL, NULL }
1297 struct compat_state *st;
1298 enum nss_lookup_type how;
1299 const char *name, *line;
1304 size_t bufsize, linesize;
1306 int rv, stayopen, *errnop;
1308 #define set_lookup_type(x, y) do { \
1311 for (i = 0; i < (sizeof(x)/sizeof(x[0])) - 1; i++) \
1312 x[i].mdata = (void *)y; \
1317 how = (enum nss_lookup_type)mdata;
1320 name = va_arg(ap, const char *);
1323 gid = va_arg(ap, gid_t);
1328 return (NS_NOTFOUND);
1330 grp = va_arg(ap, struct group *);
1331 buffer = va_arg(ap, char *);
1332 bufsize = va_arg(ap, size_t);
1333 errnop = va_arg(ap, int *);
1334 *errnop = compat_getstate(&st);
1336 return (NS_UNAVAIL);
1337 if (st->fp == NULL &&
1338 ((st->fp = fopen(_PATH_GROUP, "r")) == NULL)) {
1343 if (how == nss_lt_all)
1347 stayopen = st->stayopen;
1350 switch (st->compat) {
1351 case COMPAT_MODE_ALL:
1352 set_lookup_type(dtab, how);
1355 rv = _nsdispatch(&discard, dtab, NSDB_GROUP_COMPAT,
1356 "getgrent_r", compatsrc, grp, buffer, bufsize,
1360 rv = _nsdispatch(&discard, dtab, NSDB_GROUP_COMPAT,
1361 "getgrgid_r", compatsrc, gid, grp, buffer, bufsize,
1365 rv = _nsdispatch(&discard, dtab, NSDB_GROUP_COMPAT,
1366 "getgrnam_r", compatsrc, name, grp, buffer,
1370 if (rv & NS_TERMINATE)
1372 st->compat = COMPAT_MODE_OFF;
1374 case COMPAT_MODE_NAME:
1375 set_lookup_type(dtab, nss_lt_name);
1376 rv = _nsdispatch(&discard, dtab, NSDB_GROUP_COMPAT,
1377 "getgrnam_r", compatsrc, st->name, grp, buffer, bufsize,
1383 if (strcmp(name, grp->gr_name) != 0)
1387 if (gid != grp->gr_gid)
1401 st->compat = COMPAT_MODE_OFF;
1402 if (rv == NS_SUCCESS)
1409 pos = ftello(st->fp);
1410 while ((line = fgetln(st->fp, &linesize)) != NULL) {
1411 if (line[linesize-1] == '\n')
1413 if (linesize > 2 && line[0] == '+') {
1414 p = memchr(&line[1], ':', linesize);
1415 if (p == NULL || p == &line[1])
1416 st->compat = COMPAT_MODE_ALL;
1418 st->name = malloc(p - line);
1419 if (st->name == NULL) {
1421 "getgrent memory allocation failure");
1426 memcpy(st->name, &line[1], p - line - 1);
1427 st->name[p - line - 1] = '\0';
1428 st->compat = COMPAT_MODE_NAME;
1432 rv = __gr_match_entry(line, linesize, how, name, gid);
1433 if (rv != NS_SUCCESS)
1435 /* We need room at least for the line, a string NUL
1436 * terminator, alignment padding, and one (char *)
1437 * pointer for the member list terminator.
1439 if (bufsize <= linesize + _ALIGNBYTES + sizeof(char *)) {
1444 memcpy(buffer, line, linesize);
1445 buffer[linesize] = '\0';
1446 rv = __gr_parse_entry(buffer, linesize, grp,
1447 &buffer[linesize + 1], bufsize - linesize - 1, errnop);
1448 if (rv & NS_TERMINATE)
1450 pos = ftello(st->fp);
1453 if (!stayopen && st->fp != NULL) {
1457 if (rv == NS_SUCCESS && retval != NULL)
1458 *(struct group **)retval = grp;
1459 else if (rv == NS_RETURN && *errnop == ERANGE && st->fp != NULL)
1460 fseeko(st->fp, pos, SEEK_SET);
1462 #undef set_lookup_type
1467 * common group line matching and parsing
1470 __gr_match_entry(const char *line, size_t linesize, enum nss_lookup_type how,
1471 const char *name, gid_t gid)
1474 const char *p, *eol;
1479 if (linesize == 0 || is_comment_line(line, linesize))
1480 return (NS_NOTFOUND);
1482 case nss_lt_name: needed = 1; break;
1483 case nss_lt_id: needed = 2; break;
1484 default: needed = 2; break;
1486 eol = &line[linesize];
1487 for (p = line, i = 0; i < needed && p < eol; p++)
1491 return (NS_NOTFOUND);
1494 namesize = strlen(name);
1495 if (namesize + 1 == (size_t)(p - line) &&
1496 memcmp(line, name, namesize) == 0)
1497 return (NS_SUCCESS);
1500 n = strtoul(p, &q, 10);
1501 if (q < eol && *q == ':' && gid == (gid_t)n)
1502 return (NS_SUCCESS);
1505 return (NS_SUCCESS);
1509 return (NS_NOTFOUND);
1514 __gr_parse_entry(char *line, size_t linesize, struct group *grp, char *membuf,
1515 size_t membufsize, int *errnop)
1517 char *s_gid, *s_mem, *p, **members;
1521 memset(grp, 0, sizeof(*grp));
1522 members = (char **)_ALIGN(membuf);
1523 membufsize -= (char *)members - membuf;
1524 maxmembers = membufsize / sizeof(*members);
1525 if (maxmembers <= 0 ||
1526 (grp->gr_name = strsep(&line, ":")) == NULL ||
1527 grp->gr_name[0] == '\0' ||
1528 (grp->gr_passwd = strsep(&line, ":")) == NULL ||
1529 (s_gid = strsep(&line, ":")) == NULL ||
1531 return (NS_NOTFOUND);
1533 n = strtoul(s_gid, &s_gid, 10);
1534 if (s_gid[0] != '\0')
1535 return (NS_NOTFOUND);
1536 grp->gr_gid = (gid_t)n;
1537 grp->gr_mem = members;
1538 while (maxmembers > 1 && s_mem != NULL) {
1539 p = strsep(&s_mem, ",");
1540 if (p != NULL && *p != '\0') {
1547 return (NS_SUCCESS);