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