getpwent.c revision 1.61
1 /* $NetBSD: getpwent.c,v 1.61 2004/10/24 14:46:23 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.61 2004/10/24 14:46:23 lukem Exp $"); 99 #endif 100 #endif /* LIBC_SCCS and not lint */ 101 102 #include "namespace.h" 103 #include <sys/param.h> 104 105 #include <assert.h> 106 #include <db.h> 107 #include <errno.h> 108 #include <fcntl.h> 109 #include <limits.h> 110 #include <netgroup.h> 111 #include <nsswitch.h> 112 #include <pwd.h> 113 #include <stdarg.h> 114 #include <stdio.h> 115 #include <stdlib.h> 116 #include <string.h> 117 #include <syslog.h> 118 #include <threadlib.h> 119 #include <unistd.h> 120 121 #ifdef HESIOD 122 #include <hesiod.h> 123 #endif 124 125 #ifdef YP 126 #include <machine/param.h> 127 #include <rpc/rpc.h> 128 #include <rpcsvc/yp_prot.h> 129 #include <rpcsvc/ypclnt.h> 130 #endif 131 132 #include "pw_private.h" 133 134 #define _PASSWD_COMPAT /* "passwd" defaults to compat, so always provide it */ 135 136 #define GETPW_R_SIZE_MAX 1024 /* XXXLUKEM: move to {pwd,unistd}.h ? */ 137 138 #ifdef __weak_alias 139 __weak_alias(endpwent,_endpwent) 140 __weak_alias(getpwent,_getpwent) 141 __weak_alias(getpwnam,_getpwnam) 142 __weak_alias(getpwnam_r,_getpwnam_r) 143 __weak_alias(getpwuid,_getpwuid) 144 __weak_alias(getpwuid_r,_getpwuid_r) 145 __weak_alias(setpassent,_setpassent) 146 __weak_alias(setpwent,_setpwent) 147 #endif 148 149 #ifdef _REENTRANT 150 static mutex_t _pwmutex = MUTEX_INITIALIZER; 151 #endif 152 153 const char __yp_token[] = "__YP!"; /* Let pwd_mkdb pull this in. */ 154 155 static const ns_src defaultcompat[] = { 156 { NSSRC_FILES, NS_SUCCESS }, 157 { 0 } 158 }; 159 160 static const ns_src defaultcompat_forceall[] = { 161 { NSSRC_FILES, NS_SUCCESS | NS_FORCEALL }, 162 { 0 } 163 }; 164 165 static const ns_src defaultnis[] = { 166 { NSSRC_NIS, NS_SUCCESS }, 167 { 0 } 168 }; 169 170 static const ns_src defaultnis_forceall[] = { 171 { NSSRC_NIS, NS_SUCCESS | NS_FORCEALL }, 172 { 0 } 173 }; 174 175 176 /* 177 * The pwd.db lookup techniques and data extraction code here must be kept 178 * in sync with that in `pwd_mkdb'. 179 */ 180 181 #if defined(YP) || defined(HESIOD) 182 /* 183 * _pw_parse 184 * Parses entry using pw_scan(3) (without the trailing \n) 185 * after copying to buf, and fills in pw with corresponding values. 186 * If old is non-zero, entry is in _PASSWORD_OLDFMT. 187 * Returns 1 if parsed successfully, 0 on parse failure. 188 */ 189 static int 190 _pw_parse(const char *entry, struct passwd *pw, char *buf, size_t buflen, 191 int old) 192 { 193 int flags; 194 195 _DIAGASSERT(entry != NULL); 196 _DIAGASSERT(pw != NULL); 197 _DIAGASSERT(buf != NULL); 198 199 if (strlcpy(buf, entry, buflen) >= buflen) 200 return 0; 201 flags = _PASSWORD_NOWARN; 202 if (old) 203 flags |= _PASSWORD_OLDFMT; 204 return __pw_scan(buf, pw, &flags); 205 } 206 #endif /* YP || HESIOD */ 207 208 /* 209 * _pw_opendb 210 * if *db is NULL, dbopen(3) /etc/spwd.db or /etc/pwd.db (depending 211 * upon permissions, etc) 212 */ 213 static int 214 _pw_opendb(DB **db) 215 { 216 static int warned; 217 218 const char *dbfile; 219 220 _DIAGASSERT(db != NULL); 221 if (*db != NULL) /* open *db */ 222 return NS_SUCCESS; 223 224 if (geteuid() == 0) { 225 dbfile = _PATH_SMP_DB; 226 *db = dbopen(dbfile, O_RDONLY, 0, DB_HASH, NULL); 227 } 228 if (*db == NULL) { 229 dbfile = _PATH_MP_DB; 230 *db = dbopen(dbfile, O_RDONLY, 0, DB_HASH, NULL); 231 } 232 if (*db == NULL) { 233 if (!warned) { 234 int serrno = errno; 235 syslog(LOG_ERR, "%s: %m", dbfile); 236 errno = serrno; 237 } 238 warned = 1; 239 return NS_UNAVAIL; 240 } 241 return NS_SUCCESS; 242 } 243 244 /* 245 * _pw_getkey 246 * Lookup key in *db, filling in pw 247 * with the result, allocating memory from buffer (size buflen). 248 * (The caller may point key.data to buffer on entry; the contents 249 * of key.data will be invalid on exit.) 250 */ 251 static int 252 _pw_getkey(DB *db, DBT *key, 253 struct passwd *pw, char *buffer, size_t buflen, int *pwflags) 254 { 255 char *p, *t; 256 DBT data; 257 258 _DIAGASSERT(db != NULL); 259 _DIAGASSERT(key != NULL); 260 _DIAGASSERT(pw != NULL); 261 _DIAGASSERT(buffer != NULL); 262 /* pwflags may be NULL (if we don't care about them */ 263 264 if (db == NULL) /* this shouldn't happen */ 265 return NS_UNAVAIL; 266 267 switch ((db->get)(db, key, &data, 0)) { 268 case 0: 269 break; /* found */ 270 case 1: 271 return NS_NOTFOUND; 272 case -1: 273 return NS_UNAVAIL; /* error in db routines */ 274 default: 275 abort(); 276 } 277 278 p = (char *)data.data; 279 if (data.size > buflen) { 280 errno = ERANGE; 281 return NS_UNAVAIL; 282 } 283 284 /* 285 * THE DECODING BELOW MUST MATCH THAT IN pwd_mkdb. 286 */ 287 t = buffer; 288 #define EXPAND(e) e = t; while ((*t++ = *p++)); 289 #define SCALAR(v) memmove(&(v), p, sizeof v); p += sizeof v 290 EXPAND(pw->pw_name); 291 EXPAND(pw->pw_passwd); 292 SCALAR(pw->pw_uid); 293 SCALAR(pw->pw_gid); 294 SCALAR(pw->pw_change); 295 EXPAND(pw->pw_class); 296 EXPAND(pw->pw_gecos); 297 EXPAND(pw->pw_dir); 298 EXPAND(pw->pw_shell); 299 SCALAR(pw->pw_expire); 300 if (pwflags) { 301 /* See if there's any data left. If so, read in flags. */ 302 if (data.size > (size_t) (p - (char *)data.data)) { 303 SCALAR(*pwflags); 304 } else { /* default */ 305 *pwflags = _PASSWORD_NOUID|_PASSWORD_NOGID; 306 } 307 } 308 309 return NS_SUCCESS; 310 } 311 312 /* 313 * _pw_memfrombuf 314 * Obtain want bytes from buffer (of size buflen) and return a pointer 315 * to the available memory after adjusting buffer/buflen. 316 * Returns NULL if there is insufficient space. 317 */ 318 static char * 319 _pw_memfrombuf(size_t want, char **buffer, size_t *buflen) 320 { 321 char *rv; 322 323 if (want > *buflen) { 324 errno = ERANGE; 325 return NULL; 326 } 327 rv = *buffer; 328 *buffer += want; 329 *buflen -= want; 330 return rv; 331 } 332 333 /* 334 * _pw_copy 335 * Copy the contents of frompw to pw; memory for strings 336 * and arrays will be allocated from buf (of size buflen). 337 * If proto != NULL, use various fields in proto in preference to frompw. 338 * Returns 1 if copied successfully, 0 on copy failure. 339 * NOTE: frompw must not use buf for its own pointers. 340 */ 341 static int 342 _pw_copy(const struct passwd *frompw, struct passwd *pw, 343 char *buf, size_t buflen, const struct passwd *protopw, int protoflags) 344 { 345 size_t count; 346 int useproto; 347 348 _DIAGASSERT(frompw != NULL); 349 _DIAGASSERT(pw != NULL); 350 _DIAGASSERT(buf != NULL); 351 /* protopw may be NULL */ 352 353 useproto = protopw && protopw->pw_name; 354 355 #define COPYSTR(to, from) \ 356 do { \ 357 count = strlen((from)); \ 358 (to) = _pw_memfrombuf(count+1, &buf, &buflen); \ 359 if ((to) == NULL) \ 360 return 0; \ 361 memmove((to), (from), count); \ 362 to[count] = '\0'; \ 363 } while (0) /* LINTED */ 364 365 #define COPYFIELD(field) COPYSTR(pw->field, frompw->field) 366 367 #define COPYPROTOFIELD(field) COPYSTR(pw->field, \ 368 (useproto && *protopw->field ? protopw->field : frompw->field)) 369 370 COPYFIELD(pw_name); 371 372 #ifdef PW_OVERRIDE_PASSWD 373 COPYPROTOFIELD(pw_passwd); 374 #else 375 COPYFIELD(pw_passwd); 376 #endif 377 378 if (useproto && !(protoflags & _PASSWORD_NOUID)) 379 pw->pw_uid = protopw->pw_uid; 380 else 381 pw->pw_uid = frompw->pw_uid; 382 383 if (useproto && !(protoflags & _PASSWORD_NOGID)) 384 pw->pw_gid = protopw->pw_gid; 385 else 386 pw->pw_gid = frompw->pw_gid; 387 388 pw->pw_change = frompw->pw_change; 389 COPYFIELD(pw_class); 390 COPYPROTOFIELD(pw_gecos); 391 COPYPROTOFIELD(pw_dir); 392 COPYPROTOFIELD(pw_shell); 393 394 #undef COPYSTR 395 #undef COPYFIELD 396 #undef COPYPROTOFIELD 397 398 return 1; 399 } 400 401 402 /* 403 * files methods 404 */ 405 406 /* state shared between files methods */ 407 struct files_state { 408 int stayopen; /* see getpassent(3) */ 409 DB *db; /* passwd file handle */ 410 int keynum; /* key counter, -1 if no more */ 411 }; 412 413 static struct files_state _files_state; 414 /* storage for non _r functions */ 415 static struct passwd _files_passwd; 416 static char _files_passwdbuf[GETPW_R_SIZE_MAX]; 417 418 static int 419 _files_start(struct files_state *state) 420 { 421 int rv; 422 423 _DIAGASSERT(state != NULL); 424 425 state->keynum = 0; 426 rv = _pw_opendb(&state->db); 427 if (rv != NS_SUCCESS) 428 return rv; 429 return NS_SUCCESS; 430 } 431 432 static int 433 _files_end(struct files_state *state) 434 { 435 436 _DIAGASSERT(state != NULL); 437 438 state->keynum = 0; 439 if (state->db) { 440 (void)(state->db->close)(state->db); 441 state->db = NULL; 442 } 443 return NS_SUCCESS; 444 } 445 446 /* 447 * _files_pwscan 448 * Search state->db for the next desired entry. 449 * If search is _PW_KEYBYNUM, look for state->keynum. 450 * If search is _PW_KEYBYNAME, look for name. 451 * If search is _PW_KEYBYUID, look for uid. 452 * Sets *retval to the errno if the result is not NS_SUCCESS. 453 */ 454 static int 455 _files_pwscan(int *retval, struct passwd *pw, char *buffer, size_t buflen, 456 struct files_state *state, int search, const char *name, uid_t uid) 457 { 458 const void *from; 459 size_t fromlen; 460 DBT key; 461 int rv; 462 463 _DIAGASSERT(retval != NULL); 464 _DIAGASSERT(pw != NULL); 465 _DIAGASSERT(buffer != NULL); 466 _DIAGASSERT(state != NULL); 467 /* name is NULL to indicate searching for uid */ 468 469 *retval = 0; 470 471 if (state->db == NULL) { /* only start if file not open yet */ 472 rv = _files_start(state); 473 if (rv != NS_SUCCESS) 474 goto filespwscan_out; 475 } 476 477 for (;;) { /* search for a match */ 478 switch (search) { 479 case _PW_KEYBYNUM: 480 if (state->keynum == -1) 481 return NS_NOTFOUND; /* no more records */ 482 state->keynum++; 483 from = &state->keynum; 484 fromlen = sizeof(state->keynum); 485 break; 486 case _PW_KEYBYNAME: 487 from = name; 488 fromlen = strlen(name); 489 break; 490 case _PW_KEYBYUID: 491 from = &uid; 492 fromlen = sizeof(uid); 493 break; 494 default: 495 abort(); 496 } 497 498 if (buflen <= fromlen) { /* buffer too small */ 499 *retval = ERANGE; 500 return NS_UNAVAIL; 501 } 502 buffer[0] = search; /* setup key */ 503 memmove(buffer + 1, from, fromlen); 504 key.size = fromlen + 1; 505 key.data = (u_char *)buffer; 506 507 /* search for key */ 508 rv = _pw_getkey(state->db, &key, pw, buffer, buflen, NULL); 509 if (rv != NS_SUCCESS) /* no match */ 510 break; 511 if (pw->pw_name[0] == '+' || pw->pw_name[0] == '-') { 512 /* if a compat line */ 513 if (search == _PW_KEYBYNUM) 514 continue; /* read next if pwent */ 515 rv = NS_NOTFOUND; /* don't match if pw{nam,uid} */ 516 break; 517 } 518 break; 519 } 520 521 if (rv == NS_NOTFOUND && search == _PW_KEYBYNUM) 522 state->keynum = -1; /* flag `no more records' */ 523 524 if (rv == NS_SUCCESS) { 525 if ((search == _PW_KEYBYUID && pw->pw_uid != uid) || 526 (search == _PW_KEYBYNAME && strcmp(pw->pw_name, name) != 0)) 527 rv = NS_NOTFOUND; 528 } 529 530 filespwscan_out: 531 if (rv != NS_SUCCESS) 532 *retval = errno; 533 return rv; 534 } 535 536 /*ARGSUSED*/ 537 static int 538 _files_setpwent(void *nsrv, void *nscb, va_list ap) 539 { 540 541 _files_state.stayopen = 0; 542 return _files_start(&_files_state); 543 } 544 545 /*ARGSUSED*/ 546 static int 547 _files_setpassent(void *nsrv, void *nscb, va_list ap) 548 { 549 int *retval = va_arg(ap, int *); 550 int stayopen = va_arg(ap, int); 551 552 int rv; 553 554 _files_state.stayopen = stayopen; 555 rv = _files_start(&_files_state); 556 *retval = (rv == NS_SUCCESS); 557 return rv; 558 } 559 560 /*ARGSUSED*/ 561 static int 562 _files_endpwent(void *nsrv, void *nscb, va_list ap) 563 { 564 565 _files_state.stayopen = 0; 566 return _files_end(&_files_state); 567 } 568 569 /*ARGSUSED*/ 570 static int 571 _files_getpwent(void *nsrv, void *nscb, va_list ap) 572 { 573 struct passwd **retval = va_arg(ap, struct passwd **); 574 575 int rv, rerror; 576 577 _DIAGASSERT(retval != NULL); 578 579 *retval = NULL; 580 rv = _files_pwscan(&rerror, &_files_passwd, 581 _files_passwdbuf, sizeof(_files_passwdbuf), 582 &_files_state, _PW_KEYBYNUM, NULL, 0); 583 if (rv == NS_SUCCESS) 584 *retval = &_files_passwd; 585 return rv; 586 } 587 588 /*ARGSUSED*/ 589 static int 590 _files_getpwnam(void *nsrv, void *nscb, va_list ap) 591 { 592 struct passwd **retval = va_arg(ap, struct passwd **); 593 const char *name = va_arg(ap, const char *); 594 595 int rv, rerror; 596 597 _DIAGASSERT(retval != NULL); 598 599 *retval = NULL; 600 rv = _files_start(&_files_state); 601 if (rv != NS_SUCCESS) 602 return rv; 603 rv = _files_pwscan(&rerror, &_files_passwd, 604 _files_passwdbuf, sizeof(_files_passwdbuf), 605 &_files_state, _PW_KEYBYNAME, name, 0); 606 if (!_files_state.stayopen) 607 _files_end(&_files_state); 608 if (rv == NS_SUCCESS) 609 *retval = &_files_passwd; 610 return rv; 611 } 612 613 /*ARGSUSED*/ 614 static int 615 _files_getpwnam_r(void *nsrv, void *nscb, va_list ap) 616 { 617 int *retval = va_arg(ap, int *); 618 const char *name = va_arg(ap, const char *); 619 struct passwd *pw = va_arg(ap, struct passwd *); 620 char *buffer = va_arg(ap, char *); 621 size_t buflen = va_arg(ap, size_t); 622 struct passwd **result = va_arg(ap, struct passwd **); 623 624 struct files_state state; 625 int rv; 626 627 _DIAGASSERT(retval != NULL); 628 _DIAGASSERT(pw != NULL); 629 _DIAGASSERT(buffer != NULL); 630 _DIAGASSERT(result != NULL); 631 632 *result = NULL; 633 memset(&state, 0, sizeof(state)); 634 rv = _files_pwscan(retval, pw, buffer, buflen, &state, 635 _PW_KEYBYNAME, name, 0); 636 _files_end(&state); 637 if (rv == NS_SUCCESS) 638 *result = pw; 639 return rv; 640 } 641 642 /*ARGSUSED*/ 643 static int 644 _files_getpwuid(void *nsrv, void *nscb, va_list ap) 645 { 646 struct passwd **retval = va_arg(ap, struct passwd **); 647 uid_t uid = va_arg(ap, uid_t); 648 649 int rv, rerror; 650 651 _DIAGASSERT(retval != NULL); 652 653 *retval = NULL; 654 rv = _files_start(&_files_state); 655 if (rv != NS_SUCCESS) 656 return rv; 657 rv = _files_pwscan(&rerror, &_files_passwd, 658 _files_passwdbuf, sizeof(_files_passwdbuf), 659 &_files_state, _PW_KEYBYUID, NULL, uid); 660 if (!_files_state.stayopen) 661 _files_end(&_files_state); 662 if (rv == NS_SUCCESS) 663 *retval = &_files_passwd; 664 return rv; 665 } 666 667 /*ARGSUSED*/ 668 static int 669 _files_getpwuid_r(void *nsrv, void *nscb, va_list ap) 670 { 671 int *retval = va_arg(ap, int *); 672 uid_t uid = va_arg(ap, uid_t); 673 struct passwd *pw = va_arg(ap, struct passwd *); 674 char *buffer = va_arg(ap, char *); 675 size_t buflen = va_arg(ap, size_t); 676 struct passwd **result = va_arg(ap, struct passwd **); 677 678 struct files_state state; 679 int rv; 680 681 _DIAGASSERT(retval != NULL); 682 _DIAGASSERT(pw != NULL); 683 _DIAGASSERT(buffer != NULL); 684 _DIAGASSERT(result != NULL); 685 686 *result = NULL; 687 memset(&state, 0, sizeof(state)); 688 rv = _files_pwscan(retval, pw, buffer, buflen, &state, 689 _PW_KEYBYUID, NULL, uid); 690 _files_end(&state); 691 if (rv == NS_SUCCESS) 692 *result = pw; 693 return rv; 694 } 695 696 697 #ifdef HESIOD 698 /* 699 * dns methods 700 */ 701 702 /* state shared between dns methods */ 703 struct dns_state { 704 int stayopen; /* see getpassent(3) */ 705 void *context; /* Hesiod context */ 706 int num; /* passwd index, -1 if no more */ 707 }; 708 709 static struct dns_state _dns_state; 710 /* storage for non _r functions */ 711 static struct passwd _dns_passwd; 712 static char _dns_passwdbuf[GETPW_R_SIZE_MAX]; 713 714 static int 715 _dns_start(struct dns_state *state) 716 { 717 718 _DIAGASSERT(state != NULL); 719 720 state->num = 0; 721 if (state->context == NULL) { /* setup Hesiod */ 722 if (hesiod_init(&state->context) == -1) 723 return NS_UNAVAIL; 724 } 725 726 return NS_SUCCESS; 727 } 728 729 static int 730 _dns_end(struct dns_state *state) 731 { 732 733 _DIAGASSERT(state != NULL); 734 735 state->num = 0; 736 if (state->context) { 737 hesiod_end(state->context); 738 state->context = NULL; 739 } 740 return NS_SUCCESS; 741 } 742 743 /* 744 * _dns_pwscan 745 * Look for the Hesiod name provided in buffer in the NULL-terminated 746 * list of zones, 747 * and decode into pw/buffer/buflen. 748 */ 749 static int 750 _dns_pwscan(int *retval, struct passwd *pw, char *buffer, size_t buflen, 751 struct dns_state *state, const char **zones) 752 { 753 const char **curzone; 754 char **hp, *ep; 755 int rv; 756 757 _DIAGASSERT(retval != NULL); 758 _DIAGASSERT(pw != NULL); 759 _DIAGASSERT(buffer != NULL); 760 _DIAGASSERT(state != NULL); 761 _DIAGASSERT(zones != NULL); 762 763 *retval = 0; 764 765 if (state->context == NULL) { /* only start if Hesiod not setup */ 766 rv = _dns_start(state); 767 if (rv != NS_SUCCESS) 768 return rv; 769 } 770 771 hp = NULL; 772 rv = NS_NOTFOUND; 773 774 for (curzone = zones; *curzone; curzone++) { /* search zones */ 775 hp = hesiod_resolve(state->context, buffer, *curzone); 776 if (hp != NULL) 777 break; 778 if (errno != ENOENT) { 779 rv = NS_UNAVAIL; 780 goto dnspwscan_out; 781 } 782 } 783 if (*curzone == NULL) 784 goto dnspwscan_out; 785 786 if ((ep = strchr(hp[0], '\n')) != NULL) 787 *ep = '\0'; /* clear trailing \n */ 788 if (_pw_parse(hp[0], pw, buffer, buflen, 1)) /* validate line */ 789 rv = NS_SUCCESS; 790 else 791 rv = NS_UNAVAIL; 792 793 dnspwscan_out: 794 if (rv != NS_SUCCESS) 795 *retval = errno; 796 if (hp) 797 hesiod_free_list(state->context, hp); 798 return rv; 799 } 800 801 /*ARGSUSED*/ 802 static int 803 _dns_setpwent(void *nsrv, void *nscb, va_list ap) 804 { 805 806 _dns_state.stayopen = 0; 807 return _dns_start(&_dns_state); 808 } 809 810 /*ARGSUSED*/ 811 static int 812 _dns_setpassent(void *nsrv, void *nscb, va_list ap) 813 { 814 int *retval = va_arg(ap, int *); 815 int stayopen = va_arg(ap, int); 816 817 int rv; 818 819 _dns_state.stayopen = stayopen; 820 rv = _dns_start(&_dns_state); 821 *retval = (rv == NS_SUCCESS); 822 return rv; 823 } 824 825 /*ARGSUSED*/ 826 static int 827 _dns_endpwent(void *nsrv, void *nscb, va_list ap) 828 { 829 830 _dns_state.stayopen = 0; 831 return _dns_end(&_dns_state); 832 } 833 834 /*ARGSUSED*/ 835 static int 836 _dns_getpwent(void *nsrv, void *nscb, va_list ap) 837 { 838 struct passwd **retval = va_arg(ap, struct passwd **); 839 840 char **hp, *ep; 841 int rv; 842 843 _DIAGASSERT(retval != NULL); 844 845 *retval = NULL; 846 847 if (_dns_state.num == -1) /* exhausted search */ 848 return NS_NOTFOUND; 849 850 if (_dns_state.context == NULL) { 851 /* only start if Hesiod not setup */ 852 rv = _dns_start(&_dns_state); 853 if (rv != NS_SUCCESS) 854 return rv; 855 } 856 857 hp = NULL; 858 rv = NS_NOTFOUND; 859 860 /* find passwd-NNN */ 861 snprintf(_dns_passwdbuf, sizeof(_dns_passwdbuf), 862 "passwd-%u", _dns_state.num); 863 _dns_state.num++; 864 865 hp = hesiod_resolve(_dns_state.context, _dns_passwdbuf, "passwd"); 866 if (hp == NULL) { 867 if (errno == ENOENT) 868 _dns_state.num = -1; 869 else 870 rv = NS_UNAVAIL; 871 } else { 872 if ((ep = strchr(hp[0], '\n')) != NULL) 873 *ep = '\0'; /* clear trailing \n */ 874 /* validate line */ 875 if (_pw_parse(hp[0], &_dns_passwd, 876 _dns_passwdbuf, sizeof(_dns_passwdbuf), 1)) 877 rv = NS_SUCCESS; 878 else 879 rv = NS_UNAVAIL; 880 } 881 882 if (hp) 883 hesiod_free_list(_dns_state.context, hp); 884 if (rv == NS_SUCCESS) 885 *retval = &_dns_passwd; 886 return rv; 887 } 888 889 static const char *_dns_uid_zones[] = { 890 "uid", 891 "passwd", 892 NULL 893 }; 894 895 /*ARGSUSED*/ 896 static int 897 _dns_getpwuid(void *nsrv, void *nscb, va_list ap) 898 { 899 struct passwd **retval = va_arg(ap, struct passwd **); 900 uid_t uid = va_arg(ap, uid_t); 901 902 int rv, rerror; 903 904 _DIAGASSERT(retval != NULL); 905 906 *retval = NULL; 907 rv = _dns_start(&_dns_state); 908 if (rv != NS_SUCCESS) 909 return rv; 910 snprintf(_dns_passwdbuf, sizeof(_dns_passwdbuf), 911 "%u", (unsigned int)uid); 912 rv = _dns_pwscan(&rerror, &_dns_passwd, 913 _dns_passwdbuf, sizeof(_dns_passwdbuf), 914 &_dns_state, _dns_uid_zones); 915 if (!_dns_state.stayopen) 916 _dns_end(&_dns_state); 917 if (rv == NS_SUCCESS && uid == _dns_passwd.pw_uid) 918 *retval = &_dns_passwd; 919 return rv; 920 } 921 922 /*ARGSUSED*/ 923 static int 924 _dns_getpwuid_r(void *nsrv, void *nscb, va_list ap) 925 { 926 int *retval = va_arg(ap, int *); 927 uid_t uid = va_arg(ap, uid_t); 928 struct passwd *pw = va_arg(ap, struct passwd *); 929 char *buffer = va_arg(ap, char *); 930 size_t buflen = va_arg(ap, size_t); 931 struct passwd **result = va_arg(ap, struct passwd **); 932 933 struct dns_state state; 934 int rv; 935 936 _DIAGASSERT(retval != NULL); 937 _DIAGASSERT(pw != NULL); 938 _DIAGASSERT(buffer != NULL); 939 _DIAGASSERT(result != NULL); 940 941 *result = NULL; 942 memset(&state, 0, sizeof(state)); 943 snprintf(buffer, buflen, "%u", (unsigned int)uid); 944 rv = _dns_pwscan(retval, pw, buffer, buflen, &state, _dns_uid_zones); 945 _dns_end(&state); 946 if (rv != NS_SUCCESS) 947 return rv; 948 if (uid == pw->pw_uid) { 949 *result = pw; 950 return NS_SUCCESS; 951 } else 952 return NS_NOTFOUND; 953 } 954 955 static const char *_dns_nam_zones[] = { 956 "passwd", 957 NULL 958 }; 959 960 /*ARGSUSED*/ 961 static int 962 _dns_getpwnam(void *nsrv, void *nscb, va_list ap) 963 { 964 struct passwd **retval = va_arg(ap, struct passwd **); 965 const char *name = va_arg(ap, const char *); 966 967 int rv, rerror; 968 969 _DIAGASSERT(retval != NULL); 970 971 *retval = NULL; 972 rv = _dns_start(&_dns_state); 973 if (rv != NS_SUCCESS) 974 return rv; 975 snprintf(_dns_passwdbuf, sizeof(_dns_passwdbuf), "%s", name); 976 rv = _dns_pwscan(&rerror, &_dns_passwd, 977 _dns_passwdbuf, sizeof(_dns_passwdbuf), 978 &_dns_state, _dns_nam_zones); 979 if (!_dns_state.stayopen) 980 _dns_end(&_dns_state); 981 if (rv == NS_SUCCESS && strcmp(name, _dns_passwd.pw_name) == 0) 982 *retval = &_dns_passwd; 983 return rv; 984 } 985 986 /*ARGSUSED*/ 987 static int 988 _dns_getpwnam_r(void *nsrv, void *nscb, va_list ap) 989 { 990 int *retval = va_arg(ap, int *); 991 const char *name = va_arg(ap, const char *); 992 struct passwd *pw = va_arg(ap, struct passwd *); 993 char *buffer = va_arg(ap, char *); 994 size_t buflen = va_arg(ap, size_t); 995 struct passwd **result = va_arg(ap, struct passwd **); 996 997 struct dns_state state; 998 int rv; 999 1000 _DIAGASSERT(retval != NULL); 1001 _DIAGASSERT(pw != NULL); 1002 _DIAGASSERT(buffer != NULL); 1003 _DIAGASSERT(result != NULL); 1004 1005 *result = NULL; 1006 memset(&state, 0, sizeof(state)); 1007 snprintf(buffer, buflen, "%s", name); 1008 rv = _dns_pwscan(retval, pw, buffer, buflen, &state, _dns_nam_zones); 1009 _dns_end(&state); 1010 if (rv != NS_SUCCESS) 1011 return rv; 1012 if (strcmp(name, pw->pw_name) == 0) { 1013 *result = pw; 1014 return NS_SUCCESS; 1015 } else 1016 return NS_NOTFOUND; 1017 } 1018 1019 #endif /* HESIOD */ 1020 1021 1022 #ifdef YP 1023 /* 1024 * nis methods 1025 */ 1026 /* state shared between nis methods */ 1027 struct nis_state { 1028 int stayopen; /* see getpassent(3) */ 1029 char *domain; /* NIS domain */ 1030 int done; /* non-zero if search exhausted */ 1031 char *current; /* current first/next match */ 1032 int currentlen; /* length of _nis_current */ 1033 enum { /* shadow map type */ 1034 NISMAP_UNKNOWN, /* unknown ... */ 1035 NISMAP_NONE, /* none: use "passwd.by*" */ 1036 NISMAP_ADJUNCT, /* pw_passwd from "passwd.adjunct.*" */ 1037 NISMAP_MASTER /* all from "master.passwd.by*" */ 1038 } maptype; 1039 }; 1040 1041 static struct nis_state _nis_state; 1042 /* storage for non _r functions */ 1043 static struct passwd _nis_passwd; 1044 static char _nis_passwdbuf[GETPW_R_SIZE_MAX]; 1045 1046 /* macros for deciding which NIS maps to use. */ 1047 #define PASSWD_BYNAME(x) ((x)->maptype == NISMAP_MASTER \ 1048 ? "master.passwd.byname" : "passwd.byname") 1049 #define PASSWD_BYUID(x) ((x)->maptype == NISMAP_MASTER \ 1050 ? "master.passwd.byuid" : "passwd.byuid") 1051 1052 static int 1053 _nis_start(struct nis_state *state) 1054 { 1055 1056 _DIAGASSERT(state != NULL); 1057 1058 state->done = 0; 1059 if (state->current) { 1060 free(state->current); 1061 state->current = NULL; 1062 } 1063 if (state->domain == NULL) { /* setup NIS */ 1064 switch (yp_get_default_domain(&state->domain)) { 1065 case 0: 1066 break; 1067 case YPERR_RESRC: 1068 return NS_TRYAGAIN; 1069 default: 1070 return NS_UNAVAIL; 1071 } 1072 } 1073 1074 /* determine where to get pw_passwd from */ 1075 if (state->maptype == NISMAP_UNKNOWN) { 1076 int r, order; 1077 1078 state->maptype = NISMAP_NONE; /* default to no adjunct */ 1079 if (geteuid() != 0) /* non-root can't use adjunct */ 1080 return NS_SUCCESS; 1081 1082 /* look for "master.passwd.*" */ 1083 r = yp_order(state->domain, "master.passwd.byname", &order); 1084 if (r == 0) { 1085 state->maptype = NISMAP_MASTER; 1086 return NS_SUCCESS; 1087 } 1088 1089 /* master.passwd doesn't exist, try passwd.adjunct */ 1090 if (r == YPERR_MAP) { 1091 r = yp_order(state->domain, "passwd.adjunct.byname", 1092 &order); 1093 if (r == 0) 1094 state->maptype = NISMAP_ADJUNCT; 1095 } 1096 } 1097 return NS_SUCCESS; 1098 } 1099 1100 static int 1101 _nis_end(struct nis_state *state) 1102 { 1103 1104 _DIAGASSERT(state != NULL); 1105 1106 if (state->domain) 1107 state->domain = NULL; 1108 state->done = 0; 1109 if (state->current) 1110 free(state->current); 1111 state->current = NULL; 1112 state->maptype = NISMAP_UNKNOWN; 1113 return NS_SUCCESS; 1114 } 1115 1116 /* 1117 * nis_parse 1118 * wrapper to _pw_parse that obtains the real password from the 1119 * "passwd.adjunct.byname" NIS map if the maptype is NISMAP_ADJUNCT. 1120 */ 1121 static int 1122 _nis_parse(const char *entry, struct passwd *pw, char *buf, size_t buflen, 1123 struct nis_state *state) 1124 { 1125 size_t elen; 1126 1127 _DIAGASSERT(entry != NULL); 1128 _DIAGASSERT(pw != NULL); 1129 _DIAGASSERT(buf != NULL); 1130 _DIAGASSERT(state != NULL); 1131 1132 elen = strlen(entry); 1133 if (elen >= buflen) 1134 return 0; 1135 if (! _pw_parse(entry, pw, buf, buflen, 1136 !(state->maptype == NISMAP_MASTER))) 1137 return 0; 1138 1139 if ((state->maptype == NISMAP_ADJUNCT) && 1140 (strstr(pw->pw_passwd, "##") != NULL)) { 1141 char *data; 1142 int datalen; 1143 1144 if (yp_match(state->domain, "passwd.adjunct.byname", 1145 pw->pw_name, (int)strlen(pw->pw_name), 1146 &data, &datalen) == 0) { 1147 char *bp, *ep; 1148 /* skip name to get password */ 1149 ep = data; 1150 if ((bp = strsep(&ep, ":")) != NULL && 1151 (bp = strsep(&ep, ":")) != NULL) { 1152 /* store new pw_passwd after entry */ 1153 strlcpy(buf + elen, bp, buflen - elen); 1154 pw->pw_passwd = &buf[elen]; 1155 } 1156 free(data); 1157 } 1158 } 1159 1160 return 1; 1161 } 1162 1163 1164 /* 1165 * _nis_pwscan 1166 * Look for the yp key provided in buffer from map, 1167 * and decode into pw/buffer/buflen. 1168 */ 1169 static int 1170 _nis_pwscan(int *retval, struct passwd *pw, char *buffer, size_t buflen, 1171 struct nis_state *state, const char *map) 1172 { 1173 char *data; 1174 int nisr, rv, datalen; 1175 1176 _DIAGASSERT(retval != NULL); 1177 _DIAGASSERT(pw != NULL); 1178 _DIAGASSERT(buffer != NULL); 1179 _DIAGASSERT(state != NULL); 1180 _DIAGASSERT(map != NULL); 1181 1182 *retval = 0; 1183 1184 if (state->domain == NULL) { /* only start if NIS not setup */ 1185 rv = _nis_start(state); 1186 if (rv != NS_SUCCESS) 1187 return rv; 1188 } 1189 1190 data = NULL; 1191 rv = NS_NOTFOUND; 1192 1193 /* search map */ 1194 nisr = yp_match(state->domain, map, buffer, (int)strlen(buffer), 1195 &data, &datalen); 1196 switch (nisr) { 1197 case 0: 1198 data[datalen] = '\0'; /* clear trailing \n */ 1199 if (_nis_parse(data, pw, buffer, buflen, state)) 1200 rv = NS_SUCCESS; /* validate line */ 1201 else 1202 rv = NS_UNAVAIL; 1203 break; 1204 case YPERR_KEY: 1205 break; 1206 default: 1207 rv = NS_UNAVAIL; 1208 break; 1209 } 1210 1211 if (rv != NS_SUCCESS) 1212 *retval = errno; 1213 if (data) 1214 free(data); 1215 return rv; 1216 } 1217 1218 /*ARGSUSED*/ 1219 static int 1220 _nis_setpwent(void *nsrv, void *nscb, va_list ap) 1221 { 1222 1223 _nis_state.stayopen = 0; 1224 return _nis_start(&_nis_state); 1225 } 1226 1227 /*ARGSUSED*/ 1228 static int 1229 _nis_setpassent(void *nsrv, void *nscb, va_list ap) 1230 { 1231 int *retval = va_arg(ap, int *); 1232 int stayopen = va_arg(ap, int); 1233 1234 int rv; 1235 1236 _nis_state.stayopen = stayopen; 1237 rv = _nis_start(&_nis_state); 1238 *retval = (rv == NS_SUCCESS); 1239 return rv; 1240 } 1241 1242 /*ARGSUSED*/ 1243 static int 1244 _nis_endpwent(void *nsrv, void *nscb, va_list ap) 1245 { 1246 1247 return _nis_end(&_nis_state); 1248 } 1249 1250 1251 /*ARGSUSED*/ 1252 static int 1253 _nis_getpwent(void *nsrv, void *nscb, va_list ap) 1254 { 1255 struct passwd **retval = va_arg(ap, struct passwd **); 1256 1257 char *key, *data; 1258 int keylen, datalen, rv, nisr; 1259 1260 _DIAGASSERT(retval != NULL); 1261 1262 *retval = NULL; 1263 1264 if (_nis_state.done) /* exhausted search */ 1265 return NS_NOTFOUND; 1266 if (_nis_state.domain == NULL) { 1267 /* only start if NIS not setup */ 1268 rv = _nis_start(&_nis_state); 1269 if (rv != NS_SUCCESS) 1270 return rv; 1271 } 1272 1273 key = NULL; 1274 data = NULL; 1275 rv = NS_NOTFOUND; 1276 1277 if (_nis_state.current) { /* already searching */ 1278 nisr = yp_next(_nis_state.domain, PASSWD_BYNAME(&_nis_state), 1279 _nis_state.current, _nis_state.currentlen, 1280 &key, &keylen, &data, &datalen); 1281 free(_nis_state.current); 1282 _nis_state.current = NULL; 1283 switch (nisr) { 1284 case 0: 1285 _nis_state.current = key; 1286 _nis_state.currentlen = keylen; 1287 key = NULL; 1288 break; 1289 case YPERR_NOMORE: 1290 _nis_state.done = 1; 1291 goto nisent_out; 1292 default: 1293 rv = NS_UNAVAIL; 1294 goto nisent_out; 1295 } 1296 } else { /* new search */ 1297 if (yp_first(_nis_state.domain, PASSWD_BYNAME(&_nis_state), 1298 &_nis_state.current, &_nis_state.currentlen, 1299 &data, &datalen)) { 1300 rv = NS_UNAVAIL; 1301 goto nisent_out; 1302 } 1303 } 1304 1305 data[datalen] = '\0'; /* clear trailing \n */ 1306 /* validate line */ 1307 if (_nis_parse(data, &_nis_passwd, 1308 _nis_passwdbuf, sizeof(_nis_passwdbuf), &_nis_state)) 1309 rv = NS_SUCCESS; 1310 else 1311 rv = NS_UNAVAIL; 1312 1313 nisent_out: 1314 if (key) 1315 free(key); 1316 if (data) 1317 free(data); 1318 if (rv == NS_SUCCESS) 1319 *retval = &_nis_passwd; 1320 return rv; 1321 } 1322 1323 /*ARGSUSED*/ 1324 static int 1325 _nis_getpwuid(void *nsrv, void *nscb, va_list ap) 1326 { 1327 struct passwd **retval = va_arg(ap, struct passwd **); 1328 uid_t uid = va_arg(ap, uid_t); 1329 1330 int rv, rerror; 1331 1332 _DIAGASSERT(retval != NULL); 1333 1334 *retval = NULL; 1335 rv = _nis_start(&_nis_state); 1336 if (rv != NS_SUCCESS) 1337 return rv; 1338 snprintf(_nis_passwdbuf, sizeof(_nis_passwdbuf), "%u", (unsigned int)uid); 1339 rv = _nis_pwscan(&rerror, &_nis_passwd, 1340 _nis_passwdbuf, sizeof(_nis_passwdbuf), 1341 &_nis_state, PASSWD_BYUID(&_nis_state)); 1342 if (!_nis_state.stayopen) 1343 _nis_end(&_nis_state); 1344 if (rv == NS_SUCCESS && uid == _nis_passwd.pw_uid) 1345 *retval = &_nis_passwd; 1346 return rv; 1347 } 1348 1349 /*ARGSUSED*/ 1350 static int 1351 _nis_getpwuid_r(void *nsrv, void *nscb, va_list ap) 1352 { 1353 int *retval = va_arg(ap, int *); 1354 uid_t uid = va_arg(ap, uid_t); 1355 struct passwd *pw = va_arg(ap, struct passwd *); 1356 char *buffer = va_arg(ap, char *); 1357 size_t buflen = va_arg(ap, size_t); 1358 struct passwd **result = va_arg(ap, struct passwd **); 1359 1360 struct nis_state state; 1361 int rv; 1362 1363 _DIAGASSERT(retval != NULL); 1364 _DIAGASSERT(pw != NULL); 1365 _DIAGASSERT(buffer != NULL); 1366 _DIAGASSERT(result != NULL); 1367 1368 *result = NULL; 1369 memset(&state, 0, sizeof(state)); 1370 rv = _nis_start(&state); 1371 if (rv != NS_SUCCESS) 1372 return rv; 1373 snprintf(buffer, buflen, "%u", (unsigned int)uid); 1374 rv = _nis_pwscan(retval, pw, buffer, buflen, 1375 &state, PASSWD_BYUID(&state)); 1376 _nis_end(&state); 1377 if (rv != NS_SUCCESS) 1378 return rv; 1379 if (uid == pw->pw_uid) { 1380 *result = pw; 1381 return NS_SUCCESS; 1382 } else 1383 return NS_NOTFOUND; 1384 } 1385 1386 /*ARGSUSED*/ 1387 static int 1388 _nis_getpwnam(void *nsrv, void *nscb, va_list ap) 1389 { 1390 struct passwd **retval = va_arg(ap, struct passwd **); 1391 const char *name = va_arg(ap, const char *); 1392 1393 int rv, rerror; 1394 1395 _DIAGASSERT(retval != NULL); 1396 1397 *retval = NULL; 1398 rv = _nis_start(&_nis_state); 1399 if (rv != NS_SUCCESS) 1400 return rv; 1401 snprintf(_nis_passwdbuf, sizeof(_nis_passwdbuf), "%s", name); 1402 rv = _nis_pwscan(&rerror, &_nis_passwd, 1403 _nis_passwdbuf, sizeof(_nis_passwdbuf), 1404 &_nis_state, PASSWD_BYNAME(&_nis_state)); 1405 if (!_nis_state.stayopen) 1406 _nis_end(&_nis_state); 1407 if (rv == NS_SUCCESS && strcmp(name, _nis_passwd.pw_name) == 0) 1408 *retval = &_nis_passwd; 1409 return rv; 1410 } 1411 1412 /*ARGSUSED*/ 1413 static int 1414 _nis_getpwnam_r(void *nsrv, void *nscb, va_list ap) 1415 { 1416 int *retval = va_arg(ap, int *); 1417 const char *name = va_arg(ap, const char *); 1418 struct passwd *pw = va_arg(ap, struct passwd *); 1419 char *buffer = va_arg(ap, char *); 1420 size_t buflen = va_arg(ap, size_t); 1421 struct passwd **result = va_arg(ap, struct passwd **); 1422 1423 struct nis_state state; 1424 int rv; 1425 1426 _DIAGASSERT(retval != NULL); 1427 _DIAGASSERT(pw != NULL); 1428 _DIAGASSERT(buffer != NULL); 1429 _DIAGASSERT(result != NULL); 1430 1431 *result = NULL; 1432 snprintf(buffer, buflen, "%s", name); 1433 memset(&state, 0, sizeof(state)); 1434 rv = _nis_start(&state); 1435 if (rv != NS_SUCCESS) 1436 return rv; 1437 rv = _nis_pwscan(retval, pw, buffer, buflen, 1438 &state, PASSWD_BYNAME(&state)); 1439 _nis_end(&state); 1440 if (rv != NS_SUCCESS) 1441 return rv; 1442 if (strcmp(name, pw->pw_name) == 0) { 1443 *result = pw; 1444 return NS_SUCCESS; 1445 } else 1446 return NS_NOTFOUND; 1447 } 1448 1449 #endif /* YP */ 1450 1451 1452 #ifdef _PASSWD_COMPAT 1453 /* 1454 * compat methods 1455 */ 1456 1457 /* state shared between compat methods */ 1458 1459 struct compat_state { 1460 int stayopen; /* see getpassent(3) */ 1461 DB *db; /* passwd DB */ 1462 int keynum; /* key counter, -1 if no more */ 1463 enum { /* current compat mode */ 1464 COMPAT_NOTOKEN = 0, /* no compat token present */ 1465 COMPAT_NONE, /* parsing normal pwd.db line */ 1466 COMPAT_FULL, /* parsing `+' entries */ 1467 COMPAT_USER, /* parsing `+name' entries */ 1468 COMPAT_NETGROUP /* parsing `+@netgroup' entries */ 1469 } mode; 1470 char *user; /* COMPAT_USER "+name" */ 1471 DB *exclude; /* compat exclude DB */ 1472 struct passwd proto; /* proto passwd entry */ 1473 char protobuf[GETPW_R_SIZE_MAX]; /* 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 Thu Sep 25 16:09:42 GMT 2025