1 /* 2 * Copyright 1997 Sun Microsystems, Inc. All rights reserved. 3 * Use is subject to license terms. 4 */ 5 6 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 7 /* All Rights Reserved */ 8 9 /* 10 * Copyright (c) 1980 Regents of the University of California. 11 * All rights reserved. The Berkeley software License Agreement 12 * specifies the terms and conditions for redistribution. 13 */ 14 15 #pragma ident "%Z%%M% %I% %E% SMI" 16 17 /* 18 * ls 19 * 20 * 4.2bsd version for symbolic links, variable length 21 * directory entries, block size in the inode, etc. 22 */ 23 24 #include <stdio.h> 25 #include <stdlib.h> 26 #include <unistd.h> 27 #include <string.h> 28 #include <stddef.h> 29 #include <dirent.h> 30 #include <ctype.h> 31 #include <time.h> 32 #include <limits.h> 33 #include <locale.h> 34 #include <errno.h> 35 #include <sys/types.h> 36 #include <sys/param.h> 37 #include <sys/stat.h> 38 #include <sys/termios.h> 39 #include <sys/mkdev.h> 40 #include <sys/acl.h> 41 42 #define dbtokb(nb) ((nb) / (1024 / DEV_BSIZE)) 43 44 struct afile { 45 char ftype; /* file type, e.g. 'd', 'c', 'f' */ 46 ino_t fnum; /* inode number of file */ 47 short fflags; /* mode&~S_IFMT, perhaps ISARG */ 48 nlink_t fnl; /* number of links */ 49 uid_t fuid; /* owner id */ 50 gid_t fgid; /* group id */ 51 off_t fsize; /* file size */ 52 blkcnt_t fblks; /* number of blocks used */ 53 time_t fmtime; /* time (modify or access or create) */ 54 char *fname; /* file name */ 55 char *flinkto; /* symbolic link value */ 56 char acl; /* acl access flag */ 57 }; 58 59 #define ISARG 0x8000 /* extra ``mode'' */ 60 61 static struct subdirs { 62 char *sd_name; 63 struct subdirs *sd_next; 64 } *subdirs; 65 66 static int aflg, dflg, gflg, lflg, sflg, tflg, uflg, iflg, fflg, cflg; 67 static int rflg = 1; 68 static int qflg, Aflg, Cflg, Fflg, Lflg, Rflg; 69 70 static int usetabs; 71 72 static time_t now, sixmonthsago, onehourfromnow; 73 74 static char *dotp = "."; 75 76 static struct winsize win; 77 static int twidth; 78 79 static struct afile *gstat(struct afile *, char *, int, off_t *); 80 static int fcmp(const void *, const void *); 81 static char *cat(char *, char *); 82 static char *savestr(char *); 83 static char *fmtentry(struct afile *); 84 static char *getname(), *getgroup(); 85 static void formatd(char *, int); 86 static void formatf(struct afile *, struct afile *); 87 static off_t getdir(char *, struct afile **, struct afile **); 88 89 int 90 main(int argc, char **argv) 91 { 92 int i; 93 struct afile *fp0, *fplast; 94 register struct afile *fp; 95 struct termios trbuf; 96 97 argc--, argv++; 98 if (getuid() == 0) 99 Aflg++; 100 (void) time(&now); 101 sixmonthsago = now - 6L*30L*24L*60L*60L; 102 onehourfromnow = now + 60L*60L; 103 now += 60; 104 twidth = 80; 105 if (isatty(1)) { 106 qflg = Cflg = 1; 107 (void) ioctl(1, TCGETS, &trbuf); 108 if (ioctl(1, TIOCGWINSZ, &win) != -1) 109 twidth = (win.ws_col == 0 ? 80 : win.ws_col); 110 if ((trbuf.c_oflag & TABDLY) != TAB3) 111 usetabs = 1; 112 } else 113 usetabs = 1; 114 115 (void) setlocale(LC_ALL, ""); /* set local environment */ 116 117 while (argc > 0 && **argv == '-') { 118 (*argv)++; 119 while (**argv) { 120 switch (*(*argv)++) { 121 case 'C': 122 Cflg = 1; break; 123 case 'q': 124 qflg = 1; break; 125 case '1': 126 Cflg = 0; break; 127 case 'a': 128 aflg++; break; 129 case 'A': 130 Aflg++; break; 131 case 'c': 132 cflg++; break; 133 case 's': 134 sflg++; break; 135 case 'd': 136 dflg++; break; 137 case 'g': 138 gflg++; break; 139 case 'l': 140 lflg++; break; 141 case 'r': 142 rflg = -1; break; 143 case 't': 144 tflg++; break; 145 case 'u': 146 uflg++; break; 147 case 'i': 148 iflg++; break; 149 case 'f': 150 fflg++; break; 151 case 'L': 152 Lflg++; break; 153 case 'F': 154 Fflg++; break; 155 case 'R': 156 Rflg++; break; 157 } 158 } 159 argc--, argv++; 160 } 161 if (fflg) { 162 aflg++; lflg = 0; sflg = 0; tflg = 0; 163 } 164 if (lflg) 165 Cflg = 0; 166 if (argc == 0) { 167 argc++; 168 argv = &dotp; 169 } 170 fp = (struct afile *)calloc(argc, sizeof (struct afile)); 171 if (fp == 0) { 172 (void) fprintf(stderr, "ls: out of memory\n"); 173 exit(1); 174 } 175 fp0 = fp; 176 for (i = 0; i < argc; i++) { 177 if (gstat(fp, *argv, 1, (off_t *)0)) { 178 fp->fname = *argv; 179 fp->fflags |= ISARG; 180 fp++; 181 } 182 argv++; 183 } 184 fplast = fp; 185 qsort(fp0, fplast - fp0, sizeof (struct afile), fcmp); 186 if (dflg) { 187 formatf(fp0, fplast); 188 exit(0); 189 } 190 if (fflg) 191 fp = fp0; 192 else { 193 for (fp = fp0; fp < fplast && fp->ftype != 'd'; fp++) 194 continue; 195 formatf(fp0, fp); 196 } 197 if (fp < fplast) { 198 if (fp > fp0) 199 (void) printf("\n"); 200 for (;;) { 201 formatd(fp->fname, argc > 1); 202 while (subdirs) { 203 struct subdirs *t; 204 205 t = subdirs; subdirs = t->sd_next; 206 (void) printf("\n"); 207 formatd(t->sd_name, 1); 208 free(t->sd_name); 209 free(t); 210 } 211 if (++fp == fplast) 212 break; 213 (void) printf("\n"); 214 } 215 } 216 return (0); 217 } 218 219 static void 220 formatd(char *name, int title) 221 { 222 register struct afile *fp; 223 register struct subdirs *dp; 224 struct afile *dfp0, *dfplast; 225 off_t nkb; 226 227 nkb = getdir(name, &dfp0, &dfplast); 228 if (dfp0 == 0) 229 return; 230 if (fflg == 0) 231 qsort(dfp0, dfplast - dfp0, sizeof (struct afile), fcmp); 232 if (title) 233 (void) printf("%s:\n", name); 234 if (lflg || sflg) 235 (void) printf("total %lld\n", nkb); 236 formatf(dfp0, dfplast); 237 if (Rflg) 238 for (fp = dfplast - 1; fp >= dfp0; fp--) { 239 if (fp->ftype != 'd' || 240 strcmp(fp->fname, ".") == 0 || 241 strcmp(fp->fname, "..") == 0) 242 continue; 243 dp = (struct subdirs *)malloc(sizeof (struct subdirs)); 244 dp->sd_name = savestr(cat(name, fp->fname)); 245 dp->sd_next = subdirs; subdirs = dp; 246 } 247 for (fp = dfp0; fp < dfplast; fp++) { 248 if ((fp->fflags&ISARG) == 0 && fp->fname) 249 free(fp->fname); 250 if (fp->flinkto) 251 free(fp->flinkto); 252 } 253 free(dfp0); 254 } 255 256 static off_t 257 getdir(char *dir, struct afile **pfp0, struct afile **pfplast) 258 { 259 register struct afile *fp; 260 DIR *dirp; 261 register struct dirent *dp; 262 off_t nb; 263 size_t nent = 20; 264 265 /* 266 * This code (opendir, readdir, and the "for" loop) is arranged in 267 * this strange manner to handle the case where UNIX lets root open 268 * any directory for reading, but NFS does not let root read the 269 * openned directory. 270 */ 271 *pfp0 = *pfplast = NULL; 272 if ((dirp = opendir(dir)) == NULL) { 273 (void) printf("%s unreadable\n", dir); /* not stderr! */ 274 return (0); 275 } 276 errno = 0; 277 if (((dp = readdir(dirp)) == NULL) && (errno != 0)) { 278 /* root reading across NFS can get to this error case */ 279 (void) printf("%s unreadable\n", dir); /* not stderr! */ 280 (void) closedir(dirp); 281 return (0); 282 } 283 fp = *pfp0 = (struct afile *)calloc(nent, sizeof (struct afile)); 284 *pfplast = *pfp0 + nent; 285 for (nb = 0; dp != NULL; dp = readdir(dirp)) { 286 if (dp->d_ino == 0) 287 continue; 288 if (aflg == 0 && dp->d_name[0] == '.' && 289 (Aflg == 0 || dp->d_name[1] == 0 || 290 dp->d_name[1] == '.' && dp->d_name[2] == 0)) 291 continue; 292 if (gstat(fp, cat(dir, dp->d_name), Fflg+Rflg, &nb) == 0) 293 continue; 294 fp->fnum = dp->d_ino; 295 fp->fname = savestr(dp->d_name); 296 fp++; 297 if (fp == *pfplast) { 298 *pfp0 = (struct afile *)realloc((char *)*pfp0, 299 2 * nent * sizeof (struct afile)); 300 if (*pfp0 == 0) { 301 (void) fprintf(stderr, "ls: out of memory\n"); 302 exit(1); 303 } 304 fp = *pfp0 + nent; 305 *pfplast = fp + nent; 306 nent *= 2; 307 } 308 } 309 (void) closedir(dirp); 310 *pfplast = fp; 311 return (dbtokb(nb)); 312 } 313 314 315 static struct afile * 316 gstat(struct afile *fp, char *file, int statarg, off_t *pnb) 317 { 318 static struct afile azerofile; 319 int (*statf)() = Lflg ? stat : lstat; 320 int cc; 321 char buf[PATH_MAX]; 322 int aclcnt; 323 aclent_t *aclp; 324 aclent_t *tp; 325 o_mode_t groupperm, mask; 326 int grouppermfound, maskfound; 327 328 *fp = azerofile; 329 fp->fflags = 0; 330 fp->fnum = 0; 331 fp->ftype = '-'; 332 if (statarg || sflg || lflg || tflg) { 333 struct stat stb, stb1; 334 335 if ((*statf)(file, &stb) < 0) { 336 if (statf == lstat || lstat(file, &stb) < 0) { 337 if (errno == ENOENT) 338 (void) fprintf(stderr, 339 "%s not found\n", file); 340 else { 341 (void) fprintf(stderr, "ls: "); 342 perror(file); 343 } 344 return (0); 345 } 346 } 347 fp->fblks = stb.st_blocks; 348 fp->fsize = stb.st_size; 349 switch (stb.st_mode & S_IFMT) { 350 case S_IFDIR: 351 fp->ftype = 'd'; break; 352 case S_IFDOOR: 353 fp->ftype = 'D'; break; 354 case S_IFBLK: 355 fp->ftype = 'b'; fp->fsize = (off_t)stb.st_rdev; break; 356 case S_IFCHR: 357 fp->ftype = 'c'; fp->fsize = (off_t)stb.st_rdev; break; 358 case S_IFSOCK: 359 fp->ftype = 's'; fp->fsize = 0LL; break; 360 case S_IFIFO: 361 fp->ftype = 'p'; fp->fsize = 0LL; break; 362 case S_IFLNK: 363 fp->ftype = 'l'; 364 if (lflg) { 365 cc = readlink(file, buf, BUFSIZ); 366 if (cc >= 0) { 367 /* 368 * here we follow the symbolic 369 * link to generate the proper 370 * Fflg marker for the object, 371 * eg, /bin -> /pub/bin/ 372 */ 373 buf[cc] = 0; 374 if (Fflg && !stat(file, &stb1)) 375 switch (stb1.st_mode & S_IFMT) { 376 case S_IFDIR: 377 buf[cc++] = '/'; 378 break; 379 case S_IFDOOR: 380 buf[cc++] = '>'; 381 break; 382 case S_IFIFO: 383 buf[cc++] = '|'; 384 break; 385 case S_IFSOCK: 386 buf[cc++] = '='; 387 break; 388 default: 389 if ((stb1.st_mode & ~S_IFMT) 390 & 0111) 391 buf[cc++] = '*'; 392 break; 393 } 394 buf[cc] = 0; 395 fp->flinkto = savestr(buf); 396 } 397 break; 398 } 399 /* 400 * this is a hack from UCB to avoid having 401 * ls /bin behave differently from ls /bin/ 402 * when /bin is a symbolic link. We hack the 403 * hack to have that happen, but only for 404 * explicit arguments, by inspecting pnb. 405 */ 406 if (pnb != (off_t *)0 || stat(file, &stb1) < 0) 407 break; 408 if ((stb1.st_mode & S_IFMT) == S_IFDIR) { 409 stb = stb1; 410 fp->ftype = 'd'; 411 fp->fsize = stb.st_size; 412 fp->fblks = stb.st_blocks; 413 } 414 break; 415 } 416 fp->fnum = stb.st_ino; 417 fp->fflags = stb.st_mode & ~S_IFMT; 418 fp->fnl = stb.st_nlink; 419 fp->fuid = stb.st_uid; 420 fp->fgid = stb.st_gid; 421 422 /* ACL: check acl entries count */ 423 if ((aclcnt = acl(file, GETACLCNT, 0, NULL)) > 424 MIN_ACL_ENTRIES) { 425 426 /* this file has a non-trivial acl */ 427 428 fp->acl = '+'; 429 430 /* 431 * For files with non-trivial acls, the 432 * effective group permissions are the 433 * intersection of the GROUP_OBJ value and 434 * the CLASS_OBJ (acl mask) value. Determine 435 * both the GROUP_OBJ and CLASS_OBJ for this 436 * file and insert the logical AND of those 437 * two values in the group permissions field 438 * of the lflags value for this file. 439 */ 440 441 if ((aclp = (aclent_t *)malloc( 442 (sizeof (aclent_t)) * aclcnt)) == NULL) { 443 perror("ls"); 444 exit(2); 445 } 446 447 if (acl(file, GETACL, aclcnt, aclp) < 0) { 448 free(aclp); 449 (void) fprintf(stderr, "ls: "); 450 perror(file); 451 return (0); 452 } 453 454 /* 455 * Until found in acl list, assume maximum 456 * permissions for both group and mask. (Just 457 * in case the acl lacks either value for 458 * some reason.) 459 */ 460 groupperm = 07; 461 mask = 07; 462 grouppermfound = 0; 463 maskfound = 0; 464 for (tp = aclp; aclcnt--; tp++) { 465 if (tp->a_type == GROUP_OBJ) { 466 groupperm = tp->a_perm; 467 grouppermfound = 1; 468 continue; 469 } 470 if (tp->a_type == CLASS_OBJ) { 471 mask = tp->a_perm; 472 maskfound = 1; 473 } 474 if (grouppermfound && maskfound) 475 break; 476 } 477 478 free(aclp); 479 480 /* reset all the group bits */ 481 fp->fflags &= ~S_IRWXG; 482 483 /* 484 * Now set them to the logical AND of the 485 * GROUP_OBJ permissions and the acl mask. 486 */ 487 488 fp->fflags |= (groupperm & mask) << 3; 489 } else 490 fp->acl = ' '; 491 492 if (uflg) 493 fp->fmtime = stb.st_atime; 494 else if (cflg) 495 fp->fmtime = stb.st_ctime; 496 else 497 fp->fmtime = stb.st_mtime; 498 if (pnb) 499 *pnb += stb.st_blocks; 500 } 501 return (fp); 502 } 503 504 static void 505 formatf(struct afile *fp0, struct afile *fplast) 506 { 507 register struct afile *fp; 508 int width = 0, w, nentry = fplast - fp0; 509 int i, j, columns, lines; 510 char *cp; 511 512 if (fp0 == fplast) 513 return; 514 if (lflg || Cflg == 0) 515 columns = 1; 516 else { 517 for (fp = fp0; fp < fplast; fp++) { 518 int len = strlen(fmtentry(fp)); 519 520 if (len > width) 521 width = len; 522 } 523 if (usetabs) 524 width = (width + 8) &~ 7; 525 else 526 width += 2; 527 columns = twidth / width; 528 if (columns == 0) 529 columns = 1; 530 } 531 lines = (nentry + columns - 1) / columns; 532 for (i = 0; i < lines; i++) { 533 for (j = 0; j < columns; j++) { 534 fp = fp0 + j * lines + i; 535 cp = fmtentry(fp); 536 (void) printf("%s", cp); 537 if (fp + lines >= fplast) { 538 (void) printf("\n"); 539 break; 540 } 541 w = strlen(cp); 542 while (w < width) 543 if (usetabs) { 544 w = (w + 8) &~ 7; 545 (void) putchar('\t'); 546 } else { 547 w++; 548 (void) putchar(' '); 549 } 550 } 551 } 552 } 553 554 static int 555 fcmp(const void *arg1, const void *arg2) 556 { 557 const struct afile *f1 = arg1; 558 const struct afile *f2 = arg2; 559 560 if (dflg == 0 && fflg == 0) { 561 if ((f1->fflags&ISARG) && f1->ftype == 'd') { 562 if ((f2->fflags&ISARG) == 0 || f2->ftype != 'd') 563 return (1); 564 } else { 565 if ((f2->fflags&ISARG) && f2->ftype == 'd') 566 return (-1); 567 } 568 } 569 if (tflg) { 570 if (f2->fmtime == f1->fmtime) 571 return (0); 572 if (f2->fmtime > f1->fmtime) 573 return (rflg); 574 return (-rflg); 575 } 576 return (rflg * strcmp(f1->fname, f2->fname)); 577 } 578 579 static char * 580 cat(char *dir, char *file) 581 { 582 static char dfile[BUFSIZ]; 583 584 if (strlen(dir)+1+strlen(file)+1 > BUFSIZ) { 585 (void) fprintf(stderr, "ls: filename too long\n"); 586 exit(1); 587 } 588 if (strcmp(dir, "") == 0 || strcmp(dir, ".") == 0) { 589 (void) strcpy(dfile, file); 590 return (dfile); 591 } 592 (void) strcpy(dfile, dir); 593 if (dir[strlen(dir) - 1] != '/' && *file != '/') 594 (void) strcat(dfile, "/"); 595 (void) strcat(dfile, file); 596 return (dfile); 597 } 598 599 static char * 600 savestr(char *str) 601 { 602 char *cp = malloc(strlen(str) + 1); 603 604 if (cp == NULL) { 605 (void) fprintf(stderr, "ls: out of memory\n"); 606 exit(1); 607 } 608 (void) strcpy(cp, str); 609 return (cp); 610 } 611 612 static char *fmtinum(struct afile *); 613 static char *fmtsize(struct afile *); 614 static char *fmtlstuff(struct afile *); 615 static char *fmtmode(char *, int); 616 617 static char * 618 fmtentry(struct afile *fp) 619 { 620 static char fmtres[BUFSIZ]; 621 register char *cp, *dp; 622 623 (void) sprintf(fmtres, "%s%s%s", 624 iflg ? fmtinum(fp) : "", 625 sflg ? fmtsize(fp) : "", 626 lflg ? fmtlstuff(fp) : ""); 627 dp = &fmtres[strlen(fmtres)]; 628 for (cp = fp->fname; *cp; cp++) 629 if (qflg && !isprint((unsigned char)*cp)) 630 *dp++ = '?'; 631 else 632 *dp++ = *cp; 633 /* avoid both "->" and trailing marks */ 634 if (Fflg && ! (lflg && fp->flinkto)) { 635 if (fp->ftype == 'd') 636 *dp++ = '/'; 637 else if (fp->ftype == 'D') 638 *dp++ = '>'; 639 else if (fp->ftype == 'p') 640 *dp++ = '|'; 641 else if (fp->ftype == 'l') 642 *dp++ = '@'; 643 else if (fp->ftype == 's') 644 *dp++ = '='; 645 else if (fp->fflags & 0111) 646 *dp++ = '*'; 647 } 648 if (lflg && fp->flinkto) { 649 (void) strcpy(dp, " -> "); dp += 4; 650 for (cp = fp->flinkto; *cp; cp++) 651 if (qflg && !isprint((unsigned char) *cp)) 652 *dp++ = '?'; 653 else 654 *dp++ = *cp; 655 } 656 *dp++ = 0; 657 return (fmtres); 658 } 659 660 static char * 661 fmtinum(struct afile *p) 662 { 663 static char inumbuf[12]; 664 665 (void) sprintf(inumbuf, "%10llu ", p->fnum); 666 return (inumbuf); 667 } 668 669 static char * 670 fmtsize(struct afile *p) 671 { 672 static char sizebuf[32]; 673 674 (void) sprintf(sizebuf, (off_t)dbtokb(p->fblks) < 10000 ? "%4lld " : \ 675 "%lld ", (off_t)dbtokb(p->fblks)); 676 return (sizebuf); 677 } 678 679 static char * 680 fmtlstuff(struct afile *p) 681 { 682 static char lstuffbuf[256]; 683 char gname[32], uname[32], fsize[32], ftime[32]; 684 register char *lp = lstuffbuf; 685 686 /* type mode uname gname fsize ftime */ 687 /* get uname */ 688 { 689 char *cp = getname(p->fuid); 690 (void) sprintf(uname, "%-9s", cp); 691 } 692 /* get gname */ 693 if (gflg) { 694 char *cp = getgroup(p->fgid); 695 (void) sprintf(gname, "%-9s", cp); 696 } 697 /* get fsize */ 698 if (p->ftype == 'b' || p->ftype == 'c') 699 (void) sprintf(fsize, "%3ld,%4ld", 700 major(p->fsize), minor(p->fsize)); 701 else if (p->ftype == 's') 702 (void) sprintf(fsize, "%8d", 0); 703 else 704 (void) sprintf(fsize, p->fsize < 100000000 ? "%8lld" : \ 705 "%lld", p->fsize); 706 /* get ftime */ 707 { 708 char *cp = ctime(&p->fmtime); 709 if ((p->fmtime < sixmonthsago) || (p->fmtime > onehourfromnow)) 710 (void) sprintf(ftime, " %-7.7s %-4.4s ", cp+4, cp+20); 711 else 712 (void) sprintf(ftime, " %-12.12s ", cp+4); 713 } 714 /* splat */ 715 *lp++ = p->ftype; 716 lp = fmtmode(lp, p->fflags); 717 (void) sprintf(lp, "%c%3ld %s%s%s%s", 718 p->acl, p->fnl, uname, gflg ? gname : "", fsize, ftime); 719 return (lstuffbuf); 720 } 721 722 static int m1[] = 723 { 1, S_IREAD>>0, 'r', '-' }; 724 static int m2[] = 725 { 1, S_IWRITE>>0, 'w', '-' }; 726 static int m3[] = 727 { 3, S_ISUID|(S_IEXEC>>0), 's', S_IEXEC>>0, 'x', S_ISUID, 'S', '-' }; 728 static int m4[] = 729 { 1, S_IREAD>>3, 'r', '-' }; 730 static int m5[] = 731 { 1, S_IWRITE>>3, 'w', '-' }; 732 static int m6[] = 733 { 3, S_ISGID|(S_IEXEC>>3), 's', S_IEXEC>>3, 'x', S_ISGID, 'S', '-' }; 734 static int m7[] = 735 { 1, S_IREAD>>6, 'r', '-' }; 736 static int m8[] = 737 { 1, S_IWRITE>>6, 'w', '-' }; 738 static int m9[] = 739 { 3, S_ISVTX|(S_IEXEC>>6), 't', S_ISVTX, 'T', S_IEXEC>>6, 'x', '-' }; 740 741 static int *m[] = { m1, m2, m3, m4, m5, m6, m7, m8, m9}; 742 743 static char * 744 fmtmode(char *lp, int flags) 745 { 746 int **mp; 747 748 for (mp = &m[0]; mp < &m[sizeof (m)/sizeof (m[0])]; ) { 749 register int *pairp = *mp++; 750 register int n = *pairp++; 751 752 while (n-- > 0) { 753 if ((flags&*pairp) == *pairp) { 754 pairp++; 755 break; 756 } else 757 pairp += 2; 758 } 759 *lp++ = *pairp; 760 } 761 return (lp); 762 } 763 764 /* rest should be done with nameserver or database */ 765 766 #include <pwd.h> 767 #include <grp.h> 768 #include <utmpx.h> 769 770 #define NMAX (sizeof (((struct utmpx *)0)->ut_name)) 771 #define SCPYN(a, b) strncpy(a, b, NMAX) 772 773 774 static struct cachenode { /* this struct must be zeroed before using */ 775 struct cachenode *lesschild; /* subtree whose entries < val */ 776 struct cachenode *grtrchild; /* subtree whose entries > val */ 777 int val; /* the uid or gid of this entry */ 778 int initted; /* name has been filled in */ 779 char name[NMAX+1]; /* the string that val maps to */ 780 } *names, *groups; 781 782 static struct cachenode * 783 findincache(struct cachenode **head, id_t val) 784 { 785 register struct cachenode **parent = head; 786 register struct cachenode *c = *parent; 787 788 while (c != NULL) { 789 if (val == c->val) { 790 /* found it */ 791 return (c); 792 } else if (val < c->val) { 793 parent = &c->lesschild; 794 c = c->lesschild; 795 } else { 796 parent = &c->grtrchild; 797 c = c->grtrchild; 798 } 799 } 800 801 /* not in the cache, make a new entry for it */ 802 *parent = c = (struct cachenode *)calloc(1, sizeof (struct cachenode)); 803 c->val = val; 804 return (c); 805 } 806 807 static char * 808 getname(uid_t uid) 809 { 810 struct cachenode *c; 811 struct passwd *pw; 812 813 c = findincache(&names, uid); 814 if (c->initted == 0) { 815 if ((pw = getpwuid(uid)) != NULL) { 816 (void) SCPYN(&c->name[0], pw->pw_name); 817 } else { 818 (void) sprintf(&c->name[0], "%-8lu ", uid); 819 } 820 c->initted = 1; 821 } 822 return (&c->name[0]); 823 } 824 825 static char * 826 getgroup(gid_t gid) 827 { 828 struct cachenode *c; 829 struct group *gr; 830 831 c = findincache(&groups, gid); 832 if (c->initted == 0) { 833 if ((gr = getgrgid(gid)) != NULL) { 834 (void) SCPYN(&c->name[0], gr->gr_name); 835 } else { 836 (void) sprintf(&c->name[0], "%-8lu ", gid); 837 } 838 c->initted = 1; 839 } 840 return (&c->name[0]); 841 } 842