getpwent.c revision 1.57
1 /* $NetBSD: getpwent.c,v 1.57 2004/10/05 04:45:54 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.57 2004/10/05 04:45:54 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", 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", 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), &_nis_state, "passwd.byuid"); 1334 if (!_nis_state.stayopen) 1335 _nis_end(&_nis_state); 1336 if (rv == NS_SUCCESS && uid == _nis_passwd.pw_uid) 1337 *retval = &_nis_passwd; 1338 return rv; 1339 } 1340 1341 /*ARGSUSED*/ 1342 static int 1343 _nis_getpwuid_r(void *nsrv, void *nscb, va_list ap) 1344 { 1345 int *retval = va_arg(ap, int *); 1346 uid_t uid = va_arg(ap, uid_t); 1347 struct passwd *pw = va_arg(ap, struct passwd *); 1348 char *buffer = va_arg(ap, char *); 1349 size_t buflen = va_arg(ap, size_t); 1350 struct passwd **result = va_arg(ap, struct passwd **); 1351 1352 struct nis_state state; 1353 int rv; 1354 1355 _DIAGASSERT(retval != NULL); 1356 _DIAGASSERT(pw != NULL); 1357 _DIAGASSERT(buffer != NULL); 1358 _DIAGASSERT(result != NULL); 1359 1360 *result = NULL; 1361 memset(&state, 0, sizeof(state)); 1362 snprintf(buffer, buflen, "%u", (unsigned int)uid); 1363 rv = _nis_pwscan(retval, pw, buffer, buflen, &state, "passwd.byuid"); 1364 _nis_end(&state); 1365 if (rv != NS_SUCCESS) 1366 return rv; 1367 if (uid == pw->pw_uid) { 1368 *result = pw; 1369 return NS_SUCCESS; 1370 } else 1371 return NS_NOTFOUND; 1372 } 1373 1374 /*ARGSUSED*/ 1375 static int 1376 _nis_getpwnam(void *nsrv, void *nscb, va_list ap) 1377 { 1378 struct passwd **retval = va_arg(ap, struct passwd **); 1379 const char *name = va_arg(ap, const char *); 1380 1381 int rv, rerror; 1382 1383 _DIAGASSERT(retval != NULL); 1384 1385 *retval = NULL; 1386 rv = _nis_start(&_nis_state); 1387 if (rv != NS_SUCCESS) 1388 return rv; 1389 snprintf(_nis_passwdbuf, sizeof(_nis_passwdbuf), "%s", name); 1390 rv = _nis_pwscan(&rerror, &_nis_passwd, 1391 _nis_passwdbuf, sizeof(_nis_passwdbuf), &_nis_state, "passwd.byname"); 1392 if (!_nis_state.stayopen) 1393 _nis_end(&_nis_state); 1394 if (rv == NS_SUCCESS && strcmp(name, _nis_passwd.pw_name) == 0) 1395 *retval = &_nis_passwd; 1396 return rv; 1397 } 1398 1399 /*ARGSUSED*/ 1400 static int 1401 _nis_getpwnam_r(void *nsrv, void *nscb, va_list ap) 1402 { 1403 int *retval = va_arg(ap, int *); 1404 const char *name = va_arg(ap, const char *); 1405 struct passwd *pw = va_arg(ap, struct passwd *); 1406 char *buffer = va_arg(ap, char *); 1407 size_t buflen = va_arg(ap, size_t); 1408 struct passwd **result = va_arg(ap, struct passwd **); 1409 1410 struct nis_state state; 1411 int rv; 1412 1413 _DIAGASSERT(retval != NULL); 1414 _DIAGASSERT(pw != NULL); 1415 _DIAGASSERT(buffer != NULL); 1416 _DIAGASSERT(result != NULL); 1417 1418 *result = NULL; 1419 snprintf(buffer, buflen, "%s", name); 1420 memset(&state, 0, sizeof(state)); 1421 rv = _nis_pwscan(retval, pw, buffer, buflen, &state, "passwd.byname"); 1422 _nis_end(&state); 1423 if (rv != NS_SUCCESS) 1424 return rv; 1425 if (strcmp(name, pw->pw_name) == 0) { 1426 *result = pw; 1427 return NS_SUCCESS; 1428 } else 1429 return NS_NOTFOUND; 1430 } 1431 1432 #endif /* YP */ 1433 1434 1435 #ifdef _PASSWD_COMPAT 1436 /* 1437 * compat methods 1438 */ 1439 1440 /* state shared between compat methods */ 1441 1442 struct compat_state { 1443 int stayopen; /* see getpassent(3) */ 1444 DB *db; /* passwd DB */ 1445 int keynum; /* key counter, -1 if no more */ 1446 enum { /* current compat mode */ 1447 COMPAT_NOTOKEN = 0, /* no compat token present */ 1448 COMPAT_NONE, /* parsing normal pwd.db line */ 1449 COMPAT_FULL, /* parsing `+' entries */ 1450 COMPAT_USER, /* parsing `+name' entries */ 1451 COMPAT_NETGROUP /* parsing `+@netgroup' entries */ 1452 } mode; 1453 char *user; /* COMPAT_USER "+name" */ 1454 DB *exclude; /* compat exclude DB */ 1455 struct passwd proto; /* proto passwd entry */ 1456 char protobuf[GETPW_R_SIZE_MAX]; /* buffer for proto ptrs */ 1457 int protoflags; /* proto passwd flags */ 1458 }; 1459 1460 static struct compat_state _compat_state; 1461 /* storage for non _r functions */ 1462 static struct passwd _compat_passwd; 1463 static char _compat_passwdbuf[GETPW_R_SIZE_MAX]; 1464 1465 static int 1466 _compat_start(struct compat_state *state) 1467 { 1468 int rv; 1469 1470 _DIAGASSERT(state != NULL); 1471 1472 state->keynum = 0; 1473 if (state->db == NULL) { /* not open yet */ 1474 DBT key, data; 1475 DBT pkey, pdata; 1476 char bf[MAXLOGNAME]; 1477 1478 rv = _pw_opendb(&state->db); 1479 if (rv != NS_SUCCESS) 1480 return rv; 1481 1482 state->mode = COMPAT_NOTOKEN; 1483 1484 /* 1485 * Determine if the "compat" token is present in pwd.db; 1486 * either "__YP!" or PW_KEYBYNAME+"+". 1487 * Only works if pwd_mkdb installs the token. 1488 */ 1489 key.data = (u_char *)__UNCONST(__yp_token); 1490 key.size = strlen(__yp_token); 1491 1492 bf[0] = _PW_KEYBYNAME; /* Pre-token database support. */ 1493 bf[1] = '+'; 1494 pkey.data = (u_char *)bf; 1495 pkey.size = 2; 1496 1497 if ((state->db->get)(state->db, &key, &data, 0) == 0 1498 || (state->db->get)(state->db, &pkey, &pdata, 0) == 0) 1499 state->mode = COMPAT_NONE; 1500 } 1501 return NS_SUCCESS; 1502 } 1503 1504 static int 1505 _compat_end(struct compat_state *state) 1506 { 1507 1508 _DIAGASSERT(state != NULL); 1509 1510 state->keynum = 0; 1511 if (state->db) { 1512 (void)(state->db->close)(state->db); 1513 state->db = NULL; 1514 } 1515 state->mode = COMPAT_NOTOKEN; 1516 if (state->user) 1517 free(state->user); 1518 state->user = NULL; 1519 if (state->exclude != NULL) 1520 (void)(state->exclude->close)(state->exclude); 1521 state->exclude = NULL; 1522 state->proto.pw_name = NULL; 1523 state->protoflags = 0; 1524 return NS_SUCCESS; 1525 } 1526 1527 /* 1528 * _compat_add_exclude 1529 * add the name to the exclude list in state->exclude. 1530 */ 1531 static int 1532 _compat_add_exclude(struct compat_state *state, const char *name) 1533 { 1534 DBT key, data; 1535 1536 _DIAGASSERT(state != NULL); 1537 _DIAGASSERT(name != NULL); 1538 1539 /* initialize the exclusion table if needed */ 1540 if (state->exclude == NULL) { 1541 state->exclude = dbopen(NULL, O_RDWR, 600, DB_HASH, NULL); 1542 if (state->exclude == NULL) 1543 return 0; 1544 } 1545 1546 key.size = strlen(name); /* set up the key */ 1547 key.data = (u_char *)__UNCONST(name); 1548 1549 data.data = NULL; /* data is nothing */ 1550 data.size = 0; 1551 1552 /* store it */ 1553 if ((state->exclude->put)(state->exclude, &key, &data, 0) == -1) 1554 return 0; 1555 1556 return 1; 1557 } 1558 1559 /* 1560 * _compat_is_excluded 1561 * test if a name is on the compat mode exclude list 1562 */ 1563 static int 1564 _compat_is_excluded(struct compat_state *state, const char *name) 1565 { 1566 DBT key, data; 1567 1568 _DIAGASSERT(state != NULL); 1569 _DIAGASSERT(name != NULL); 1570 1571 if (state->exclude == NULL) 1572 return 0; /* nothing excluded */ 1573 1574 key.size = strlen(name); /* set up the key */ 1575 key.data = (u_char *)__UNCONST(name); 1576 1577 if ((state->exclude->get)(state->exclude, &key, &data, 0) == 0) 1578 return 1; /* is excluded */ 1579 1580 return 0; 1581 } 1582 1583 1584 /* 1585 * _passwdcompat_bad 1586 * log an error if "files" or "compat" is specified in 1587 * passwd_compat database 1588 */ 1589 /*ARGSUSED*/ 1590 static int 1591 _passwdcompat_bad(void *nsrv, void *nscb, va_list ap) 1592 { 1593 static int warned; 1594 1595 _DIAGASSERT(cb_data != NULL); 1596 1597 if (!warned) { 1598 syslog(LOG_ERR, 1599 "nsswitch.conf passwd_compat database can't use '%s'", 1600 (char *)nscb); 1601 } 1602 warned = 1; 1603 return NS_UNAVAIL; 1604 } 1605 1606 /* 1607 * _passwdcompat_setpassent 1608 * Call setpassent for all passwd_compat sources. 1609 */ 1610 static int 1611 _passwdcompat_setpassent(int stayopen) 1612 { 1613 static const ns_dtab dtab[] = { 1614 NS_FILES_CB(_passwdcompat_bad, "files") 1615 NS_DNS_CB(_dns_setpassent, NULL) 1616 NS_NIS_CB(_nis_setpassent, NULL) 1617 NS_COMPAT_CB(_passwdcompat_bad, "compat") 1618 { 0 } 1619 }; 1620 1621 int rv, result; 1622 1623 rv = nsdispatch(NULL, dtab, NSDB_PASSWD_COMPAT, "setpassent", 1624 defaultnis_forceall, &result, stayopen); 1625 return rv; 1626 } 1627 1628 /* 1629 * _passwdcompat_endpwent 1630 * Call endpwent for all passwd_compat sources. 1631 */ 1632 static int 1633 _passwdcompat_endpwent(void) 1634 { 1635 static const ns_dtab dtab[] = { 1636 NS_FILES_CB(_passwdcompat_bad, "files") 1637 NS_DNS_CB(_dns_endpwent, NULL) 1638 NS_NIS_CB(_nis_endpwent, NULL) 1639 NS_COMPAT_CB(_passwdcompat_bad, "compat") 1640 { 0 } 1641 }; 1642 1643 return nsdispatch(NULL, dtab, NSDB_PASSWD_COMPAT, "endpwent", 1644 defaultnis_forceall); 1645 } 1646 1647 /* 1648 * _passwdcompat_grscan 1649 * When a name lookup in compat mode is required (e.g., `+name', or a 1650 * name in `+@netgroup'), look it up in the 'passwd_compat' nsswitch 1651 * database. 1652 * Fail if passwd_compat contains files or compat. 1653 */ 1654 static int 1655 _passwdcompat_grscan(struct passwd *pw, char *buffer, size_t buflen, 1656 int search, const char *name, uid_t uid) 1657 { 1658 static const ns_dtab compatentdtab[] = { 1659 NS_FILES_CB(_passwdcompat_bad, "files") 1660 NS_DNS_CB(_dns_getpwent, NULL) 1661 NS_NIS_CB(_nis_getpwent, NULL) 1662 NS_COMPAT_CB(_passwdcompat_bad, "compat") 1663 { 0 } 1664 }; 1665 static const ns_dtab compatuiddtab[] = { 1666 NS_FILES_CB(_passwdcompat_bad, "files") 1667 NS_DNS_CB(_dns_getpwuid_r, NULL) 1668 NS_NIS_CB(_nis_getpwuid_r, NULL) 1669 NS_COMPAT_CB(_passwdcompat_bad, "compat") 1670 { 0 } 1671 }; 1672 static const ns_dtab compatnamdtab[] = { 1673 NS_FILES_CB(_passwdcompat_bad, "files") 1674 NS_DNS_CB(_dns_getpwnam_r, NULL) 1675 NS_NIS_CB(_nis_getpwnam_r, NULL) 1676 NS_COMPAT_CB(_passwdcompat_bad, "compat") 1677 { 0 } 1678 }; 1679 1680 int rv, crv; 1681 struct passwd *cpw; 1682 1683 switch (search) { 1684 case _PW_KEYBYNUM: 1685 /* XXXREENTRANT: implement & use getpwent_r */ 1686 rv = nsdispatch(NULL, compatentdtab, 1687 NSDB_PASSWD_COMPAT, "getpwent", defaultnis, 1688 &cpw); 1689 if (rv == NS_SUCCESS && 1690 ! _pw_copy(cpw, pw, buffer, buflen, NULL, 0)) { 1691 errno = ERANGE; 1692 rv = NS_UNAVAIL; 1693 } 1694 break; 1695 case _PW_KEYBYNAME: 1696 _DIAGASSERT(name != NULL); 1697 rv = nsdispatch(NULL, compatnamdtab, 1698 NSDB_PASSWD_COMPAT, "getpwnam_r", defaultnis, 1699 &crv, name, pw, buffer, buflen, &cpw); 1700 break; 1701 case _PW_KEYBYUID: 1702 rv = nsdispatch(NULL, compatuiddtab, 1703 NSDB_PASSWD_COMPAT, "getpwuid_r", defaultnis, 1704 &crv, uid, pw, buffer, buflen, &cpw); 1705 break; 1706 default: 1707 abort(); 1708 /*NOTREACHED*/ 1709 } 1710 return rv; 1711 } 1712 1713 /* 1714 * _compat_pwscan 1715 * Search state->db for the next desired entry. 1716 * If search is _PW_KEYBYNUM, look for state->keynum. 1717 * If search is _PW_KEYBYNAME, look for name. 1718 * If search is _PW_KEYBYUID, look for uid. 1719 * Sets *retval to the errno if the result is not NS_SUCCESS. 1720 */ 1721 static int 1722 _compat_pwscan(int *retval, struct passwd *pw, char *buffer, size_t buflen, 1723 struct compat_state *state, int search, const char *name, uid_t uid) 1724 { 1725 DBT key; 1726 int rv, r, pwflags; 1727 const char *user, *host, *dom; 1728 const void *from; 1729 size_t fromlen; 1730 1731 _DIAGASSERT(retval != NULL); 1732 _DIAGASSERT(pw != NULL); 1733 _DIAGASSERT(buffer != NULL); 1734 _DIAGASSERT(state != NULL); 1735 /* name may be NULL */ 1736 1737 *retval = 0; 1738 1739 if (state->db == NULL) { 1740 rv = _compat_start(state); 1741 if (rv != NS_SUCCESS) 1742 return rv; 1743 } 1744 if (buflen <= 1) { /* buffer too small */ 1745 *retval = ERANGE; 1746 return NS_UNAVAIL; 1747 } 1748 1749 for (;;) { /* loop over pwd.db */ 1750 rv = NS_NOTFOUND; 1751 if (state->mode != COMPAT_NOTOKEN && 1752 state->mode != COMPAT_NONE) { 1753 /* doing a compat lookup */ 1754 struct passwd cpw; 1755 char cbuf[GETPW_R_SIZE_MAX]; 1756 1757 switch (state->mode) { 1758 1759 case COMPAT_FULL: 1760 /* get next user */ 1761 rv = _passwdcompat_grscan(&cpw, 1762 cbuf, sizeof(cbuf), 1763 _PW_KEYBYNUM, NULL, 0); 1764 if (rv != NS_SUCCESS) 1765 state->mode = COMPAT_NONE; 1766 break; 1767 1768 case COMPAT_NETGROUP: 1769 /* XXXREENTRANT: getnetgrent is not thread safe */ 1770 /* get next user from netgroup */ 1771 r = getnetgrent(&host, &user, &dom); 1772 if (r == 0) { /* end of group */ 1773 endnetgrent(); 1774 state->mode = COMPAT_NONE; 1775 break; 1776 } 1777 if (!user || !*user) 1778 break; 1779 rv = _passwdcompat_grscan(&cpw, 1780 cbuf, sizeof(cbuf), 1781 _PW_KEYBYNAME, user, 0); 1782 break; 1783 1784 case COMPAT_USER: 1785 /* get specific user */ 1786 if (state->user == NULL) { 1787 state->mode = COMPAT_NONE; 1788 break; 1789 } 1790 rv = _passwdcompat_grscan(&cpw, 1791 cbuf, sizeof(cbuf), 1792 _PW_KEYBYNAME, state->user, 0); 1793 free(state->user); 1794 state->user = NULL; 1795 state->mode = COMPAT_NONE; 1796 break; 1797 1798 case COMPAT_NOTOKEN: 1799 case COMPAT_NONE: 1800 abort(); 1801 1802 } 1803 if (rv != NS_SUCCESS) /* if not matched, next loop */ 1804 continue; 1805 1806 /* copy cpw to pw, applying prototype */ 1807 if (! _pw_copy(&cpw, pw, buffer, buflen, 1808 &state->proto, state->protoflags)) { 1809 rv = NS_UNAVAIL; 1810 break; 1811 } 1812 1813 if (_compat_is_excluded(state, pw->pw_name)) 1814 continue; /* excluded; next loop */ 1815 1816 if ((search == _PW_KEYBYNAME 1817 && strcmp(pw->pw_name, name) != 0) 1818 || (search == _PW_KEYBYUID && pw->pw_uid != uid)) { 1819 continue; /* not specific; next loop */ 1820 } 1821 1822 break; /* exit loop if found */ 1823 } else { /* not a compat line */ 1824 state->proto.pw_name = NULL; 1825 /* clear prototype */ 1826 } 1827 1828 if (state->mode == COMPAT_NOTOKEN) { 1829 /* no compat token; do direct lookup */ 1830 switch (search) { 1831 case _PW_KEYBYNUM: 1832 if (state->keynum == -1) /* no more records */ 1833 return NS_NOTFOUND; 1834 state->keynum++; 1835 from = &state->keynum; 1836 fromlen = sizeof(state->keynum); 1837 break; 1838 case _PW_KEYBYNAME: 1839 from = name; 1840 fromlen = strlen(name); 1841 break; 1842 case _PW_KEYBYUID: 1843 from = &uid; 1844 fromlen = sizeof(uid); 1845 break; 1846 default: 1847 abort(); 1848 } 1849 buffer[0] = search; 1850 } else { 1851 /* compat token; do line by line */ 1852 if (state->keynum == -1) /* no more records */ 1853 return NS_NOTFOUND; 1854 state->keynum++; 1855 from = &state->keynum; 1856 fromlen = sizeof(state->keynum); 1857 buffer[0] = _PW_KEYBYNUM; 1858 } 1859 1860 if (buflen <= fromlen) { /* buffer too small */ 1861 *retval = ERANGE; 1862 return NS_UNAVAIL; 1863 } 1864 memmove(buffer + 1, from, fromlen); /* setup key */ 1865 key.size = fromlen + 1; 1866 key.data = (u_char *)buffer; 1867 1868 rv = _pw_getkey(state->db, &key, pw, buffer, buflen, &pwflags); 1869 if (rv != NS_SUCCESS) /* stop on error */ 1870 break; 1871 1872 if (state->mode == COMPAT_NOTOKEN) 1873 break; /* stop if no compat token */ 1874 1875 if (pw->pw_name[0] == '+') { 1876 /* compat inclusion */ 1877 switch(pw->pw_name[1]) { 1878 case '\0': /* `+' */ 1879 state->mode = COMPAT_FULL; 1880 /* reset passwd_compat search */ 1881 /* XXXREENTRANT: setpassent is not thread safe ? */ 1882 (void) _passwdcompat_setpassent(0); 1883 break; 1884 case '@': /* `+@netgroup' */ 1885 state->mode = COMPAT_NETGROUP; 1886 /* reset netgroup search */ 1887 /* XXXREENTRANT: setnetgrent is not thread safe */ 1888 setnetgrent(pw->pw_name + 2); 1889 break; 1890 default: /* `+name' */ 1891 state->mode = COMPAT_USER; 1892 if (state->user) 1893 free(state->user); 1894 state->user = strdup(pw->pw_name + 1); 1895 break; 1896 } 1897 /* save the prototype */ 1898 state->protoflags = pwflags; 1899 if (! _pw_copy(pw, &state->proto, state->protobuf, 1900 sizeof(state->protobuf), NULL, 0)) { 1901 rv = NS_UNAVAIL; 1902 break; 1903 } 1904 continue; /* loop again after inclusion */ 1905 } else if (pw->pw_name[0] == '-') { 1906 /* compat exclusion */ 1907 rv = NS_SUCCESS; 1908 switch(pw->pw_name[1]) { 1909 case '\0': /* `-' */ 1910 break; 1911 case '@': /* `-@netgroup' */ 1912 /* XXXREENTRANT: {set,get,end}netgrent is not thread safe */ 1913 setnetgrent(pw->pw_name + 2); 1914 while (getnetgrent(&host, &user, &dom)) { 1915 if (!user || !*user) 1916 continue; 1917 if (! _compat_add_exclude(state,user)) { 1918 rv = NS_UNAVAIL; 1919 break; 1920 } 1921 } 1922 endnetgrent(); 1923 break; 1924 default: /* `-name' */ 1925 if (! _compat_add_exclude(state, 1926 pw->pw_name + 1)) { 1927 rv = NS_UNAVAIL; 1928 } 1929 break; 1930 } 1931 if (rv != NS_SUCCESS) /* exclusion failure */ 1932 break; 1933 continue; /* loop again after exclusion */ 1934 } 1935 if (search == _PW_KEYBYNUM || 1936 (search == _PW_KEYBYUID && pw->pw_uid == uid) || 1937 (search == _PW_KEYBYNAME && strcmp(pw->pw_name, name) == 0)) 1938 break; /* token mode match found */ 1939 } 1940 1941 if (rv == NS_NOTFOUND && 1942 (search == _PW_KEYBYNUM || state->mode != COMPAT_NOTOKEN)) 1943 state->keynum = -1; /* flag `no more records' */ 1944 1945 if (rv == NS_SUCCESS) { 1946 if ((search == _PW_KEYBYNAME && strcmp(pw->pw_name, name) != 0) 1947 || (search == _PW_KEYBYUID && pw->pw_uid != uid)) 1948 rv = NS_NOTFOUND; 1949 } 1950 1951 if (rv != NS_SUCCESS) 1952 *retval = errno; 1953 return rv; 1954 } 1955 1956 /*ARGSUSED*/ 1957 static int 1958 _compat_setpwent(void *nsrv, void *nscb, va_list ap) 1959 { 1960 1961 /* force passwd_compat setpwent() */ 1962 (void) _passwdcompat_setpassent(0); 1963 1964 /* reset state, keep db open */ 1965 _compat_state.stayopen = 0; 1966 return _compat_start(&_compat_state); 1967 } 1968 1969 /*ARGSUSED*/ 1970 static int 1971 _compat_setpassent(void *nsrv, void *nscb, va_list ap) 1972 { 1973 int *retval = va_arg(ap, int *); 1974 int stayopen = va_arg(ap, int); 1975 1976 int rv; 1977 1978 /* force passwd_compat setpassent() */ 1979 (void) _passwdcompat_setpassent(stayopen); 1980 1981 _compat_state.stayopen = stayopen; 1982 rv = _compat_start(&_compat_state); 1983 *retval = (rv == NS_SUCCESS); 1984 return rv; 1985 } 1986 1987 /*ARGSUSED*/ 1988 static int 1989 _compat_endpwent(void *nsrv, void *nscb, va_list ap) 1990 { 1991 1992 /* force passwd_compat endpwent() */ 1993 (void) _passwdcompat_endpwent(); 1994 1995 /* reset state, close db */ 1996 _compat_state.stayopen = 0; 1997 return _compat_end(&_compat_state); 1998 } 1999 2000 2001 /*ARGSUSED*/ 2002 static int 2003 _compat_getpwent(void *nsrv, void *nscb, va_list ap) 2004 { 2005 struct passwd **retval = va_arg(ap, struct passwd **); 2006 2007 int rv, rerror; 2008 2009 _DIAGASSERT(retval != NULL); 2010 2011 *retval = NULL; 2012 rv = _compat_pwscan(&rerror, &_compat_passwd, 2013 _compat_passwdbuf, sizeof(_compat_passwdbuf), 2014 &_compat_state, _PW_KEYBYNUM, NULL, 0); 2015 if (rv == NS_SUCCESS) 2016 *retval = &_compat_passwd; 2017 return rv; 2018 } 2019 2020 /*ARGSUSED*/ 2021 static int 2022 _compat_getpwnam(void *nsrv, void *nscb, va_list ap) 2023 { 2024 struct passwd **retval = va_arg(ap, struct passwd **); 2025 const char *name = va_arg(ap, const char *); 2026 2027 int rv, rerror; 2028 2029 _DIAGASSERT(retval != NULL); 2030 2031 *retval = NULL; 2032 rv = _compat_start(&_compat_state); 2033 if (rv != NS_SUCCESS) 2034 return rv; 2035 rv = _compat_pwscan(&rerror, &_compat_passwd, 2036 _compat_passwdbuf, sizeof(_compat_passwdbuf), 2037 &_compat_state, _PW_KEYBYNAME, name, 0); 2038 if (!_compat_state.stayopen) 2039 _compat_end(&_compat_state); 2040 if (rv == NS_SUCCESS) 2041 *retval = &_compat_passwd; 2042 return rv; 2043 } 2044 2045 /*ARGSUSED*/ 2046 static int 2047 _compat_getpwnam_r(void *nsrv, void *nscb, va_list ap) 2048 { 2049 int *retval = va_arg(ap, int *); 2050 const char *name = va_arg(ap, const char *); 2051 struct passwd *pw = va_arg(ap, struct passwd *); 2052 char *buffer = va_arg(ap, char *); 2053 size_t buflen = va_arg(ap, size_t); 2054 struct passwd **result = va_arg(ap, struct passwd **); 2055 2056 struct compat_state state; 2057 int rv; 2058 2059 _DIAGASSERT(retval != NULL); 2060 _DIAGASSERT(pw != NULL); 2061 _DIAGASSERT(buffer != NULL); 2062 _DIAGASSERT(result != NULL); 2063 2064 *result = NULL; 2065 memset(&state, 0, sizeof(state)); 2066 rv = _compat_pwscan(retval, pw, buffer, buflen, &state, 2067 _PW_KEYBYNAME, name, 0); 2068 _compat_end(&state); 2069 if (rv == NS_SUCCESS) 2070 *result = pw; 2071 return rv; 2072 } 2073 2074 /*ARGSUSED*/ 2075 static int 2076 _compat_getpwuid(void *nsrv, void *nscb, va_list ap) 2077 { 2078 struct passwd **retval = va_arg(ap, struct passwd **); 2079 uid_t uid = va_arg(ap, uid_t); 2080 2081 int rv, rerror; 2082 2083 _DIAGASSERT(retval != NULL); 2084 2085 *retval = NULL; 2086 rv = _compat_start(&_compat_state); 2087 if (rv != NS_SUCCESS) 2088 return rv; 2089 rv = _compat_pwscan(&rerror, &_compat_passwd, 2090 _compat_passwdbuf, sizeof(_compat_passwdbuf), 2091 &_compat_state, _PW_KEYBYUID, NULL, uid); 2092 if (!_compat_state.stayopen) 2093 _compat_end(&_compat_state); 2094 if (rv == NS_SUCCESS) 2095 *retval = &_compat_passwd; 2096 return rv; 2097 } 2098 2099 /*ARGSUSED*/ 2100 static int 2101 _compat_getpwuid_r(void *nsrv, void *nscb, va_list ap) 2102 { 2103 int *retval = va_arg(ap, int *); 2104 uid_t uid = va_arg(ap, uid_t); 2105 struct passwd *pw = va_arg(ap, struct passwd *); 2106 char *buffer = va_arg(ap, char *); 2107 size_t buflen = va_arg(ap, size_t); 2108 struct passwd **result = va_arg(ap, struct passwd **); 2109 2110 struct compat_state state; 2111 int rv; 2112 2113 _DIAGASSERT(retval != NULL); 2114 _DIAGASSERT(pw != NULL); 2115 _DIAGASSERT(buffer != NULL); 2116 _DIAGASSERT(result != NULL); 2117 2118 *result = NULL; 2119 memset(&state, 0, sizeof(state)); 2120 rv = _compat_pwscan(retval, pw, buffer, buflen, &state, 2121 _PW_KEYBYUID, NULL, uid); 2122 _compat_end(&state); 2123 if (rv == NS_SUCCESS) 2124 *result = pw; 2125 return rv; 2126 } 2127 2128 #endif /* _PASSWD_COMPAT */ 2129 2130 2131 /* 2132 * public functions 2133 */ 2134 2135 struct passwd * 2136 getpwent(void) 2137 { 2138 int r; 2139 struct passwd *retval; 2140 2141 static const ns_dtab dtab[] = { 2142 NS_FILES_CB(_files_getpwent, NULL) 2143 NS_DNS_CB(_dns_getpwent, NULL) 2144 NS_NIS_CB(_nis_getpwent, NULL) 2145 NS_COMPAT_CB(_compat_getpwent, NULL) 2146 { 0 } 2147 }; 2148 2149 r = nsdispatch(NULL, dtab, NSDB_PASSWD, "getpwent", defaultcompat, 2150 &retval); 2151 return (r == NS_SUCCESS) ? retval : NULL; 2152 } 2153 2154 struct passwd * 2155 getpwnam(const char *name) 2156 { 2157 int rv; 2158 struct passwd *retval; 2159 2160 static const ns_dtab dtab[] = { 2161 NS_FILES_CB(_files_getpwnam, NULL) 2162 NS_DNS_CB(_dns_getpwnam, NULL) 2163 NS_NIS_CB(_nis_getpwnam, NULL) 2164 NS_COMPAT_CB(_compat_getpwnam, NULL) 2165 { 0 } 2166 }; 2167 2168 rv = nsdispatch(NULL, dtab, NSDB_PASSWD, "getpwnam", defaultcompat, 2169 &retval, name); 2170 return (rv == NS_SUCCESS) ? retval : NULL; 2171 } 2172 2173 int 2174 getpwnam_r(const char *name, struct passwd *pwd, char *buffer, size_t buflen, 2175 struct passwd **result) 2176 { 2177 int r, retval; 2178 2179 static const ns_dtab dtab[] = { 2180 NS_FILES_CB(_files_getpwnam_r, NULL) 2181 NS_DNS_CB(_dns_getpwnam_r, NULL) 2182 NS_NIS_CB(_nis_getpwnam_r, NULL) 2183 NS_COMPAT_CB(_compat_getpwnam_r, NULL) 2184 { 0 } 2185 }; 2186 2187 _DIAGASSERT(name != NULL); 2188 _DIAGASSERT(pwd != NULL); 2189 _DIAGASSERT(buffer != NULL); 2190 _DIAGASSERT(result != NULL); 2191 2192 *result = NULL; 2193 retval = 0; 2194 r = nsdispatch(NULL, dtab, NSDB_PASSWD, "getpwnam_r", defaultcompat, 2195 &retval, name, pwd, buffer, buflen, result); 2196 return (r == NS_SUCCESS) ? 0 : retval ? retval : ENOENT; 2197 } 2198 2199 struct passwd * 2200 getpwuid(uid_t uid) 2201 { 2202 int rv; 2203 struct passwd *retval; 2204 2205 static const ns_dtab dtab[] = { 2206 NS_FILES_CB(_files_getpwuid, NULL) 2207 NS_DNS_CB(_dns_getpwuid, NULL) 2208 NS_NIS_CB(_nis_getpwuid, NULL) 2209 NS_COMPAT_CB(_compat_getpwuid, NULL) 2210 { 0 } 2211 }; 2212 2213 rv = nsdispatch(NULL, dtab, NSDB_PASSWD, "getpwuid", defaultcompat, 2214 &retval, uid); 2215 return (rv == NS_SUCCESS) ? retval : NULL; 2216 } 2217 2218 int 2219 getpwuid_r(uid_t uid, struct passwd *pwd, char *buffer, size_t buflen, 2220 struct passwd **result) 2221 { 2222 int r, retval; 2223 2224 static const ns_dtab dtab[] = { 2225 NS_FILES_CB(_files_getpwuid_r, NULL) 2226 NS_DNS_CB(_dns_getpwuid_r, NULL) 2227 NS_NIS_CB(_nis_getpwuid_r, NULL) 2228 NS_COMPAT_CB(_compat_getpwuid_r, NULL) 2229 { 0 } 2230 }; 2231 2232 _DIAGASSERT(pwd != NULL); 2233 _DIAGASSERT(buffer != NULL); 2234 _DIAGASSERT(result != NULL); 2235 2236 *result = NULL; 2237 retval = 0; 2238 r = nsdispatch(NULL, dtab, NSDB_PASSWD, "getpwuid_r", defaultcompat, 2239 &retval, uid, pwd, buffer, buflen, result); 2240 return (r == NS_SUCCESS) ? 0 : retval ? retval : ENOENT; 2241 } 2242 2243 void 2244 endpwent(void) 2245 { 2246 static const ns_dtab dtab[] = { 2247 NS_FILES_CB(_files_endpwent, NULL) 2248 NS_DNS_CB(_dns_endpwent, NULL) 2249 NS_NIS_CB(_nis_endpwent, NULL) 2250 NS_COMPAT_CB(_compat_endpwent, NULL) 2251 { 0 } 2252 }; 2253 2254 /* force all endpwent() methods */ 2255 (void) nsdispatch(NULL, dtab, NSDB_PASSWD, "endpwent", 2256 defaultcompat_forceall); 2257 } 2258 2259 /*ARGSUSED*/ 2260 int 2261 setpassent(int stayopen) 2262 { 2263 static const ns_dtab dtab[] = { 2264 NS_FILES_CB(_files_setpassent, NULL) 2265 NS_DNS_CB(_dns_setpassent, NULL) 2266 NS_NIS_CB(_nis_setpassent, NULL) 2267 NS_COMPAT_CB(_compat_setpassent, NULL) 2268 { 0 } 2269 }; 2270 int rv, retval; 2271 2272 /* force all setpassent() methods */ 2273 rv = nsdispatch(NULL, dtab, NSDB_PASSWD, "setpassent", 2274 defaultcompat_forceall, &retval, stayopen); 2275 return (rv == NS_SUCCESS) ? retval : 0; 2276 } 2277 2278 void 2279 setpwent(void) 2280 { 2281 static const ns_dtab dtab[] = { 2282 NS_FILES_CB(_files_setpwent, NULL) 2283 NS_DNS_CB(_dns_setpwent, NULL) 2284 NS_NIS_CB(_nis_setpwent, NULL) 2285 NS_COMPAT_CB(_compat_setpwent, NULL) 2286 { 0 } 2287 }; 2288 2289 /* force all setpwent() methods */ 2290 (void) nsdispatch(NULL, dtab, NSDB_PASSWD, "setpwent", 2291 defaultcompat_forceall); 2292 } 2293
Indexes created Wed Sep 24 15:09:51 GMT 2025