getpwent.c revision 1.14
1 /* $NetBSD: getpwent.c,v 1.14 1995/07/28 05:43:01 phil Exp $ */ 2 3 /* 4 * Copyright (c) 1988, 1993 5 * The Regents of the University of California. All rights reserved. 6 * Portions Copyright (c) 1994, 1995, Jason Downs. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by the University of 19 * California, Berkeley and its contributors. 20 * 4. Neither the name of the University nor the names of its contributors 21 * may be used to endorse or promote products derived from this software 22 * without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 */ 36 37 #if defined(LIBC_SCCS) && !defined(lint) 38 #if 0 39 static char sccsid[] = "@(#)getpwent.c 8.1 (Berkeley) 6/4/93"; 40 #else 41 static char rcsid[] = "$NetBSD: getpwent.c,v 1.14 1995/07/28 05:43:01 phil Exp $"; 42 #endif 43 #endif /* LIBC_SCCS and not lint */ 44 45 #include <sys/param.h> 46 #include <fcntl.h> 47 #include <db.h> 48 #include <syslog.h> 49 #include <pwd.h> 50 #include <utmp.h> 51 #include <errno.h> 52 #include <unistd.h> 53 #include <stdlib.h> 54 #include <string.h> 55 #include <limits.h> 56 #include <netgroup.h> 57 #ifdef YP 58 #include <machine/param.h> 59 #include <stdio.h> 60 #include <rpc/rpc.h> 61 #include <rpcsvc/yp_prot.h> 62 #include <rpcsvc/ypclnt.h> 63 #endif 64 65 static struct passwd _pw_passwd; /* password structure */ 66 static DB *_pw_db; /* password database */ 67 static int _pw_keynum; /* key counter */ 68 static int _pw_stayopen; /* keep fd's open */ 69 static int _pw_flags; /* password flags */ 70 static int __hashpw __P((DBT *)); 71 static int __initdb __P((void)); 72 73 const char __yp_token[] = "__YP!"; /* Let pwd_mkdb pull this in. */ 74 75 #ifdef YP 76 enum _ypmode { YPMODE_NONE, YPMODE_FULL, YPMODE_USER, YPMODE_NETGRP }; 77 static enum _ypmode __ypmode; 78 79 static char *__ypcurrent, *__ypdomain; 80 static int __ypcurrentlen; 81 static struct passwd *__ypproto = (struct passwd *)NULL; 82 static int __ypflags; 83 static char line[1024]; 84 static long prbuf[1024 / sizeof(long)]; 85 static DB *__ypexclude = (DB *)NULL; 86 87 static int __has_yppw __P((void)); 88 static int __ypexclude_add __P((const char *)); 89 static int __ypexclude_is __P((const char *)); 90 static void __ypproto_set __P((void)); 91 92 static int 93 __ypexclude_add(name) 94 const char *name; 95 { 96 DBT key, data; 97 98 /* initialize the exclusion table if needed. */ 99 if(__ypexclude == (DB *)NULL) { 100 __ypexclude = dbopen(NULL, O_RDWR, 600, DB_HASH, NULL); 101 if(__ypexclude == (DB *)NULL) 102 return(1); 103 } 104 105 /* set up the key */ 106 key.data = (char *)name; 107 key.size = strlen(name); 108 109 /* data is nothing. */ 110 data.data = NULL; 111 data.size = 0; 112 113 /* store it */ 114 if((__ypexclude->put)(__ypexclude, &key, &data, 0) == -1) 115 return(1); 116 117 return(0); 118 } 119 120 static int 121 __ypexclude_is(name) 122 const char *name; 123 { 124 DBT key, data; 125 126 if(__ypexclude == (DB *)NULL) 127 return(0); /* nothing excluded */ 128 129 /* set up the key */ 130 key.data = (char *)name; 131 key.size = strlen(name); 132 133 if((__ypexclude->get)(__ypexclude, &key, &data, 0) == 0) 134 return(1); /* excluded */ 135 136 return(0); 137 } 138 139 static void 140 __ypproto_set() 141 { 142 register char *ptr; 143 register struct passwd *pw = &_pw_passwd; 144 145 /* make this the new prototype */ 146 ptr = (char *)prbuf; 147 148 /* first allocate the struct. */ 149 __ypproto = (struct passwd *)ptr; 150 ptr += sizeof(struct passwd); 151 152 /* name */ 153 if(pw->pw_name && (pw->pw_name)[0]) { 154 ptr = (char *)ALIGN(ptr); 155 bcopy(pw->pw_name, ptr, strlen(pw->pw_name) + 1); 156 __ypproto->pw_name = ptr; 157 ptr += (strlen(pw->pw_name) + 1); 158 } else 159 __ypproto->pw_name = (char *)NULL; 160 161 /* password */ 162 if(pw->pw_passwd && (pw->pw_passwd)[0]) { 163 ptr = (char *)ALIGN(ptr); 164 bcopy(pw->pw_passwd, ptr, strlen(pw->pw_passwd) + 1); 165 __ypproto->pw_passwd = ptr; 166 ptr += (strlen(pw->pw_passwd) + 1); 167 } else 168 __ypproto->pw_passwd = (char *)NULL; 169 170 /* uid */ 171 __ypproto->pw_uid = pw->pw_uid; 172 173 /* gid */ 174 __ypproto->pw_gid = pw->pw_gid; 175 176 /* change (ignored anyway) */ 177 __ypproto->pw_change = pw->pw_change; 178 179 /* class (ignored anyway) */ 180 __ypproto->pw_class = ""; 181 182 /* gecos */ 183 if(pw->pw_gecos && (pw->pw_gecos)[0]) { 184 ptr = (char *)ALIGN(ptr); 185 bcopy(pw->pw_gecos, ptr, strlen(pw->pw_gecos) + 1); 186 __ypproto->pw_gecos = ptr; 187 ptr += (strlen(pw->pw_gecos) + 1); 188 } else 189 __ypproto->pw_gecos = (char *)NULL; 190 191 /* dir */ 192 if(pw->pw_dir && (pw->pw_dir)[0]) { 193 ptr = (char *)ALIGN(ptr); 194 bcopy(pw->pw_dir, ptr, strlen(pw->pw_dir) + 1); 195 __ypproto->pw_dir = ptr; 196 ptr += (strlen(pw->pw_dir) + 1); 197 } else 198 __ypproto->pw_dir = (char *)NULL; 199 200 /* shell */ 201 if(pw->pw_shell && (pw->pw_shell)[0]) { 202 ptr = (char *)ALIGN(ptr); 203 bcopy(pw->pw_shell, ptr, strlen(pw->pw_shell) + 1); 204 __ypproto->pw_shell = ptr; 205 ptr += (strlen(pw->pw_shell) + 1); 206 } else 207 __ypproto->pw_shell = (char *)NULL; 208 209 /* expire (ignored anyway) */ 210 __ypproto->pw_expire = pw->pw_expire; 211 212 /* flags */ 213 __ypflags = _pw_flags; 214 } 215 216 static int 217 __ypparse(pw, s) 218 struct passwd *pw; 219 char *s; 220 { 221 char *bp, *cp; 222 223 /* since this is currently using strsep(), parse it first */ 224 bp = s; 225 pw->pw_name = strsep(&bp, ":\n"); 226 pw->pw_passwd = strsep(&bp, ":\n"); 227 if (!(cp = strsep(&bp, ":\n"))) 228 return 1; 229 pw->pw_uid = atoi(cp); 230 if (!(cp = strsep(&bp, ":\n"))) 231 return 1; 232 pw->pw_gid = atoi(cp); 233 pw->pw_change = 0; 234 pw->pw_class = ""; 235 pw->pw_gecos = strsep(&bp, ":\n"); 236 pw->pw_dir = strsep(&bp, ":\n"); 237 pw->pw_shell = strsep(&bp, ":\n"); 238 pw->pw_expire = 0; 239 240 /* now let the prototype override, if set. */ 241 if(__ypproto != (struct passwd *)NULL) { 242 #ifdef YP_OVERRIDE_PASSWD 243 if(__ypproto->pw_passwd != (char *)NULL) 244 pw->pw_passwd = __ypproto->pw_passwd; 245 #endif 246 if(!(__ypflags & _PASSWORD_NOUID)) 247 pw->pw_uid = __ypproto->pw_uid; 248 if(!(__ypflags & _PASSWORD_NOGID)) 249 pw->pw_gid = __ypproto->pw_gid; 250 if(__ypproto->pw_gecos != (char *)NULL) 251 pw->pw_gecos = __ypproto->pw_gecos; 252 if(__ypproto->pw_dir != (char *)NULL) 253 pw->pw_dir = __ypproto->pw_dir; 254 if(__ypproto->pw_shell != (char *)NULL) 255 pw->pw_shell = __ypproto->pw_shell; 256 } 257 return 0; 258 } 259 #endif 260 261 struct passwd * 262 getpwent() 263 { 264 DBT key; 265 char bf[sizeof(_pw_keynum) + 1]; 266 #ifdef YP 267 char *cp; 268 static char *name = (char *)NULL; 269 const char *user, *host, *dom; 270 int has_yppw; 271 #endif 272 273 if (!_pw_db && !__initdb()) 274 return((struct passwd *)NULL); 275 276 #ifdef YP 277 has_yppw = __has_yppw(); 278 279 again: 280 if(has_yppw && (__ypmode != YPMODE_NONE)) { 281 char *key, *data; 282 int keylen, datalen; 283 int r, s; 284 285 if(!__ypdomain) { 286 if( _yp_check(&__ypdomain) == 0) { 287 __ypmode = YPMODE_NONE; 288 goto again; 289 } 290 } 291 switch(__ypmode) { 292 case YPMODE_FULL: 293 if(__ypcurrent) { 294 r = yp_next(__ypdomain, "passwd.byname", 295 __ypcurrent, __ypcurrentlen, 296 &key, &keylen, &data, &datalen); 297 free(__ypcurrent); 298 if(r != 0) { 299 __ypcurrent = NULL; 300 __ypmode = YPMODE_NONE; 301 if(data) 302 free(data); 303 data = NULL; 304 goto again; 305 } 306 __ypcurrent = key; 307 __ypcurrentlen = keylen; 308 bcopy(data, line, datalen); 309 free(data); 310 data = NULL; 311 } else { 312 r = yp_first(__ypdomain, "passwd.byname", 313 &__ypcurrent, &__ypcurrentlen, 314 &data, &datalen); 315 if(r != 0) { 316 __ypmode = YPMODE_NONE; 317 if(data) 318 free(data); 319 goto again; 320 } 321 bcopy(data, line, datalen); 322 free(data); 323 data = NULL; 324 } 325 break; 326 case YPMODE_NETGRP: 327 s = getnetgrent(&host, &user, &dom); 328 if(s == 0) { /* end of group */ 329 endnetgrent(); 330 __ypmode = YPMODE_NONE; 331 goto again; 332 } 333 if(user && *user) { 334 r = yp_match(__ypdomain, "passwd.byname", 335 user, strlen(user), 336 &data, &datalen); 337 } else 338 goto again; 339 if(r != 0) { 340 /* 341 * if the netgroup is invalid, keep looking 342 * as there may be valid users later on. 343 */ 344 if(data) 345 free(data); 346 goto again; 347 } 348 bcopy(data, line, datalen); 349 free(data); 350 data = (char *)NULL; 351 break; 352 case YPMODE_USER: 353 if(name != (char *)NULL) { 354 r = yp_match(__ypdomain, "passwd.byname", 355 name, strlen(name), 356 &data, &datalen); 357 __ypmode = YPMODE_NONE; 358 free(name); 359 name = (char *)NULL; 360 if(r != 0) { 361 if(data) 362 free(data); 363 goto again; 364 } 365 bcopy(data, line, datalen); 366 free(data); 367 data = (char *)NULL; 368 } else { /* XXX */ 369 __ypmode = YPMODE_NONE; 370 goto again; 371 } 372 break; 373 } 374 375 line[datalen] = '\0'; 376 if (__ypparse(&_pw_passwd, line)) 377 goto again; 378 return &_pw_passwd; 379 } 380 #endif 381 382 ++_pw_keynum; 383 bf[0] = _PW_KEYBYNUM; 384 bcopy((char *)&_pw_keynum, bf + 1, sizeof(_pw_keynum)); 385 key.data = (u_char *)bf; 386 key.size = sizeof(_pw_keynum) + 1; 387 if(__hashpw(&key)) { 388 #ifdef YP 389 /* if we don't have YP at all, don't bother. */ 390 if(has_yppw) { 391 if(_pw_passwd.pw_name[0] == '+') { 392 /* set the mode */ 393 switch(_pw_passwd.pw_name[1]) { 394 case '\0': 395 __ypmode = YPMODE_FULL; 396 break; 397 case '@': 398 __ypmode = YPMODE_NETGRP; 399 setnetgrent(_pw_passwd.pw_name + 2); 400 break; 401 default: 402 __ypmode = YPMODE_USER; 403 name = strdup(_pw_passwd.pw_name + 1); 404 break; 405 } 406 407 /* save the prototype */ 408 __ypproto_set(); 409 goto again; 410 } else if(_pw_passwd.pw_name[0] == '-') { 411 /* an attempted exclusion */ 412 switch(_pw_passwd.pw_name[1]) { 413 case '\0': 414 break; 415 case '@': 416 setnetgrent(_pw_passwd.pw_name + 2); 417 while(getnetgrent(&host, &user, &dom)) { 418 if(user && *user) 419 __ypexclude_add(user); 420 } 421 endnetgrent(); 422 break; 423 default: 424 __ypexclude_add(_pw_passwd.pw_name + 1); 425 break; 426 } 427 goto again; 428 } 429 } 430 #endif 431 return &_pw_passwd; 432 } 433 return (struct passwd *)NULL; 434 } 435 436 #ifdef YP 437 438 /* 439 * See if the YP token is in the database. Only works if pwd_mkdb knows 440 * about the token. 441 */ 442 static int 443 __has_yppw() 444 { 445 DBT key, data; 446 DBT pkey, pdata; 447 int len; 448 char bf[UT_NAMESIZE]; 449 450 key.data = (u_char *)__yp_token; 451 key.size = strlen(__yp_token); 452 453 /* Pre-token database support. */ 454 bf[0] = _PW_KEYBYNAME; 455 len = strlen("+"); 456 bcopy("+", bf + 1, MIN(len, UT_NAMESIZE)); 457 pkey.data = (u_char *)bf; 458 pkey.size = len + 1; 459 460 if ((_pw_db->get)(_pw_db, &key, &data, 0) 461 && (_pw_db->get)(_pw_db, &pkey, &pdata, 0)) 462 return(0); /* No YP. */ 463 return(1); 464 } 465 #endif 466 467 struct passwd * 468 getpwnam(name) 469 const char *name; 470 { 471 DBT key; 472 int len, rval; 473 char bf[UT_NAMESIZE + 1]; 474 475 if (!_pw_db && !__initdb()) 476 return((struct passwd *)NULL); 477 478 #ifdef YP 479 /* 480 * If YP is active, we must sequence through the passwd file 481 * in sequence. 482 */ 483 if (__has_yppw()) { 484 int r; 485 int s = -1; 486 const char *host, *user, *dom; 487 488 for(_pw_keynum=1; _pw_keynum; _pw_keynum++) { 489 bf[0] = _PW_KEYBYNUM; 490 bcopy((char *)&_pw_keynum, bf + 1, sizeof(_pw_keynum)); 491 key.data = (u_char *)bf; 492 key.size = sizeof(_pw_keynum) + 1; 493 if(__hashpw(&key) == 0) 494 break; 495 switch(_pw_passwd.pw_name[0]) { 496 case '+': 497 if(!__ypdomain) { 498 if(_yp_check(&__ypdomain) == 0) { 499 continue; 500 } 501 } 502 /* save the prototype */ 503 __ypproto_set(); 504 505 switch(_pw_passwd.pw_name[1]) { 506 case '\0': 507 if(__ypcurrent) { 508 free(__ypcurrent); 509 __ypcurrent = NULL; 510 } 511 r = yp_match(__ypdomain, 512 "passwd.byname", 513 name, strlen(name), 514 &__ypcurrent, &__ypcurrentlen); 515 if(r != 0) { 516 if(__ypcurrent) 517 free(__ypcurrent); 518 __ypcurrent = NULL; 519 continue; 520 } 521 break; 522 case '@': 523 pwnam_netgrp: 524 if(__ypcurrent) { 525 free(__ypcurrent); 526 __ypcurrent = NULL; 527 } 528 if(s == -1) /* first time */ 529 setnetgrent(_pw_passwd.pw_name + 2); 530 s = getnetgrent(&host, &user, &dom); 531 if(s == 0) { /* end of group */ 532 endnetgrent(); 533 s = -1; 534 continue; 535 } else { 536 if(user && *user) { 537 r = yp_match(__ypdomain, 538 "passwd.byname", 539 user, strlen(user), 540 &__ypcurrent, 541 &__ypcurrentlen); 542 } else 543 goto pwnam_netgrp; 544 if(r != 0) { 545 if(__ypcurrent) 546 free(__ypcurrent); 547 __ypcurrent = NULL; 548 /* 549 * just because this 550 * user is bad, doesn't 551 * mean they all are. 552 */ 553 goto pwnam_netgrp; 554 } 555 } 556 break; 557 default: 558 if(__ypcurrent) { 559 free(__ypcurrent); 560 __ypcurrent = NULL; 561 } 562 user = _pw_passwd.pw_name + 1; 563 r = yp_match(__ypdomain, 564 "passwd.byname", 565 user, strlen(user), 566 &__ypcurrent, 567 &__ypcurrentlen); 568 if(r != 0) { 569 if(__ypcurrent) 570 free(__ypcurrent); 571 __ypcurrent = NULL; 572 continue; 573 } 574 break; 575 } 576 bcopy(__ypcurrent, line, __ypcurrentlen); 577 line[__ypcurrentlen] = '\0'; 578 if(__ypparse(&_pw_passwd, line) 579 || __ypexclude_is(_pw_passwd.pw_name)) { 580 if(s == 1) /* inside netgrp */ 581 goto pwnam_netgrp; 582 continue; 583 } 584 break; 585 case '-': 586 /* attempted exclusion */ 587 switch(_pw_passwd.pw_name[1]) { 588 case '\0': 589 break; 590 case '@': 591 setnetgrent(_pw_passwd.pw_name + 2); 592 while(getnetgrent(&host, &user, &dom)) { 593 if(user && *user) 594 __ypexclude_add(user); 595 } 596 endnetgrent(); 597 break; 598 default: 599 __ypexclude_add(_pw_passwd.pw_name + 1); 600 break; 601 } 602 break; 603 604 continue; 605 } 606 if(strcmp(_pw_passwd.pw_name, name) == 0) { 607 if (!_pw_stayopen) { 608 (void)(_pw_db->close)(_pw_db); 609 _pw_db = (DB *)NULL; 610 } 611 if(__ypexclude != (DB *)NULL) { 612 (void)(__ypexclude->close)(__ypexclude); 613 __ypexclude = (DB *)NULL; 614 } 615 __ypproto = (struct passwd *)NULL; 616 return &_pw_passwd; 617 } 618 if(s == 1) /* inside netgrp */ 619 goto pwnam_netgrp; 620 continue; 621 } 622 if (!_pw_stayopen) { 623 (void)(_pw_db->close)(_pw_db); 624 _pw_db = (DB *)NULL; 625 } 626 if(__ypexclude != (DB *)NULL) { 627 (void)(__ypexclude->close)(__ypexclude); 628 __ypexclude = (DB *)NULL; 629 } 630 __ypproto = (struct passwd *)NULL; 631 return (struct passwd *)NULL; 632 } 633 #endif /* YP */ 634 635 bf[0] = _PW_KEYBYNAME; 636 len = strlen(name); 637 bcopy(name, bf + 1, MIN(len, UT_NAMESIZE)); 638 key.data = (u_char *)bf; 639 key.size = len + 1; 640 rval = __hashpw(&key); 641 642 if (!_pw_stayopen) { 643 (void)(_pw_db->close)(_pw_db); 644 _pw_db = (DB *)NULL; 645 } 646 return(rval ? &_pw_passwd : (struct passwd *)NULL); 647 } 648 649 struct passwd * 650 #ifdef __STDC__ 651 getpwuid(uid_t uid) 652 #else 653 getpwuid(uid) 654 int uid; 655 #endif 656 { 657 DBT key; 658 char bf[sizeof(_pw_keynum) + 1]; 659 int keyuid, rval; 660 661 if (!_pw_db && !__initdb()) 662 return((struct passwd *)NULL); 663 664 #ifdef YP 665 /* 666 * If YP is active, we must sequence through the passwd file 667 * in sequence. 668 */ 669 if (__has_yppw()) { 670 char uidbuf[20]; 671 int r; 672 int s = -1; 673 const char *host, *user, *dom; 674 675 sprintf(uidbuf, "%d", uid); 676 for(_pw_keynum=1; _pw_keynum; _pw_keynum++) { 677 bf[0] = _PW_KEYBYNUM; 678 bcopy((char *)&_pw_keynum, bf + 1, sizeof(_pw_keynum)); 679 key.data = (u_char *)bf; 680 key.size = sizeof(_pw_keynum) + 1; 681 if(__hashpw(&key) == 0) 682 break; 683 switch(_pw_passwd.pw_name[0]) { 684 case '+': 685 if(!__ypdomain) { 686 if(_yp_check(&__ypdomain) == 0) { 687 continue; 688 } 689 } 690 /* save the prototype */ 691 __ypproto_set(); 692 693 switch(_pw_passwd.pw_name[1]) { 694 case '\0': 695 if(__ypcurrent) { 696 free(__ypcurrent); 697 __ypcurrent = NULL; 698 } 699 r = yp_match(__ypdomain, "passwd.byuid", 700 uidbuf, strlen(uidbuf), 701 &__ypcurrent, &__ypcurrentlen); 702 if(r != 0) { 703 if(__ypcurrent) 704 free(__ypcurrent); 705 __ypcurrent = NULL; 706 continue; 707 } 708 break; 709 case '@': 710 pwuid_netgrp: 711 if(__ypcurrent) { 712 free(__ypcurrent); 713 __ypcurrent = NULL; 714 } 715 if(s == -1) /* first time */ 716 setnetgrent(_pw_passwd.pw_name + 2); 717 s = getnetgrent(&host, &user, &dom); 718 if(s == 0) { /* end of group */ 719 endnetgrent(); 720 s = -1; 721 continue; 722 } else { 723 if(user && *user) { 724 r = yp_match(__ypdomain, 725 "passwd.byname", 726 user, strlen(user), 727 &__ypcurrent, 728 &__ypcurrentlen); 729 } else 730 goto pwuid_netgrp; 731 if(r != 0) { 732 if(__ypcurrent) 733 free(__ypcurrent); 734 __ypcurrent = NULL; 735 /* 736 * just because this 737 * user is bad, doesn't 738 * mean they all are. 739 */ 740 goto pwuid_netgrp; 741 } 742 } 743 break; 744 default: 745 if(__ypcurrent) { 746 free(__ypcurrent); 747 __ypcurrent = NULL; 748 } 749 user = _pw_passwd.pw_name + 1; 750 r = yp_match(__ypdomain, 751 "passwd.byname", 752 user, strlen(user), 753 &__ypcurrent, 754 &__ypcurrentlen); 755 if(r != 0) { 756 if(__ypcurrent) 757 free(__ypcurrent); 758 __ypcurrent = NULL; 759 continue; 760 } 761 break; 762 } 763 bcopy(__ypcurrent, line, __ypcurrentlen); 764 line[__ypcurrentlen] = '\0'; 765 if(__ypparse(&_pw_passwd, line) 766 || __ypexclude_is(_pw_passwd.pw_name)) { 767 if(s == 1) /* inside netgroup */ 768 goto pwuid_netgrp; 769 continue; 770 } 771 break; 772 case '-': 773 /* attempted exclusion */ 774 switch(_pw_passwd.pw_name[1]) { 775 case '\0': 776 break; 777 case '@': 778 setnetgrent(_pw_passwd.pw_name + 2); 779 while(getnetgrent(&host, &user, &dom)) { 780 if(user && *user) 781 __ypexclude_add(user); 782 } 783 endnetgrent(); 784 break; 785 default: 786 __ypexclude_add(_pw_passwd.pw_name + 1); 787 break; 788 } 789 break; 790 791 continue; 792 } 793 if( _pw_passwd.pw_uid == uid) { 794 if (!_pw_stayopen) { 795 (void)(_pw_db->close)(_pw_db); 796 _pw_db = (DB *)NULL; 797 } 798 if (__ypexclude != (DB *)NULL) { 799 (void)(__ypexclude->close)(__ypexclude); 800 __ypexclude = (DB *)NULL; 801 } 802 __ypproto = NULL; 803 return &_pw_passwd; 804 } 805 if(s == 1) /* inside netgroup */ 806 goto pwuid_netgrp; 807 continue; 808 } 809 if (!_pw_stayopen) { 810 (void)(_pw_db->close)(_pw_db); 811 _pw_db = (DB *)NULL; 812 } 813 if(__ypexclude != (DB *)NULL) { 814 (void)(__ypexclude->close)(__ypexclude); 815 __ypexclude = (DB *)NULL; 816 } 817 __ypproto = (struct passwd *)NULL; 818 return (struct passwd *)NULL; 819 } 820 #endif /* YP */ 821 822 bf[0] = _PW_KEYBYUID; 823 keyuid = uid; 824 bcopy(&keyuid, bf + 1, sizeof(keyuid)); 825 key.data = (u_char *)bf; 826 key.size = sizeof(keyuid) + 1; 827 rval = __hashpw(&key); 828 829 if (!_pw_stayopen) { 830 (void)(_pw_db->close)(_pw_db); 831 _pw_db = (DB *)NULL; 832 } 833 return(rval ? &_pw_passwd : (struct passwd *)NULL); 834 } 835 836 int 837 setpassent(stayopen) 838 int stayopen; 839 { 840 _pw_keynum = 0; 841 _pw_stayopen = stayopen; 842 #ifdef YP 843 __ypmode = YPMODE_NONE; 844 if(__ypcurrent) 845 free(__ypcurrent); 846 __ypcurrent = NULL; 847 if(__ypexclude != (DB *)NULL) { 848 (void)(__ypexclude->close)(__ypexclude); 849 __ypexclude = (DB *)NULL; 850 } 851 __ypproto = (struct passwd *)NULL; 852 #endif 853 return(1); 854 } 855 856 void 857 setpwent() 858 { 859 (void) setpassent(0); 860 } 861 862 void 863 endpwent() 864 { 865 _pw_keynum = 0; 866 if (_pw_db) { 867 (void)(_pw_db->close)(_pw_db); 868 _pw_db = (DB *)NULL; 869 } 870 #ifdef YP 871 __ypmode = YPMODE_NONE; 872 if(__ypcurrent) 873 free(__ypcurrent); 874 __ypcurrent = NULL; 875 if(__ypexclude != (DB *)NULL) { 876 (void)(__ypexclude->close)(__ypexclude); 877 __ypexclude = (DB *)NULL; 878 } 879 __ypproto = (struct passwd *)NULL; 880 #endif 881 } 882 883 static int 884 __initdb() 885 { 886 static int warned; 887 char *p; 888 889 #ifdef YP 890 __ypmode = YPMODE_NONE; 891 #endif 892 p = (geteuid()) ? _PATH_MP_DB : _PATH_SMP_DB; 893 _pw_db = dbopen(p, O_RDONLY, 0, DB_HASH, NULL); 894 if (_pw_db) 895 return(1); 896 if (!warned) 897 syslog(LOG_ERR, "%s: %m", p); 898 warned = 1; 899 return(0); 900 } 901 902 static int 903 __hashpw(key) 904 DBT *key; 905 { 906 register char *p, *t; 907 static u_int max; 908 static char *line; 909 DBT data; 910 911 if ((_pw_db->get)(_pw_db, key, &data, 0)) 912 return(0); 913 p = (char *)data.data; 914 if (data.size > max && !(line = realloc(line, (max += 1024)))) 915 return(0); 916 917 t = line; 918 #define EXPAND(e) e = t; while ((*t++ = *p++)); 919 EXPAND(_pw_passwd.pw_name); 920 EXPAND(_pw_passwd.pw_passwd); 921 bcopy(p, (char *)&_pw_passwd.pw_uid, sizeof(int)); 922 p += sizeof(int); 923 bcopy(p, (char *)&_pw_passwd.pw_gid, sizeof(int)); 924 p += sizeof(int); 925 bcopy(p, (char *)&_pw_passwd.pw_change, sizeof(time_t)); 926 p += sizeof(time_t); 927 EXPAND(_pw_passwd.pw_class); 928 EXPAND(_pw_passwd.pw_gecos); 929 EXPAND(_pw_passwd.pw_dir); 930 EXPAND(_pw_passwd.pw_shell); 931 bcopy(p, (char *)&_pw_passwd.pw_expire, sizeof(time_t)); 932 p += sizeof(time_t); 933 934 /* See if there's any data left. If so, read in flags. */ 935 if (data.size > (p - (char *)data.data)) { 936 bcopy(p, (char *)&_pw_flags, sizeof(int)); 937 p += sizeof(int); 938 } else 939 _pw_flags = _PASSWORD_NOUID|_PASSWORD_NOGID; /* default */ 940 941 return(1); 942 } 943
Indexes created Tue Sep 23 02:09:52 GMT 2025