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