getpwent.c revision 1.64
1 /* $NetBSD: getpwent.c,v 1.64 2004/11/10 04:11:34 lukem Exp $ */ 2 3 /*- 4 * Copyright (c) 1997-2000, 2004 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Luke Mewburn. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 /* 40 * Copyright (c) 1988, 1993 41 * The Regents of the University of California. All rights reserved. 42 * 43 * Redistribution and use in source and binary forms, with or without 44 * modification, are permitted provided that the following conditions 45 * are met: 46 * 1. Redistributions of source code must retain the above copyright 47 * notice, this list of conditions and the following disclaimer. 48 * 2. Redistributions in binary form must reproduce the above copyright 49 * notice, this list of conditions and the following disclaimer in the 50 * documentation and/or other materials provided with the distribution. 51 * 3. Neither the name of the University nor the names of its contributors 52 * may be used to endorse or promote products derived from this software 53 * without specific prior written permission. 54 * 55 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 56 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 57 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 58 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 59 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 60 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 61 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 62 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 63 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 64 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 65 * SUCH DAMAGE. 66 */ 67 68 /* 69 * Portions Copyright (c) 1994, 1995, Jason Downs. All rights reserved. 70 * 71 * Redistribution and use in source and binary forms, with or without 72 * modification, are permitted provided that the following conditions 73 * are met: 74 * 1. Redistributions of source code must retain the above copyright 75 * notice, this list of conditions and the following disclaimer. 76 * 2. Redistributions in binary form must reproduce the above copyright 77 * notice, this list of conditions and the following disclaimer in the 78 * documentation and/or other materials provided with the distribution. 79 * 80 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS 81 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 82 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 83 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, 84 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 85 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 86 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 87 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 88 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 89 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 90 * SUCH DAMAGE. 91 */ 92 93 #include <sys/cdefs.h> 94 #if defined(LIBC_SCCS) && !defined(lint) 95 #if 0 96 static char sccsid[] = "@(#)getpwent.c 8.2 (Berkeley) 4/27/95"; 97 #else 98 __RCSID("$NetBSD: getpwent.c,v 1.64 2004/11/10 04:11:34 lukem Exp $"); 99 #endif 100 #endif /* LIBC_SCCS and not lint */ 101 102 #include "namespace.h" 103 #include "reentrant.h" 104 105 #include <sys/param.h> 106 107 #include <assert.h> 108 #include <db.h> 109 #include <errno.h> 110 #include <fcntl.h> 111 #include <limits.h> 112 #include <netgroup.h> 113 #include <nsswitch.h> 114 #include <pwd.h> 115 #include <stdarg.h> 116 #include <stdio.h> 117 #include <stdlib.h> 118 #include <string.h> 119 #include <syslog.h> 120 #include <unistd.h> 121 122 #ifdef HESIOD 123 #include <hesiod.h> 124 #endif 125 126 #ifdef YP 127 #include <machine/param.h> 128 #include <rpc/rpc.h> 129 #include <rpcsvc/yp_prot.h> 130 #include <rpcsvc/ypclnt.h> 131 #endif 132 133 #include "pw_private.h" 134 135 #define _PASSWD_COMPAT /* "passwd" defaults to compat, so always provide it */ 136 137 #ifdef __weak_alias 138 __weak_alias(endpwent,_endpwent) 139 __weak_alias(getpwent,_getpwent) 140 __weak_alias(getpwnam,_getpwnam) 141 __weak_alias(getpwnam_r,_getpwnam_r) 142 __weak_alias(getpwuid,_getpwuid) 143 __weak_alias(getpwuid_r,_getpwuid_r) 144 __weak_alias(setpassent,_setpassent) 145 __weak_alias(setpwent,_setpwent) 146 #endif 147 148 #ifdef _REENTRANT 149 static mutex_t _pwmutex = MUTEX_INITIALIZER; 150 #endif 151 152 const char __yp_token[] = "__YP!"; /* Let pwd_mkdb pull this in. */ 153 154 static const ns_src defaultcompat[] = { 155 { NSSRC_COMPAT, NS_SUCCESS }, 156 { 0 } 157 }; 158 159 static const ns_src defaultcompat_forceall[] = { 160 { NSSRC_COMPAT, NS_SUCCESS | NS_FORCEALL }, 161 { 0 } 162 }; 163 164 static const ns_src defaultnis[] = { 165 { NSSRC_NIS, NS_SUCCESS }, 166 { 0 } 167 }; 168 169 static const ns_src defaultnis_forceall[] = { 170 { NSSRC_NIS, NS_SUCCESS | NS_FORCEALL }, 171 { 0 } 172 }; 173 174 175 /* 176 * The pwd.db lookup techniques and data extraction code here must be kept 177 * in sync with that in `pwd_mkdb'. 178 */ 179 180 #if defined(YP) || defined(HESIOD) 181 /* 182 * _pw_parse 183 * Parses entry using pw_scan(3) (without the trailing \n) 184 * after copying to buf, and fills in pw with corresponding values. 185 * If old is non-zero, entry is in _PASSWORD_OLDFMT. 186 * Returns 1 if parsed successfully, 0 on parse failure. 187 */ 188 static int 189 _pw_parse(const char *entry, struct passwd *pw, char *buf, size_t buflen, 190 int old) 191 { 192 int flags; 193 194 _DIAGASSERT(entry != NULL); 195 _DIAGASSERT(pw != NULL); 196 _DIAGASSERT(buf != NULL); 197 198 if (strlcpy(buf, entry, buflen) >= buflen) 199 return 0; 200 flags = _PASSWORD_NOWARN; 201 if (old) 202 flags |= _PASSWORD_OLDFMT; 203 return __pw_scan(buf, pw, &flags); 204 } 205 #endif /* YP || HESIOD */ 206 207 /* 208 * _pw_opendb 209 * if *db is NULL, dbopen(3) /etc/spwd.db or /etc/pwd.db (depending 210 * upon permissions, etc) 211 */ 212 static int 213 _pw_opendb(DB **db) 214 { 215 static int warned; 216 217 const char *dbfile; 218 219 _DIAGASSERT(db != NULL); 220 if (*db != NULL) /* open *db */ 221 return NS_SUCCESS; 222 223 if (geteuid() == 0) { 224 dbfile = _PATH_SMP_DB; 225 *db = dbopen(dbfile, O_RDONLY, 0, DB_HASH, NULL); 226 } 227 if (*db == NULL) { 228 dbfile = _PATH_MP_DB; 229 *db = dbopen(dbfile, O_RDONLY, 0, DB_HASH, NULL); 230 } 231 if (*db == NULL) { 232 if (!warned) { 233 int serrno = errno; 234 syslog(LOG_ERR, "%s: %m", dbfile); 235 errno = serrno; 236 } 237 warned = 1; 238 return NS_UNAVAIL; 239 } 240 return NS_SUCCESS; 241 } 242 243 /* 244 * _pw_getkey 245 * Lookup key in *db, filling in pw 246 * with the result, allocating memory from buffer (size buflen). 247 * (The caller may point key.data to buffer on entry; the contents 248 * of key.data will be invalid on exit.) 249 */ 250 static int 251 _pw_getkey(DB *db, DBT *key, 252 struct passwd *pw, char *buffer, size_t buflen, int *pwflags) 253 { 254 char *p, *t; 255 DBT data; 256 257 _DIAGASSERT(db != NULL); 258 _DIAGASSERT(key != NULL); 259 _DIAGASSERT(pw != NULL); 260 _DIAGASSERT(buffer != NULL); 261 /* pwflags may be NULL (if we don't care about them */ 262 263 if (db == NULL) /* this shouldn't happen */ 264 return NS_UNAVAIL; 265 266 switch ((db->get)(db, key, &data, 0)) { 267 case 0: 268 break; /* found */ 269 case 1: 270 return NS_NOTFOUND; 271 case -1: 272 return NS_UNAVAIL; /* error in db routines */ 273 default: 274 abort(); 275 } 276 277 p = (char *)data.data; 278 if (data.size > buflen) { 279 errno = ERANGE; 280 return NS_UNAVAIL; 281 } 282 283 /* 284 * THE DECODING BELOW MUST MATCH THAT IN pwd_mkdb. 285 */ 286 t = buffer; 287 #define EXPAND(e) e = t; while ((*t++ = *p++)); 288 #define SCALAR(v) memmove(&(v), p, sizeof v); p += sizeof v 289 EXPAND(pw->pw_name); 290 EXPAND(pw->pw_passwd); 291 SCALAR(pw->pw_uid); 292 SCALAR(pw->pw_gid); 293 SCALAR(pw->pw_change); 294 EXPAND(pw->pw_class); 295 EXPAND(pw->pw_gecos); 296 EXPAND(pw->pw_dir); 297 EXPAND(pw->pw_shell); 298 SCALAR(pw->pw_expire); 299 if (pwflags) { 300 /* See if there's any data left. If so, read in flags. */ 301 if (data.size > (size_t) (p - (char *)data.data)) { 302 SCALAR(*pwflags); 303 } else { /* default */ 304 *pwflags = _PASSWORD_NOUID|_PASSWORD_NOGID; 305 } 306 } 307 308 return NS_SUCCESS; 309 } 310 311 /* 312 * _pw_memfrombuf 313 * Obtain want bytes from buffer (of size buflen) and return a pointer 314 * to the available memory after adjusting buffer/buflen. 315 * Returns NULL if there is insufficient space. 316 */ 317 static char * 318 _pw_memfrombuf(size_t want, char **buffer, size_t *buflen) 319 { 320 char *rv; 321 322 if (want > *buflen) { 323 errno = ERANGE; 324 return NULL; 325 } 326 rv = *buffer; 327 *buffer += want; 328 *buflen -= want; 329 return rv; 330 } 331 332 /* 333 * _pw_copy 334 * Copy the contents of frompw to pw; memory for strings 335 * and arrays will be allocated from buf (of size buflen). 336 * If proto != NULL, use various fields in proto in preference to frompw. 337 * Returns 1 if copied successfully, 0 on copy failure. 338 * NOTE: frompw must not use buf for its own pointers. 339 */ 340 static int 341 _pw_copy(const struct passwd *frompw, struct passwd *pw, 342 char *buf, size_t buflen, const struct passwd *protopw, int protoflags) 343 { 344 size_t count; 345 int useproto; 346 347 _DIAGASSERT(frompw != NULL); 348 _DIAGASSERT(pw != NULL); 349 _DIAGASSERT(buf != NULL); 350 /* protopw may be NULL */ 351 352 useproto = protopw && protopw->pw_name; 353 354 #define COPYSTR(to, from) \ 355 do { \ 356 count = strlen((from)); \ 357 (to) = _pw_memfrombuf(count+1, &buf, &buflen); \ 358 if ((to) == NULL) \ 359 return 0; \ 360 memmove((to), (from), count); \ 361 to[count] = '\0'; \ 362 } while (0) /* LINTED */ 363 364 #define COPYFIELD(field) COPYSTR(pw->field, frompw->field) 365 366 #define COPYPROTOFIELD(field) COPYSTR(pw->field, \ 367 (useproto && *protopw->field ? protopw->field : frompw->field)) 368 369 COPYFIELD(pw_name); 370 371 #ifdef PW_OVERRIDE_PASSWD 372 COPYPROTOFIELD(pw_passwd); 373 #else 374 COPYFIELD(pw_passwd); 375 #endif 376 377 if (useproto && !(protoflags & _PASSWORD_NOUID)) 378 pw->pw_uid = protopw->pw_uid; 379 else 380 pw->pw_uid = frompw->pw_uid; 381 382 if (useproto && !(protoflags & _PASSWORD_NOGID)) 383 pw->pw_gid = protopw->pw_gid; 384 else 385 pw->pw_gid = frompw->pw_gid; 386 387 pw->pw_change = frompw->pw_change; 388 COPYFIELD(pw_class); 389 COPYPROTOFIELD(pw_gecos); 390 COPYPROTOFIELD(pw_dir); 391 COPYPROTOFIELD(pw_shell); 392 393 #undef COPYSTR 394 #undef COPYFIELD 395 #undef COPYPROTOFIELD 396 397 return 1; 398 } 399 400 401 /* 402 * files methods 403 */ 404 405 /* state shared between files methods */ 406 struct files_state { 407 int stayopen; /* see getpassent(3) */ 408 DB *db; /* passwd file handle */ 409 int keynum; /* key counter, -1 if no more */ 410 }; 411 412 static struct files_state _files_state; 413 /* storage for non _r functions */ 414 static struct passwd _files_passwd; 415 static char _files_passwdbuf[_GETPW_R_SIZE_MAX]; 416 417 static int 418 _files_start(struct files_state *state) 419 { 420 int rv; 421 422 _DIAGASSERT(state != NULL); 423 424 state->keynum = 0; 425 rv = _pw_opendb(&state->db); 426 if (rv != NS_SUCCESS) 427 return rv; 428 return NS_SUCCESS; 429 } 430 431 static int 432 _files_end(struct files_state *state) 433 { 434 435 _DIAGASSERT(state != NULL); 436 437 state->keynum = 0; 438 if (state->db) { 439 (void)(state->db->close)(state->db); 440 state->db = NULL; 441 } 442 return NS_SUCCESS; 443 } 444 445 /* 446 * _files_pwscan 447 * Search state->db for the next desired entry. 448 * If search is _PW_KEYBYNUM, look for state->keynum. 449 * If search is _PW_KEYBYNAME, look for name. 450 * If search is _PW_KEYBYUID, look for uid. 451 * Sets *retval to the errno if the result is not NS_SUCCESS. 452 */ 453 static int 454 _files_pwscan(int *retval, struct passwd *pw, char *buffer, size_t buflen, 455 struct files_state *state, int search, const char *name, uid_t uid) 456 { 457 const void *from; 458 size_t fromlen; 459 DBT key; 460 int rv; 461 462 _DIAGASSERT(retval != NULL); 463 _DIAGASSERT(pw != NULL); 464 _DIAGASSERT(buffer != NULL); 465 _DIAGASSERT(state != NULL); 466 /* name is NULL to indicate searching for uid */ 467 468 *retval = 0; 469 470 if (state->db == NULL) { /* only start if file not open yet */ 471 rv = _files_start(state); 472 if (rv != NS_SUCCESS) 473 goto filespwscan_out; 474 } 475 476 for (;;) { /* search for a match */ 477 switch (search) { 478 case _PW_KEYBYNUM: 479 if (state->keynum == -1) 480 return NS_NOTFOUND; /* no more records */ 481 state->keynum++; 482 from = &state->keynum; 483 fromlen = sizeof(state->keynum); 484 break; 485 case _PW_KEYBYNAME: 486 from = name; 487 fromlen = strlen(name); 488 break; 489 case _PW_KEYBYUID: 490 from = &uid; 491 fromlen = sizeof(uid); 492 break; 493 default: 494 abort(); 495 } 496 497 if (buflen <= fromlen) { /* buffer too small */ 498 *retval = ERANGE; 499 return NS_UNAVAIL; 500 } 501 buffer[0] = search; /* setup key */ 502 memmove(buffer + 1, from, fromlen); 503 key.size = fromlen + 1; 504 key.data = (u_char *)buffer; 505 506 /* search for key */ 507 rv = _pw_getkey(state->db, &key, pw, buffer, buflen, NULL); 508 if (rv != NS_SUCCESS) /* no match */ 509 break; 510 if (pw->pw_name[0] == '+' || pw->pw_name[0] == '-') { 511 /* if a compat line */ 512 if (search == _PW_KEYBYNUM) 513 continue; /* read next if pwent */ 514 rv = NS_NOTFOUND; /* don't match if pw{nam,uid} */ 515 break; 516 } 517 break; 518 } 519 520 if (rv == NS_NOTFOUND && search == _PW_KEYBYNUM) 521 state->keynum = -1; /* flag `no more records' */ 522 523 if (rv == NS_SUCCESS) { 524 if ((search == _PW_KEYBYUID && pw->pw_uid != uid) || 525 (search == _PW_KEYBYNAME && strcmp(pw->pw_name, name) != 0)) 526 rv = NS_NOTFOUND; 527 } 528 529 filespwscan_out: 530 if (rv != NS_SUCCESS) 531 *retval = errno; 532 return rv; 533 } 534 535 /*ARGSUSED*/ 536 static int 537 _files_setpwent(void *nsrv, void *nscb, va_list ap) 538 { 539 540 _files_state.stayopen = 0; 541 return _files_start(&_files_state); 542 } 543 544 /*ARGSUSED*/ 545 static int 546 _files_setpassent(void *nsrv, void *nscb, va_list ap) 547 { 548 int *retval = va_arg(ap, int *); 549 int stayopen = va_arg(ap, int); 550 551 int rv; 552 553 _files_state.stayopen = stayopen; 554 rv = _files_start(&_files_state); 555 *retval = (rv == NS_SUCCESS); 556 return rv; 557 } 558 559 /*ARGSUSED*/ 560 static int 561 _files_endpwent(void *nsrv, void *nscb, va_list ap) 562 { 563 564 _files_state.stayopen = 0; 565 return _files_end(&_files_state); 566 } 567 568 /*ARGSUSED*/ 569 static int 570 _files_getpwent(void *nsrv, void *nscb, va_list ap) 571 { 572 struct passwd **retval = va_arg(ap, struct passwd **); 573 574 int rv, rerror; 575 576 _DIAGASSERT(retval != NULL); 577 578 *retval = NULL; 579 rv = _files_pwscan(&rerror, &_files_passwd, 580 _files_passwdbuf, sizeof(_files_passwdbuf), 581 &_files_state, _PW_KEYBYNUM, NULL, 0); 582 if (rv == NS_SUCCESS) 583 *retval = &_files_passwd; 584 return rv; 585 } 586 587 /*ARGSUSED*/ 588 static int 589 _files_getpwnam(void *nsrv, void *nscb, va_list ap) 590 { 591 struct passwd **retval = va_arg(ap, struct passwd **); 592 const char *name = va_arg(ap, const char *); 593 594 int rv, rerror; 595 596 _DIAGASSERT(retval != NULL); 597 598 *retval = NULL; 599 rv = _files_start(&_files_state); 600 if (rv != NS_SUCCESS) 601 return rv; 602 rv = _files_pwscan(&rerror, &_files_passwd, 603 _files_passwdbuf, sizeof(_files_passwdbuf), 604 &_files_state, _PW_KEYBYNAME, name, 0); 605 if (!_files_state.stayopen) 606 _files_end(&_files_state); 607 if (rv == NS_SUCCESS) 608 *retval = &_files_passwd; 609 return rv; 610 } 611 612 /*ARGSUSED*/ 613 static int 614 _files_getpwnam_r(void *nsrv, void *nscb, va_list ap) 615 { 616 int *retval = va_arg(ap, int *); 617 const char *name = va_arg(ap, const char *); 618 struct passwd *pw = va_arg(ap, struct passwd *); 619 char *buffer = va_arg(ap, char *); 620 size_t buflen = va_arg(ap, size_t); 621 struct passwd **result = va_arg(ap, struct passwd **); 622 623 struct files_state state; 624 int rv; 625 626 _DIAGASSERT(retval != NULL); 627 _DIAGASSERT(pw != NULL); 628 _DIAGASSERT(buffer != NULL); 629 _DIAGASSERT(result != NULL); 630 631 *result = NULL; 632 memset(&state, 0, sizeof(state)); 633 rv = _files_pwscan(retval, pw, buffer, buflen, &state, 634 _PW_KEYBYNAME, name, 0); 635 _files_end(&state); 636 if (rv == NS_SUCCESS) 637 *result = pw; 638 return rv; 639 } 640 641 /*ARGSUSED*/ 642 static int 643 _files_getpwuid(void *nsrv, void *nscb, va_list ap) 644 { 645 struct passwd **retval = va_arg(ap, struct passwd **); 646 uid_t uid = va_arg(ap, uid_t); 647 648 int rv, rerror; 649 650 _DIAGASSERT(retval != NULL); 651 652 *retval = NULL; 653 rv = _files_start(&_files_state); 654 if (rv != NS_SUCCESS) 655 return rv; 656 rv = _files_pwscan(&rerror, &_files_passwd, 657 _files_passwdbuf, sizeof(_files_passwdbuf), 658 &_files_state, _PW_KEYBYUID, NULL, uid); 659 if (!_files_state.stayopen) 660 _files_end(&_files_state); 661 if (rv == NS_SUCCESS) 662 *retval = &_files_passwd; 663 return rv; 664 } 665 666 /*ARGSUSED*/ 667 static int 668 _files_getpwuid_r(void *nsrv, void *nscb, va_list ap) 669 { 670 int *retval = va_arg(ap, int *); 671 uid_t uid = va_arg(ap, uid_t); 672 struct passwd *pw = va_arg(ap, struct passwd *); 673 char *buffer = va_arg(ap, char *); 674 size_t buflen = va_arg(ap, size_t); 675 struct passwd **result = va_arg(ap, struct passwd **); 676 677 struct files_state state; 678 int rv; 679 680 _DIAGASSERT(retval != NULL); 681 _DIAGASSERT(pw != NULL); 682 _DIAGASSERT(buffer != NULL); 683 _DIAGASSERT(result != NULL); 684 685 *result = NULL; 686 memset(&state, 0, sizeof(state)); 687 rv = _files_pwscan(retval, pw, buffer, buflen, &state, 688 _PW_KEYBYUID, NULL, uid); 689 _files_end(&state); 690 if (rv == NS_SUCCESS) 691 *result = pw; 692 return rv; 693 } 694 695 696 #ifdef HESIOD 697 /* 698 * dns methods 699 */ 700 701 /* state shared between dns methods */ 702 struct dns_state { 703 int stayopen; /* see getpassent(3) */ 704 void *context; /* Hesiod context */ 705 int num; /* passwd index, -1 if no more */ 706 }; 707 708 static struct dns_state _dns_state; 709 /* storage for non _r functions */ 710 static struct passwd _dns_passwd; 711 static char _dns_passwdbuf[_GETPW_R_SIZE_MAX]; 712 713 static int 714 _dns_start(struct dns_state *state) 715 { 716 717 _DIAGASSERT(state != NULL); 718 719 state->num = 0; 720 if (state->context == NULL) { /* setup Hesiod */ 721 if (hesiod_init(&state->context) == -1) 722 return NS_UNAVAIL; 723 } 724 725 return NS_SUCCESS; 726 } 727 728 static int 729 _dns_end(struct dns_state *state) 730 { 731 732 _DIAGASSERT(state != NULL); 733 734 state->num = 0; 735 if (state->context) { 736 hesiod_end(state->context); 737 state->context = NULL; 738 } 739 return NS_SUCCESS; 740 } 741 742 /* 743 * _dns_pwscan 744 * Look for the Hesiod name provided in buffer in the NULL-terminated 745 * list of zones, 746 * and decode into pw/buffer/buflen. 747 */ 748 static int 749 _dns_pwscan(int *retval, struct passwd *pw, char *buffer, size_t buflen, 750 struct dns_state *state, const char **zones) 751 { 752 const char **curzone; 753 char **hp, *ep; 754 int rv; 755 756 _DIAGASSERT(retval != NULL); 757 _DIAGASSERT(pw != NULL); 758 _DIAGASSERT(buffer != NULL); 759 _DIAGASSERT(state != NULL); 760 _DIAGASSERT(zones != NULL); 761 762 *retval = 0; 763 764 if (state->context == NULL) { /* only start if Hesiod not setup */ 765 rv = _dns_start(state); 766 if (rv != NS_SUCCESS) 767 return rv; 768 } 769 770 hp = NULL; 771 rv = NS_NOTFOUND; 772 773 for (curzone = zones; *curzone; curzone++) { /* search zones */ 774 hp = hesiod_resolve(state->context, buffer, *curzone); 775 if (hp != NULL) 776 break; 777 if (errno != ENOENT) { 778 rv = NS_UNAVAIL; 779 goto dnspwscan_out; 780 } 781 } 782 if (*curzone == NULL) 783 goto dnspwscan_out; 784 785 if ((ep = strchr(hp[0], '\n')) != NULL) 786 *ep = '\0'; /* clear trailing \n */ 787 if (_pw_parse(hp[0], pw, buffer, buflen, 1)) /* validate line */ 788 rv = NS_SUCCESS; 789 else 790 rv = NS_UNAVAIL; 791 792 dnspwscan_out: 793 if (rv != NS_SUCCESS) 794 *retval = errno; 795 if (hp) 796 hesiod_free_list(state->context, hp); 797 return rv; 798 } 799 800 /*ARGSUSED*/ 801 static int 802 _dns_setpwent(void *nsrv, void *nscb, va_list ap) 803 { 804 805 _dns_state.stayopen = 0; 806 return _dns_start(&_dns_state); 807 } 808 809 /*ARGSUSED*/ 810 static int 811 _dns_setpassent(void *nsrv, void *nscb, va_list ap) 812 { 813 int *retval = va_arg(ap, int *); 814 int stayopen = va_arg(ap, int); 815 816 int rv; 817 818 _dns_state.stayopen = stayopen; 819 rv = _dns_start(&_dns_state); 820 *retval = (rv == NS_SUCCESS); 821 return rv; 822 } 823 824 /*ARGSUSED*/ 825 static int 826 _dns_endpwent(void *nsrv, void *nscb, va_list ap) 827 { 828 829 _dns_state.stayopen = 0; 830 return _dns_end(&_dns_state); 831 } 832 833 /*ARGSUSED*/ 834 static int 835 _dns_getpwent(void *nsrv, void *nscb, va_list ap) 836 { 837 struct passwd **retval = va_arg(ap, struct passwd **); 838 839 char **hp, *ep; 840 int rv; 841 842 _DIAGASSERT(retval != NULL); 843 844 *retval = NULL; 845 846 if (_dns_state.num == -1) /* exhausted search */ 847 return NS_NOTFOUND; 848 849 if (_dns_state.context == NULL) { 850 /* only start if Hesiod not setup */ 851 rv = _dns_start(&_dns_state); 852 if (rv != NS_SUCCESS) 853 return rv; 854 } 855 856 hp = NULL; 857 rv = NS_NOTFOUND; 858 859 /* find passwd-NNN */ 860 snprintf(_dns_passwdbuf, sizeof(_dns_passwdbuf), 861 "passwd-%u", _dns_state.num); 862 _dns_state.num++; 863 864 hp = hesiod_resolve(_dns_state.context, _dns_passwdbuf, "passwd"); 865 if (hp == NULL) { 866 if (errno == ENOENT) 867 _dns_state.num = -1; 868 else 869 rv = NS_UNAVAIL; 870 } else { 871 if ((ep = strchr(hp[0], '\n')) != NULL) 872 *ep = '\0'; /* clear trailing \n */ 873 /* validate line */ 874 if (_pw_parse(hp[0], &_dns_passwd, 875 _dns_passwdbuf, sizeof(_dns_passwdbuf), 1)) 876 rv = NS_SUCCESS; 877 else 878 rv = NS_UNAVAIL; 879 } 880 881 if (hp) 882 hesiod_free_list(_dns_state.context, hp); 883 if (rv == NS_SUCCESS) 884 *retval = &_dns_passwd; 885 return rv; 886 } 887 888 static const char *_dns_uid_zones[] = { 889 "uid", 890 "passwd", 891 NULL 892 }; 893 894 /*ARGSUSED*/ 895 static int 896 _dns_getpwuid(void *nsrv, void *nscb, va_list ap) 897 { 898 struct passwd **retval = va_arg(ap, struct passwd **); 899 uid_t uid = va_arg(ap, uid_t); 900 901 int rv, rerror; 902 903 _DIAGASSERT(retval != NULL); 904 905 *retval = NULL; 906 rv = _dns_start(&_dns_state); 907 if (rv != NS_SUCCESS) 908 return rv; 909 snprintf(_dns_passwdbuf, sizeof(_dns_passwdbuf), 910 "%u", (unsigned int)uid); 911 rv = _dns_pwscan(&rerror, &_dns_passwd, 912 _dns_passwdbuf, sizeof(_dns_passwdbuf), 913 &_dns_state, _dns_uid_zones); 914 if (!_dns_state.stayopen) 915 _dns_end(&_dns_state); 916 if (rv == NS_SUCCESS && uid == _dns_passwd.pw_uid) 917 *retval = &_dns_passwd; 918 return rv; 919 } 920 921 /*ARGSUSED*/ 922 static int 923 _dns_getpwuid_r(void *nsrv, void *nscb, va_list ap) 924 { 925 int *retval = va_arg(ap, int *); 926 uid_t uid = va_arg(ap, uid_t); 927 struct passwd *pw = va_arg(ap, struct passwd *); 928 char *buffer = va_arg(ap, char *); 929 size_t buflen = va_arg(ap, size_t); 930 struct passwd **result = va_arg(ap, struct passwd **); 931 932 struct dns_state state; 933 int rv; 934 935 _DIAGASSERT(retval != NULL); 936 _DIAGASSERT(pw != NULL); 937 _DIAGASSERT(buffer != NULL); 938 _DIAGASSERT(result != NULL); 939 940 *result = NULL; 941 memset(&state, 0, sizeof(state)); 942 snprintf(buffer, buflen, "%u", (unsigned int)uid); 943 rv = _dns_pwscan(retval, pw, buffer, buflen, &state, _dns_uid_zones); 944 _dns_end(&state); 945 if (rv != NS_SUCCESS) 946 return rv; 947 if (uid == pw->pw_uid) { 948 *result = pw; 949 return NS_SUCCESS; 950 } else 951 return NS_NOTFOUND; 952 } 953 954 static const char *_dns_nam_zones[] = { 955 "passwd", 956 NULL 957 }; 958 959 /*ARGSUSED*/ 960 static int 961 _dns_getpwnam(void *nsrv, void *nscb, va_list ap) 962 { 963 struct passwd **retval = va_arg(ap, struct passwd **); 964 const char *name = va_arg(ap, const char *); 965 966 int rv, rerror; 967 968 _DIAGASSERT(retval != NULL); 969 970 *retval = NULL; 971 rv = _dns_start(&_dns_state); 972 if (rv != NS_SUCCESS) 973 return rv; 974 snprintf(_dns_passwdbuf, sizeof(_dns_passwdbuf), "%s", name); 975 rv = _dns_pwscan(&rerror, &_dns_passwd, 976 _dns_passwdbuf, sizeof(_dns_passwdbuf), 977 &_dns_state, _dns_nam_zones); 978 if (!_dns_state.stayopen) 979 _dns_end(&_dns_state); 980 if (rv == NS_SUCCESS && strcmp(name, _dns_passwd.pw_name) == 0) 981 *retval = &_dns_passwd; 982 return rv; 983 } 984 985 /*ARGSUSED*/ 986 static int 987 _dns_getpwnam_r(void *nsrv, void *nscb, va_list ap) 988 { 989 int *retval = va_arg(ap, int *); 990 const char *name = va_arg(ap, const char *); 991 struct passwd *pw = va_arg(ap, struct passwd *); 992 char *buffer = va_arg(ap, char *); 993 size_t buflen = va_arg(ap, size_t); 994 struct passwd **result = va_arg(ap, struct passwd **); 995 996 struct dns_state state; 997 int rv; 998 999 _DIAGASSERT(retval != NULL); 1000 _DIAGASSERT(pw != NULL); 1001 _DIAGASSERT(buffer != NULL); 1002 _DIAGASSERT(result != NULL); 1003 1004 *result = NULL; 1005 memset(&state, 0, sizeof(state)); 1006 snprintf(buffer, buflen, "%s", name); 1007 rv = _dns_pwscan(retval, pw, buffer, buflen, &state, _dns_nam_zones); 1008 _dns_end(&state); 1009 if (rv != NS_SUCCESS) 1010 return rv; 1011 if (strcmp(name, pw->pw_name) == 0) { 1012 *result = pw; 1013 return NS_SUCCESS; 1014 } else 1015 return NS_NOTFOUND; 1016 } 1017 1018 #endif /* HESIOD */ 1019 1020 1021 #ifdef YP 1022 /* 1023 * nis methods 1024 */ 1025 /* state shared between nis methods */ 1026 struct nis_state { 1027 int stayopen; /* see getpassent(3) */ 1028 char *domain; /* NIS domain */ 1029 int done; /* non-zero if search exhausted */ 1030 char *current; /* current first/next match */ 1031 int currentlen; /* length of _nis_current */ 1032 enum { /* shadow map type */ 1033 NISMAP_UNKNOWN, /* unknown ... */ 1034 NISMAP_NONE, /* none: use "passwd.by*" */ 1035 NISMAP_ADJUNCT, /* pw_passwd from "passwd.adjunct.*" */ 1036 NISMAP_MASTER /* all from "master.passwd.by*" */ 1037 } maptype; 1038 }; 1039 1040 static struct nis_state _nis_state; 1041 /* storage for non _r functions */ 1042 static struct passwd _nis_passwd; 1043 static char _nis_passwdbuf[_GETPW_R_SIZE_MAX]; 1044 1045 /* macros for deciding which NIS maps to use. */ 1046 #define PASSWD_BYNAME(x) ((x)->maptype == NISMAP_MASTER \ 1047 ? "master.passwd.byname" : "passwd.byname") 1048 #define PASSWD_BYUID(x) ((x)->maptype == NISMAP_MASTER \ 1049 ? "master.passwd.byuid" : "passwd.byuid") 1050 1051 static int 1052 _nis_start(struct nis_state *state) 1053 { 1054 1055 _DIAGASSERT(state != NULL); 1056 1057 state->done = 0; 1058 if (state->current) { 1059 free(state->current); 1060 state->current = NULL; 1061 } 1062 if (state->domain == NULL) { /* setup NIS */ 1063 switch (yp_get_default_domain(&state->domain)) { 1064 case 0: 1065 break; 1066 case YPERR_RESRC: 1067 return NS_TRYAGAIN; 1068 default: 1069 return NS_UNAVAIL; 1070 } 1071 } 1072 1073 /* determine where to get pw_passwd from */ 1074 if (state->maptype == NISMAP_UNKNOWN) { 1075 int r, order; 1076 1077 state->maptype = NISMAP_NONE; /* default to no adjunct */ 1078 if (geteuid() != 0) /* non-root can't use adjunct */ 1079 return NS_SUCCESS; 1080 1081 /* look for "master.passwd.*" */ 1082 r = yp_order(state->domain, "master.passwd.byname", &order); 1083 if (r == 0) { 1084 state->maptype = NISMAP_MASTER; 1085 return NS_SUCCESS; 1086 } 1087 1088 /* master.passwd doesn't exist, try passwd.adjunct */ 1089 if (r == YPERR_MAP) { 1090 r = yp_order(state->domain, "passwd.adjunct.byname", 1091 &order); 1092 if (r == 0) 1093 state->maptype = NISMAP_ADJUNCT; 1094 } 1095 } 1096 return NS_SUCCESS; 1097 } 1098 1099 static int 1100 _nis_end(struct nis_state *state) 1101 { 1102 1103 _DIAGASSERT(state != NULL); 1104 1105 if (state->domain) 1106 state->domain = NULL; 1107 state->done = 0; 1108 if (state->current) 1109 free(state->current); 1110 state->current = NULL; 1111 state->maptype = NISMAP_UNKNOWN; 1112 return NS_SUCCESS; 1113 } 1114 1115 /* 1116 * nis_parse 1117 * wrapper to _pw_parse that obtains the real password from the 1118 * "passwd.adjunct.byname" NIS map if the maptype is NISMAP_ADJUNCT. 1119 */ 1120 static int 1121 _nis_parse(const char *entry, struct passwd *pw, char *buf, size_t buflen, 1122 struct nis_state *state) 1123 { 1124 size_t elen; 1125 1126 _DIAGASSERT(entry != NULL); 1127 _DIAGASSERT(pw != NULL); 1128 _DIAGASSERT(buf != NULL); 1129 _DIAGASSERT(state != NULL); 1130 1131 elen = strlen(entry); 1132 if (elen >= buflen) 1133 return 0; 1134 if (! _pw_parse(entry, pw, buf, buflen, 1135 !(state->maptype == NISMAP_MASTER))) 1136 return 0; 1137 1138 if ((state->maptype == NISMAP_ADJUNCT) && 1139 (strstr(pw->pw_passwd, "##") != NULL)) { 1140 char *data; 1141 int datalen; 1142 1143 if (yp_match(state->domain, "passwd.adjunct.byname", 1144 pw->pw_name, (int)strlen(pw->pw_name), 1145 &data, &datalen) == 0) { 1146 char *bp, *ep; 1147 /* skip name to get password */ 1148 ep = data; 1149 if ((bp = strsep(&ep, ":")) != NULL && 1150 (bp = strsep(&ep, ":")) != NULL) { 1151 /* store new pw_passwd after entry */ 1152 strlcpy(buf + elen, bp, buflen - elen); 1153 pw->pw_passwd = &buf[elen]; 1154 } 1155 free(data); 1156 } 1157 } 1158 1159 return 1; 1160 } 1161 1162 1163 /* 1164 * _nis_pwscan 1165 * Look for the yp key provided in buffer from map, 1166 * and decode into pw/buffer/buflen. 1167 */ 1168 static int 1169 _nis_pwscan(int *retval, struct passwd *pw, char *buffer, size_t buflen, 1170 struct nis_state *state, const char *map) 1171 { 1172 char *data; 1173 int nisr, rv, datalen; 1174 1175 _DIAGASSERT(retval != NULL); 1176 _DIAGASSERT(pw != NULL); 1177 _DIAGASSERT(buffer != NULL); 1178 _DIAGASSERT(state != NULL); 1179 _DIAGASSERT(map != NULL); 1180 1181 *retval = 0; 1182 1183 if (state->domain == NULL) { /* only start if NIS not setup */ 1184 rv = _nis_start(state); 1185 if (rv != NS_SUCCESS) 1186 return rv; 1187 } 1188 1189 data = NULL; 1190 rv = NS_NOTFOUND; 1191 1192 /* search map */ 1193 nisr = yp_match(state->domain, map, buffer, (int)strlen(buffer), 1194 &data, &datalen); 1195 switch (nisr) { 1196 case 0: 1197 data[datalen] = '\0'; /* clear trailing \n */ 1198 if (_nis_parse(data, pw, buffer, buflen, state)) 1199 rv = NS_SUCCESS; /* validate line */ 1200 else 1201 rv = NS_UNAVAIL; 1202 break; 1203 case YPERR_KEY: 1204 break; 1205 default: 1206 rv = NS_UNAVAIL; 1207 break; 1208 } 1209 1210 if (rv != NS_SUCCESS) 1211 *retval = errno; 1212 if (data) 1213 free(data); 1214 return rv; 1215 } 1216 1217 /*ARGSUSED*/ 1218 static int 1219 _nis_setpwent(void *nsrv, void *nscb, va_list ap) 1220 { 1221 1222 _nis_state.stayopen = 0; 1223 return _nis_start(&_nis_state); 1224 } 1225 1226 /*ARGSUSED*/ 1227 static int 1228 _nis_setpassent(void *nsrv, void *nscb, va_list ap) 1229 { 1230 int *retval = va_arg(ap, int *); 1231 int stayopen = va_arg(ap, int); 1232 1233 int rv; 1234 1235 _nis_state.stayopen = stayopen; 1236 rv = _nis_start(&_nis_state); 1237 *retval = (rv == NS_SUCCESS); 1238 return rv; 1239 } 1240 1241 /*ARGSUSED*/ 1242 static int 1243 _nis_endpwent(void *nsrv, void *nscb, va_list ap) 1244 { 1245 1246 return _nis_end(&_nis_state); 1247 } 1248 1249 1250 /*ARGSUSED*/ 1251 static int 1252 _nis_getpwent(void *nsrv, void *nscb, va_list ap) 1253 { 1254 struct passwd **retval = va_arg(ap, struct passwd **); 1255 1256 char *key, *data; 1257 int keylen, datalen, rv, nisr; 1258 1259 _DIAGASSERT(retval != NULL); 1260 1261 *retval = NULL; 1262 1263 if (_nis_state.done) /* exhausted search */ 1264 return NS_NOTFOUND; 1265 if (_nis_state.domain == NULL) { 1266 /* only start if NIS not setup */ 1267 rv = _nis_start(&_nis_state); 1268 if (rv != NS_SUCCESS) 1269 return rv; 1270 } 1271 1272 key = NULL; 1273 data = NULL; 1274 rv = NS_NOTFOUND; 1275 1276 if (_nis_state.current) { /* already searching */ 1277 nisr = yp_next(_nis_state.domain, PASSWD_BYNAME(&_nis_state), 1278 _nis_state.current, _nis_state.currentlen, 1279 &key, &keylen, &data, &datalen); 1280 free(_nis_state.current); 1281 _nis_state.current = NULL; 1282 switch (nisr) { 1283 case 0: 1284 _nis_state.current = key; 1285 _nis_state.currentlen = keylen; 1286 key = NULL; 1287 break; 1288 case YPERR_NOMORE: 1289 _nis_state.done = 1; 1290 goto nisent_out; 1291 default: 1292 rv = NS_UNAVAIL; 1293 goto nisent_out; 1294 } 1295 } else { /* new search */ 1296 if (yp_first(_nis_state.domain, PASSWD_BYNAME(&_nis_state), 1297 &_nis_state.current, &_nis_state.currentlen, 1298 &data, &datalen)) { 1299 rv = NS_UNAVAIL; 1300 goto nisent_out; 1301 } 1302 } 1303 1304 data[datalen] = '\0'; /* clear trailing \n */ 1305 /* validate line */ 1306 if (_nis_parse(data, &_nis_passwd, 1307 _nis_passwdbuf, sizeof(_nis_passwdbuf), &_nis_state)) 1308 rv = NS_SUCCESS; 1309 else 1310 rv = NS_UNAVAIL; 1311 1312 nisent_out: 1313 if (key) 1314 free(key); 1315 if (data) 1316 free(data); 1317 if (rv == NS_SUCCESS) 1318 *retval = &_nis_passwd; 1319 return rv; 1320 } 1321 1322 /*ARGSUSED*/ 1323 static int 1324 _nis_getpwuid(void *nsrv, void *nscb, va_list ap) 1325 { 1326 struct passwd **retval = va_arg(ap, struct passwd **); 1327 uid_t uid = va_arg(ap, uid_t); 1328 1329 int rv, rerror; 1330 1331 _DIAGASSERT(retval != NULL); 1332 1333 *retval = NULL; 1334 rv = _nis_start(&_nis_state); 1335 if (rv != NS_SUCCESS) 1336 return rv; 1337 snprintf(_nis_passwdbuf, sizeof(_nis_passwdbuf), "%u", (unsigned int)uid); 1338 rv = _nis_pwscan(&rerror, &_nis_passwd, 1339 _nis_passwdbuf, sizeof(_nis_passwdbuf), 1340 &_nis_state, PASSWD_BYUID(&_nis_state)); 1341 if (!_nis_state.stayopen) 1342 _nis_end(&_nis_state); 1343 if (rv == NS_SUCCESS && uid == _nis_passwd.pw_uid) 1344 *retval = &_nis_passwd; 1345 return rv; 1346 } 1347 1348 /*ARGSUSED*/ 1349 static int 1350 _nis_getpwuid_r(void *nsrv, void *nscb, va_list ap) 1351 { 1352 int *retval = va_arg(ap, int *); 1353 uid_t uid = va_arg(ap, uid_t); 1354 struct passwd *pw = va_arg(ap, struct passwd *); 1355 char *buffer = va_arg(ap, char *); 1356 size_t buflen = va_arg(ap, size_t); 1357 struct passwd **result = va_arg(ap, struct passwd **); 1358 1359 struct nis_state state; 1360 int rv; 1361 1362 _DIAGASSERT(retval != NULL); 1363 _DIAGASSERT(pw != NULL); 1364 _DIAGASSERT(buffer != NULL); 1365 _DIAGASSERT(result != NULL); 1366 1367 *result = NULL; 1368 memset(&state, 0, sizeof(state)); 1369 rv = _nis_start(&state); 1370 if (rv != NS_SUCCESS) 1371 return rv; 1372 snprintf(buffer, buflen, "%u", (unsigned int)uid); 1373 rv = _nis_pwscan(retval, pw, buffer, buflen, 1374 &state, PASSWD_BYUID(&state)); 1375 _nis_end(&state); 1376 if (rv != NS_SUCCESS) 1377 return rv; 1378 if (uid == pw->pw_uid) { 1379 *result = pw; 1380 return NS_SUCCESS; 1381 } else 1382 return NS_NOTFOUND; 1383 } 1384 1385 /*ARGSUSED*/ 1386 static int 1387 _nis_getpwnam(void *nsrv, void *nscb, va_list ap) 1388 { 1389 struct passwd **retval = va_arg(ap, struct passwd **); 1390 const char *name = va_arg(ap, const char *); 1391 1392 int rv, rerror; 1393 1394 _DIAGASSERT(retval != NULL); 1395 1396 *retval = NULL; 1397 rv = _nis_start(&_nis_state); 1398 if (rv != NS_SUCCESS) 1399 return rv; 1400 snprintf(_nis_passwdbuf, sizeof(_nis_passwdbuf), "%s", name); 1401 rv = _nis_pwscan(&rerror, &_nis_passwd, 1402 _nis_passwdbuf, sizeof(_nis_passwdbuf), 1403 &_nis_state, PASSWD_BYNAME(&_nis_state)); 1404 if (!_nis_state.stayopen) 1405 _nis_end(&_nis_state); 1406 if (rv == NS_SUCCESS && strcmp(name, _nis_passwd.pw_name) == 0) 1407 *retval = &_nis_passwd; 1408 return rv; 1409 } 1410 1411 /*ARGSUSED*/ 1412 static int 1413 _nis_getpwnam_r(void *nsrv, void *nscb, va_list ap) 1414 { 1415 int *retval = va_arg(ap, int *); 1416 const char *name = va_arg(ap, const char *); 1417 struct passwd *pw = va_arg(ap, struct passwd *); 1418 char *buffer = va_arg(ap, char *); 1419 size_t buflen = va_arg(ap, size_t); 1420 struct passwd **result = va_arg(ap, struct passwd **); 1421 1422 struct nis_state state; 1423 int rv; 1424 1425 _DIAGASSERT(retval != NULL); 1426 _DIAGASSERT(pw != NULL); 1427 _DIAGASSERT(buffer != NULL); 1428 _DIAGASSERT(result != NULL); 1429 1430 *result = NULL; 1431 snprintf(buffer, buflen, "%s", name); 1432 memset(&state, 0, sizeof(state)); 1433 rv = _nis_start(&state); 1434 if (rv != NS_SUCCESS) 1435 return rv; 1436 rv = _nis_pwscan(retval, pw, buffer, buflen, 1437 &state, PASSWD_BYNAME(&state)); 1438 _nis_end(&state); 1439 if (rv != NS_SUCCESS) 1440 return rv; 1441 if (strcmp(name, pw->pw_name) == 0) { 1442 *result = pw; 1443 return NS_SUCCESS; 1444 } else 1445 return NS_NOTFOUND; 1446 } 1447 1448 #endif /* YP */ 1449 1450 1451 #ifdef _PASSWD_COMPAT 1452 /* 1453 * compat methods 1454 */ 1455 1456 /* state shared between compat methods */ 1457 1458 struct compat_state { 1459 int stayopen; /* see getpassent(3) */ 1460 DB *db; /* passwd DB */ 1461 int keynum; /* key counter, -1 if no more */ 1462 enum { /* current compat mode */ 1463 COMPAT_NOTOKEN = 0, /* no compat token present */ 1464 COMPAT_NONE, /* parsing normal pwd.db line */ 1465 COMPAT_FULL, /* parsing `+' entries */ 1466 COMPAT_USER, /* parsing `+name' entries */ 1467 COMPAT_NETGROUP /* parsing `+@netgroup' entries */ 1468 } mode; 1469 char *user; /* COMPAT_USER "+name" */ 1470 DB *exclude; /* compat exclude DB */ 1471 struct passwd proto; /* proto passwd entry */ 1472 char protobuf[_GETPW_R_SIZE_MAX]; 1473 /* buffer for proto ptrs */ 1474 int protoflags; /* proto passwd flags */ 1475 }; 1476 1477 static struct compat_state _compat_state; 1478 /* storage for non _r functions */ 1479 static struct passwd _compat_passwd; 1480 static char _compat_passwdbuf[_GETPW_R_SIZE_MAX]; 1481 1482 static int 1483 _compat_start(struct compat_state *state) 1484 { 1485 int rv; 1486 1487 _DIAGASSERT(state != NULL); 1488 1489 state->keynum = 0; 1490 if (state->db == NULL) { /* not open yet */ 1491 DBT key, data; 1492 DBT pkey, pdata; 1493 char bf[MAXLOGNAME]; 1494 1495 rv = _pw_opendb(&state->db); 1496 if (rv != NS_SUCCESS) 1497 return rv; 1498 1499 state->mode = COMPAT_NOTOKEN; 1500 1501 /* 1502 * Determine if the "compat" token is present in pwd.db; 1503 * either "__YP!" or PW_KEYBYNAME+"+". 1504 * Only works if pwd_mkdb installs the token. 1505 */ 1506 key.data = (u_char *)__UNCONST(__yp_token); 1507 key.size = strlen(__yp_token); 1508 1509 bf[0] = _PW_KEYBYNAME; /* Pre-token database support. */ 1510 bf[1] = '+'; 1511 pkey.data = (u_char *)bf; 1512 pkey.size = 2; 1513 1514 if ((state->db->get)(state->db, &key, &data, 0) == 0 1515 || (state->db->get)(state->db, &pkey, &pdata, 0) == 0) 1516 state->mode = COMPAT_NONE; 1517 } 1518 return NS_SUCCESS; 1519 } 1520 1521 static int 1522 _compat_end(struct compat_state *state) 1523 { 1524 1525 _DIAGASSERT(state != NULL); 1526 1527 state->keynum = 0; 1528 if (state->db) { 1529 (void)(state->db->close)(state->db); 1530 state->db = NULL; 1531 } 1532 state->mode = COMPAT_NOTOKEN; 1533 if (state->user) 1534 free(state->user); 1535 state->user = NULL; 1536 if (state->exclude != NULL) 1537 (void)(state->exclude->close)(state->exclude); 1538 state->exclude = NULL; 1539 state->proto.pw_name = NULL; 1540 state->protoflags = 0; 1541 return NS_SUCCESS; 1542 } 1543 1544 /* 1545 * _compat_add_exclude 1546 * add the name to the exclude list in state->exclude. 1547 */ 1548 static int 1549 _compat_add_exclude(struct compat_state *state, const char *name) 1550 { 1551 DBT key, data; 1552 1553 _DIAGASSERT(state != NULL); 1554 _DIAGASSERT(name != NULL); 1555 1556 /* initialize the exclusion table if needed */ 1557 if (state->exclude == NULL) { 1558 state->exclude = dbopen(NULL, O_RDWR, 600, DB_HASH, NULL); 1559 if (state->exclude == NULL) 1560 return 0; 1561 } 1562 1563 key.size = strlen(name); /* set up the key */ 1564 key.data = (u_char *)__UNCONST(name); 1565 1566 data.data = NULL; /* data is nothing */ 1567 data.size = 0; 1568 1569 /* store it */ 1570 if ((state->exclude->put)(state->exclude, &key, &data, 0) == -1) 1571 return 0; 1572 1573 return 1; 1574 } 1575 1576 /* 1577 * _compat_is_excluded 1578 * test if a name is on the compat mode exclude list 1579 */ 1580 static int 1581 _compat_is_excluded(struct compat_state *state, const char *name) 1582 { 1583 DBT key, data; 1584 1585 _DIAGASSERT(state != NULL); 1586 _DIAGASSERT(name != NULL); 1587 1588 if (state->exclude == NULL) 1589 return 0; /* nothing excluded */ 1590 1591 key.size = strlen(name); /* set up the key */ 1592 key.data = (u_char *)__UNCONST(name); 1593 1594 if ((state->exclude->get)(state->exclude, &key, &data, 0) == 0) 1595 return 1; /* is excluded */ 1596 1597 return 0; 1598 } 1599 1600 1601 /* 1602 * _passwdcompat_bad 1603 * log an error if "files" or "compat" is specified in 1604 * passwd_compat database 1605 */ 1606 /*ARGSUSED*/ 1607 static int 1608 _passwdcompat_bad(void *nsrv, void *nscb, va_list ap) 1609 { 1610 static int warned; 1611 1612 _DIAGASSERT(cb_data != NULL); 1613 1614 if (!warned) { 1615 syslog(LOG_ERR, 1616 "nsswitch.conf passwd_compat database can't use '%s'", 1617 (char *)nscb); 1618 } 1619 warned = 1; 1620 return NS_UNAVAIL; 1621 } 1622 1623 /* 1624 * _passwdcompat_setpassent 1625 * Call setpassent for all passwd_compat sources. 1626 */ 1627 static int 1628 _passwdcompat_setpassent(int stayopen) 1629 { 1630 static const ns_dtab dtab[] = { 1631 NS_FILES_CB(_passwdcompat_bad, "files") 1632 NS_DNS_CB(_dns_setpassent, NULL) 1633 NS_NIS_CB(_nis_setpassent, NULL) 1634 NS_COMPAT_CB(_passwdcompat_bad, "compat") 1635 { 0 } 1636 }; 1637 1638 int rv, result; 1639 1640 rv = nsdispatch(NULL, dtab, NSDB_PASSWD_COMPAT, "setpassent", 1641 defaultnis_forceall, &result, stayopen); 1642 return rv; 1643 } 1644 1645 /* 1646 * _passwdcompat_endpwent 1647 * Call endpwent for all passwd_compat sources. 1648 */ 1649 static int 1650 _passwdcompat_endpwent(void) 1651 { 1652 static const ns_dtab dtab[] = { 1653 NS_FILES_CB(_passwdcompat_bad, "files") 1654 NS_DNS_CB(_dns_endpwent, NULL) 1655 NS_NIS_CB(_nis_endpwent, NULL) 1656 NS_COMPAT_CB(_passwdcompat_bad, "compat") 1657 { 0 } 1658 }; 1659 1660 return nsdispatch(NULL, dtab, NSDB_PASSWD_COMPAT, "endpwent", 1661 defaultnis_forceall); 1662 } 1663 1664 /* 1665 * _passwdcompat_pwscan 1666 * When a name lookup in compat mode is required (e.g., `+name', or a 1667 * name in `+@netgroup'), look it up in the 'passwd_compat' nsswitch 1668 * database. 1669 * Fail if passwd_compat contains files or compat. 1670 */ 1671 static int 1672 _passwdcompat_pwscan(struct passwd *pw, char *buffer, size_t buflen, 1673 int search, const char *name, uid_t uid) 1674 { 1675 static const ns_dtab compatentdtab[] = { 1676 NS_FILES_CB(_passwdcompat_bad, "files") 1677 NS_DNS_CB(_dns_getpwent, NULL) 1678 NS_NIS_CB(_nis_getpwent, NULL) 1679 NS_COMPAT_CB(_passwdcompat_bad, "compat") 1680 { 0 } 1681 }; 1682 static const ns_dtab compatuiddtab[] = { 1683 NS_FILES_CB(_passwdcompat_bad, "files") 1684 NS_DNS_CB(_dns_getpwuid_r, NULL) 1685 NS_NIS_CB(_nis_getpwuid_r, NULL) 1686 NS_COMPAT_CB(_passwdcompat_bad, "compat") 1687 { 0 } 1688 }; 1689 static const ns_dtab compatnamdtab[] = { 1690 NS_FILES_CB(_passwdcompat_bad, "files") 1691 NS_DNS_CB(_dns_getpwnam_r, NULL) 1692 NS_NIS_CB(_nis_getpwnam_r, NULL) 1693 NS_COMPAT_CB(_passwdcompat_bad, "compat") 1694 { 0 } 1695 }; 1696 1697 int rv, crv; 1698 struct passwd *cpw; 1699 1700 switch (search) { 1701 case _PW_KEYBYNUM: 1702 /* XXXREENTRANT: implement & use getpwent_r */ 1703 rv = nsdispatch(NULL, compatentdtab, 1704 NSDB_PASSWD_COMPAT, "getpwent", defaultnis, 1705 &cpw); 1706 if (rv == NS_SUCCESS && 1707 ! _pw_copy(cpw, pw, buffer, buflen, NULL, 0)) { 1708 errno = ERANGE; 1709 rv = NS_UNAVAIL; 1710 } 1711 break; 1712 case _PW_KEYBYNAME: 1713 _DIAGASSERT(name != NULL); 1714 rv = nsdispatch(NULL, compatnamdtab, 1715 NSDB_PASSWD_COMPAT, "getpwnam_r", defaultnis, 1716 &crv, name, pw, buffer, buflen, &cpw); 1717 break; 1718 case _PW_KEYBYUID: 1719 rv = nsdispatch(NULL, compatuiddtab, 1720 NSDB_PASSWD_COMPAT, "getpwuid_r", defaultnis, 1721 &crv, uid, pw, buffer, buflen, &cpw); 1722 break; 1723 default: 1724 abort(); 1725 /*NOTREACHED*/ 1726 } 1727 return rv; 1728 } 1729 1730 /* 1731 * _compat_pwscan 1732 * Search state->db for the next desired entry. 1733 * If search is _PW_KEYBYNUM, look for state->keynum. 1734 * If search is _PW_KEYBYNAME, look for name. 1735 * If search is _PW_KEYBYUID, look for uid. 1736 * Sets *retval to the errno if the result is not NS_SUCCESS. 1737 */ 1738 static int 1739 _compat_pwscan(int *retval, struct passwd *pw, char *buffer, size_t buflen, 1740 struct compat_state *state, int search, const char *name, uid_t uid) 1741 { 1742 DBT key; 1743 int rv, r, pwflags; 1744 const char *user, *host, *dom; 1745 const void *from; 1746 size_t fromlen; 1747 1748 _DIAGASSERT(retval != NULL); 1749 _DIAGASSERT(pw != NULL); 1750 _DIAGASSERT(buffer != NULL); 1751 _DIAGASSERT(state != NULL); 1752 /* name may be NULL */ 1753 1754 *retval = 0; 1755 1756 if (state->db == NULL) { 1757 rv = _compat_start(state); 1758 if (rv != NS_SUCCESS) 1759 return rv; 1760 } 1761 if (buflen <= 1) { /* buffer too small */ 1762 *retval = ERANGE; 1763 return NS_UNAVAIL; 1764 } 1765 1766 for (;;) { /* loop over pwd.db */ 1767 rv = NS_NOTFOUND; 1768 if (state->mode != COMPAT_NOTOKEN && 1769 state->mode != COMPAT_NONE) { 1770 /* doing a compat lookup */ 1771 struct passwd cpw; 1772 char cbuf[_GETPW_R_SIZE_MAX]; 1773 1774 switch (state->mode) { 1775 1776 case COMPAT_FULL: 1777 /* get next user */ 1778 rv = _passwdcompat_pwscan(&cpw, 1779 cbuf, sizeof(cbuf), 1780 _PW_KEYBYNUM, NULL, 0); 1781 if (rv != NS_SUCCESS) 1782 state->mode = COMPAT_NONE; 1783 break; 1784 1785 case COMPAT_NETGROUP: 1786 /* XXXREENTRANT: getnetgrent is not thread safe */ 1787 /* get next user from netgroup */ 1788 r = getnetgrent(&host, &user, &dom); 1789 if (r == 0) { /* end of group */ 1790 endnetgrent(); 1791 state->mode = COMPAT_NONE; 1792 break; 1793 } 1794 if (!user || !*user) 1795 break; 1796 rv = _passwdcompat_pwscan(&cpw, 1797 cbuf, sizeof(cbuf), 1798 _PW_KEYBYNAME, user, 0); 1799 break; 1800 1801 case COMPAT_USER: 1802 /* get specific user */ 1803 if (state->user == NULL) { 1804 state->mode = COMPAT_NONE; 1805 break; 1806 } 1807 rv = _passwdcompat_pwscan(&cpw, 1808 cbuf, sizeof(cbuf), 1809 _PW_KEYBYNAME, state->user, 0); 1810 free(state->user); 1811 state->user = NULL; 1812 state->mode = COMPAT_NONE; 1813 break; 1814 1815 case COMPAT_NOTOKEN: 1816 case COMPAT_NONE: 1817 abort(); 1818 1819 } 1820 if (rv != NS_SUCCESS) /* if not matched, next loop */ 1821 continue; 1822 1823 /* copy cpw to pw, applying prototype */ 1824 if (! _pw_copy(&cpw, pw, buffer, buflen, 1825 &state->proto, state->protoflags)) { 1826 rv = NS_UNAVAIL; 1827 break; 1828 } 1829 1830 if (_compat_is_excluded(state, pw->pw_name)) 1831 continue; /* excluded; next loop */ 1832 1833 if ((search == _PW_KEYBYNAME 1834 && strcmp(pw->pw_name, name) != 0) 1835 || (search == _PW_KEYBYUID && pw->pw_uid != uid)) { 1836 continue; /* not specific; next loop */ 1837 } 1838 1839 break; /* exit loop if found */ 1840 } else { /* not a compat line */ 1841 state->proto.pw_name = NULL; 1842 /* clear prototype */ 1843 } 1844 1845 if (state->mode == COMPAT_NOTOKEN) { 1846 /* no compat token; do direct lookup */ 1847 switch (search) { 1848 case _PW_KEYBYNUM: 1849 if (state->keynum == -1) /* no more records */ 1850 return NS_NOTFOUND; 1851 state->keynum++; 1852 from = &state->keynum; 1853 fromlen = sizeof(state->keynum); 1854 break; 1855 case _PW_KEYBYNAME: 1856 from = name; 1857 fromlen = strlen(name); 1858 break; 1859 case _PW_KEYBYUID: 1860 from = &uid; 1861 fromlen = sizeof(uid); 1862 break; 1863 default: 1864 abort(); 1865 } 1866 buffer[0] = search; 1867 } else { 1868 /* compat token; do line by line */ 1869 if (state->keynum == -1) /* no more records */ 1870 return NS_NOTFOUND; 1871 state->keynum++; 1872 from = &state->keynum; 1873 fromlen = sizeof(state->keynum); 1874 buffer[0] = _PW_KEYBYNUM; 1875 } 1876 1877 if (buflen <= fromlen) { /* buffer too small */ 1878 *retval = ERANGE; 1879 return NS_UNAVAIL; 1880 } 1881 memmove(buffer + 1, from, fromlen); /* setup key */ 1882 key.size = fromlen + 1; 1883 key.data = (u_char *)buffer; 1884 1885 rv = _pw_getkey(state->db, &key, pw, buffer, buflen, &pwflags); 1886 if (rv != NS_SUCCESS) /* stop on error */ 1887 break; 1888 1889 if (state->mode == COMPAT_NOTOKEN) 1890 break; /* stop if no compat token */ 1891 1892 if (pw->pw_name[0] == '+') { 1893 /* compat inclusion */ 1894 switch(pw->pw_name[1]) { 1895 case '\0': /* `+' */ 1896 state->mode = COMPAT_FULL; 1897 /* reset passwd_compat search */ 1898 /* XXXREENTRANT: setpassent is not thread safe ? */ 1899 (void) _passwdcompat_setpassent(0); 1900 break; 1901 case '@': /* `+@netgroup' */ 1902 state->mode = COMPAT_NETGROUP; 1903 /* reset netgroup search */ 1904 /* XXXREENTRANT: setnetgrent is not thread safe */ 1905 setnetgrent(pw->pw_name + 2); 1906 break; 1907 default: /* `+name' */ 1908 state->mode = COMPAT_USER; 1909 if (state->user) 1910 free(state->user); 1911 state->user = strdup(pw->pw_name + 1); 1912 break; 1913 } 1914 /* save the prototype */ 1915 state->protoflags = pwflags; 1916 if (! _pw_copy(pw, &state->proto, state->protobuf, 1917 sizeof(state->protobuf), NULL, 0)) { 1918 rv = NS_UNAVAIL; 1919 break; 1920 } 1921 continue; /* loop again after inclusion */ 1922 } else if (pw->pw_name[0] == '-') { 1923 /* compat exclusion */ 1924 rv = NS_SUCCESS; 1925 switch(pw->pw_name[1]) { 1926 case '\0': /* `-' */ 1927 break; 1928 case '@': /* `-@netgroup' */ 1929 /* XXXREENTRANT: {set,get,end}netgrent is not thread safe */ 1930 setnetgrent(pw->pw_name + 2); 1931 while (getnetgrent(&host, &user, &dom)) { 1932 if (!user || !*user) 1933 continue; 1934 if (! _compat_add_exclude(state,user)) { 1935 rv = NS_UNAVAIL; 1936 break; 1937 } 1938 } 1939 endnetgrent(); 1940 break; 1941 default: /* `-name' */ 1942 if (! _compat_add_exclude(state, 1943 pw->pw_name + 1)) { 1944 rv = NS_UNAVAIL; 1945 } 1946 break; 1947 } 1948 if (rv != NS_SUCCESS) /* exclusion failure */ 1949 break; 1950 continue; /* loop again after exclusion */ 1951 } 1952 if (search == _PW_KEYBYNUM || 1953 (search == _PW_KEYBYUID && pw->pw_uid == uid) || 1954 (search == _PW_KEYBYNAME && strcmp(pw->pw_name, name) == 0)) 1955 break; /* token mode match found */ 1956 } 1957 1958 if (rv == NS_NOTFOUND && 1959 (search == _PW_KEYBYNUM || state->mode != COMPAT_NOTOKEN)) 1960 state->keynum = -1; /* flag `no more records' */ 1961 1962 if (rv == NS_SUCCESS) { 1963 if ((search == _PW_KEYBYNAME && strcmp(pw->pw_name, name) != 0) 1964 || (search == _PW_KEYBYUID && pw->pw_uid != uid)) 1965 rv = NS_NOTFOUND; 1966 } 1967 1968 if (rv != NS_SUCCESS) 1969 *retval = errno; 1970 return rv; 1971 } 1972 1973 /*ARGSUSED*/ 1974 static int 1975 _compat_setpwent(void *nsrv, void *nscb, va_list ap) 1976 { 1977 1978 /* force passwd_compat setpwent() */ 1979 (void) _passwdcompat_setpassent(0); 1980 1981 /* reset state, keep db open */ 1982 _compat_state.stayopen = 0; 1983 return _compat_start(&_compat_state); 1984 } 1985 1986 /*ARGSUSED*/ 1987 static int 1988 _compat_setpassent(void *nsrv, void *nscb, va_list ap) 1989 { 1990 int *retval = va_arg(ap, int *); 1991 int stayopen = va_arg(ap, int); 1992 1993 int rv; 1994 1995 /* force passwd_compat setpassent() */ 1996 (void) _passwdcompat_setpassent(stayopen); 1997 1998 _compat_state.stayopen = stayopen; 1999 rv = _compat_start(&_compat_state); 2000 *retval = (rv == NS_SUCCESS); 2001 return rv; 2002 } 2003 2004 /*ARGSUSED*/ 2005 static int 2006 _compat_endpwent(void *nsrv, void *nscb, va_list ap) 2007 { 2008 2009 /* force passwd_compat endpwent() */ 2010 (void) _passwdcompat_endpwent(); 2011 2012 /* reset state, close db */ 2013 _compat_state.stayopen = 0; 2014 return _compat_end(&_compat_state); 2015 } 2016 2017 2018 /*ARGSUSED*/ 2019 static int 2020 _compat_getpwent(void *nsrv, void *nscb, va_list ap) 2021 { 2022 struct passwd **retval = va_arg(ap, struct passwd **); 2023 2024 int rv, rerror; 2025 2026 _DIAGASSERT(retval != NULL); 2027 2028 *retval = NULL; 2029 rv = _compat_pwscan(&rerror, &_compat_passwd, 2030 _compat_passwdbuf, sizeof(_compat_passwdbuf), 2031 &_compat_state, _PW_KEYBYNUM, NULL, 0); 2032 if (rv == NS_SUCCESS) 2033 *retval = &_compat_passwd; 2034 return rv; 2035 } 2036 2037 /*ARGSUSED*/ 2038 static int 2039 _compat_getpwnam(void *nsrv, void *nscb, va_list ap) 2040 { 2041 struct passwd **retval = va_arg(ap, struct passwd **); 2042 const char *name = va_arg(ap, const char *); 2043 2044 int rv, rerror; 2045 2046 _DIAGASSERT(retval != NULL); 2047 2048 *retval = NULL; 2049 rv = _compat_start(&_compat_state); 2050 if (rv != NS_SUCCESS) 2051 return rv; 2052 rv = _compat_pwscan(&rerror, &_compat_passwd, 2053 _compat_passwdbuf, sizeof(_compat_passwdbuf), 2054 &_compat_state, _PW_KEYBYNAME, name, 0); 2055 if (!_compat_state.stayopen) 2056 _compat_end(&_compat_state); 2057 if (rv == NS_SUCCESS) 2058 *retval = &_compat_passwd; 2059 return rv; 2060 } 2061 2062 /*ARGSUSED*/ 2063 static int 2064 _compat_getpwnam_r(void *nsrv, void *nscb, va_list ap) 2065 { 2066 int *retval = va_arg(ap, int *); 2067 const char *name = va_arg(ap, const char *); 2068 struct passwd *pw = va_arg(ap, struct passwd *); 2069 char *buffer = va_arg(ap, char *); 2070 size_t buflen = va_arg(ap, size_t); 2071 struct passwd **result = va_arg(ap, struct passwd **); 2072 2073 struct compat_state state; 2074 int rv; 2075 2076 _DIAGASSERT(retval != NULL); 2077 _DIAGASSERT(pw != NULL); 2078 _DIAGASSERT(buffer != NULL); 2079 _DIAGASSERT(result != NULL); 2080 2081 *result = NULL; 2082 memset(&state, 0, sizeof(state)); 2083 rv = _compat_pwscan(retval, pw, buffer, buflen, &state, 2084 _PW_KEYBYNAME, name, 0); 2085 _compat_end(&state); 2086 if (rv == NS_SUCCESS) 2087 *result = pw; 2088 return rv; 2089 } 2090 2091 /*ARGSUSED*/ 2092 static int 2093 _compat_getpwuid(void *nsrv, void *nscb, va_list ap) 2094 { 2095 struct passwd **retval = va_arg(ap, struct passwd **); 2096 uid_t uid = va_arg(ap, uid_t); 2097 2098 int rv, rerror; 2099 2100 _DIAGASSERT(retval != NULL); 2101 2102 *retval = NULL; 2103 rv = _compat_start(&_compat_state); 2104 if (rv != NS_SUCCESS) 2105 return rv; 2106 rv = _compat_pwscan(&rerror, &_compat_passwd, 2107 _compat_passwdbuf, sizeof(_compat_passwdbuf), 2108 &_compat_state, _PW_KEYBYUID, NULL, uid); 2109 if (!_compat_state.stayopen) 2110 _compat_end(&_compat_state); 2111 if (rv == NS_SUCCESS) 2112 *retval = &_compat_passwd; 2113 return rv; 2114 } 2115 2116 /*ARGSUSED*/ 2117 static int 2118 _compat_getpwuid_r(void *nsrv, void *nscb, va_list ap) 2119 { 2120 int *retval = va_arg(ap, int *); 2121 uid_t uid = va_arg(ap, uid_t); 2122 struct passwd *pw = va_arg(ap, struct passwd *); 2123 char *buffer = va_arg(ap, char *); 2124 size_t buflen = va_arg(ap, size_t); 2125 struct passwd **result = va_arg(ap, struct passwd **); 2126 2127 struct compat_state state; 2128 int rv; 2129 2130 _DIAGASSERT(retval != NULL); 2131 _DIAGASSERT(pw != NULL); 2132 _DIAGASSERT(buffer != NULL); 2133 _DIAGASSERT(result != NULL); 2134 2135 *result = NULL; 2136 memset(&state, 0, sizeof(state)); 2137 rv = _compat_pwscan(retval, pw, buffer, buflen, &state, 2138 _PW_KEYBYUID, NULL, uid); 2139 _compat_end(&state); 2140 if (rv == NS_SUCCESS) 2141 *result = pw; 2142 return rv; 2143 } 2144 2145 #endif /* _PASSWD_COMPAT */ 2146 2147 2148 /* 2149 * public functions 2150 */ 2151 2152 struct passwd * 2153 getpwent(void) 2154 { 2155 int r; 2156 struct passwd *retval; 2157 2158 static const ns_dtab dtab[] = { 2159 NS_FILES_CB(_files_getpwent, NULL) 2160 NS_DNS_CB(_dns_getpwent, NULL) 2161 NS_NIS_CB(_nis_getpwent, NULL) 2162 NS_COMPAT_CB(_compat_getpwent, NULL) 2163 { 0 } 2164 }; 2165 2166 mutex_lock(&_pwmutex); 2167 r = nsdispatch(NULL, dtab, NSDB_PASSWD, "getpwent", defaultcompat, 2168 &retval); 2169 mutex_unlock(&_pwmutex); 2170 return (r == NS_SUCCESS) ? retval : NULL; 2171 } 2172 2173 struct passwd * 2174 getpwnam(const char *name) 2175 { 2176 int rv; 2177 struct passwd *retval; 2178 2179 static const ns_dtab dtab[] = { 2180 NS_FILES_CB(_files_getpwnam, NULL) 2181 NS_DNS_CB(_dns_getpwnam, NULL) 2182 NS_NIS_CB(_nis_getpwnam, NULL) 2183 NS_COMPAT_CB(_compat_getpwnam, NULL) 2184 { 0 } 2185 }; 2186 2187 mutex_lock(&_pwmutex); 2188 rv = nsdispatch(NULL, dtab, NSDB_PASSWD, "getpwnam", defaultcompat, 2189 &retval, name); 2190 mutex_unlock(&_pwmutex); 2191 return (rv == NS_SUCCESS) ? retval : NULL; 2192 } 2193 2194 int 2195 getpwnam_r(const char *name, struct passwd *pwd, char *buffer, size_t buflen, 2196 struct passwd **result) 2197 { 2198 int r, retval; 2199 2200 static const ns_dtab dtab[] = { 2201 NS_FILES_CB(_files_getpwnam_r, NULL) 2202 NS_DNS_CB(_dns_getpwnam_r, NULL) 2203 NS_NIS_CB(_nis_getpwnam_r, NULL) 2204 NS_COMPAT_CB(_compat_getpwnam_r, NULL) 2205 { 0 } 2206 }; 2207 2208 _DIAGASSERT(name != NULL); 2209 _DIAGASSERT(pwd != NULL); 2210 _DIAGASSERT(buffer != NULL); 2211 _DIAGASSERT(result != NULL); 2212 2213 *result = NULL; 2214 retval = 0; 2215 mutex_lock(&_pwmutex); 2216 r = nsdispatch(NULL, dtab, NSDB_PASSWD, "getpwnam_r", defaultcompat, 2217 &retval, name, pwd, buffer, buflen, result); 2218 mutex_unlock(&_pwmutex); 2219 return (r == NS_SUCCESS) ? 0 : retval ? retval : ENOENT; 2220 } 2221 2222 struct passwd * 2223 getpwuid(uid_t uid) 2224 { 2225 int rv; 2226 struct passwd *retval; 2227 2228 static const ns_dtab dtab[] = { 2229 NS_FILES_CB(_files_getpwuid, NULL) 2230 NS_DNS_CB(_dns_getpwuid, NULL) 2231 NS_NIS_CB(_nis_getpwuid, NULL) 2232 NS_COMPAT_CB(_compat_getpwuid, NULL) 2233 { 0 } 2234 }; 2235 2236 mutex_lock(&_pwmutex); 2237 rv = nsdispatch(NULL, dtab, NSDB_PASSWD, "getpwuid", defaultcompat, 2238 &retval, uid); 2239 mutex_unlock(&_pwmutex); 2240 return (rv == NS_SUCCESS) ? retval : NULL; 2241 } 2242 2243 int 2244 getpwuid_r(uid_t uid, struct passwd *pwd, char *buffer, size_t buflen, 2245 struct passwd **result) 2246 { 2247 int r, retval; 2248 2249 static const ns_dtab dtab[] = { 2250 NS_FILES_CB(_files_getpwuid_r, NULL) 2251 NS_DNS_CB(_dns_getpwuid_r, NULL) 2252 NS_NIS_CB(_nis_getpwuid_r, NULL) 2253 NS_COMPAT_CB(_compat_getpwuid_r, NULL) 2254 { 0 } 2255 }; 2256 2257 _DIAGASSERT(pwd != NULL); 2258 _DIAGASSERT(buffer != NULL); 2259 _DIAGASSERT(result != NULL); 2260 2261 *result = NULL; 2262 retval = 0; 2263 mutex_lock(&_pwmutex); 2264 r = nsdispatch(NULL, dtab, NSDB_PASSWD, "getpwuid_r", defaultcompat, 2265 &retval, uid, pwd, buffer, buflen, result); 2266 mutex_unlock(&_pwmutex); 2267 return (r == NS_SUCCESS) ? 0 : retval ? retval : ENOENT; 2268 } 2269 2270 void 2271 endpwent(void) 2272 { 2273 static const ns_dtab dtab[] = { 2274 NS_FILES_CB(_files_endpwent, NULL) 2275 NS_DNS_CB(_dns_endpwent, NULL) 2276 NS_NIS_CB(_nis_endpwent, NULL) 2277 NS_COMPAT_CB(_compat_endpwent, NULL) 2278 { 0 } 2279 }; 2280 2281 mutex_lock(&_pwmutex); 2282 /* force all endpwent() methods */ 2283 (void) nsdispatch(NULL, dtab, NSDB_PASSWD, "endpwent", 2284 defaultcompat_forceall); 2285 mutex_unlock(&_pwmutex); 2286 } 2287 2288 /*ARGSUSED*/ 2289 int 2290 setpassent(int stayopen) 2291 { 2292 static const ns_dtab dtab[] = { 2293 NS_FILES_CB(_files_setpassent, NULL) 2294 NS_DNS_CB(_dns_setpassent, NULL) 2295 NS_NIS_CB(_nis_setpassent, NULL) 2296 NS_COMPAT_CB(_compat_setpassent, NULL) 2297 { 0 } 2298 }; 2299 int rv, retval; 2300 2301 mutex_lock(&_pwmutex); 2302 /* force all setpassent() methods */ 2303 rv = nsdispatch(NULL, dtab, NSDB_PASSWD, "setpassent", 2304 defaultcompat_forceall, &retval, stayopen); 2305 mutex_unlock(&_pwmutex); 2306 return (rv == NS_SUCCESS) ? retval : 0; 2307 } 2308 2309 void 2310 setpwent(void) 2311 { 2312 static const ns_dtab dtab[] = { 2313 NS_FILES_CB(_files_setpwent, NULL) 2314 NS_DNS_CB(_dns_setpwent, NULL) 2315 NS_NIS_CB(_nis_setpwent, NULL) 2316 NS_COMPAT_CB(_compat_setpwent, NULL) 2317 { 0 } 2318 }; 2319 2320 mutex_lock(&_pwmutex); 2321 /* force all setpwent() methods */ 2322 (void) nsdispatch(NULL, dtab, NSDB_PASSWD, "setpwent", 2323 defaultcompat_forceall); 2324 mutex_unlock(&_pwmutex); 2325 } 2326
Indexes created Tue Sep 23 07:09:52 GMT 2025