![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ucbls.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 41BSD / cmd / ls|
Return to ucbls.c CVS log | Up to [CSRG BSD Unix] / 41BSD / cmd / ls |
1.1 ! root 1: #define UCB /* Controls output format for -F */ ! 2: /* #define UCB_PWHASH /* If have hashed password file */ ! 3: ! 4: /* ! 5: * ls - list file or directory ! 6: * ! 7: * Modified by Bill Joy UCB May/August 1977 ! 8: * Modified by Dave Presotto BTL Feb/80 ! 9: * Modified by Bill Joy and Mark Horton Summer 1980 ! 10: * ! 11: * this version of ls is designed for graphic terminals and to ! 12: * list directories with lots of files in them compactly. ! 13: * It supports three variants for listings: ! 14: * ! 15: * 1) Columnar output. ! 16: * 2) Stream output. ! 17: * 3) Old one per line format. ! 18: * ! 19: * Columnar output is the default. ! 20: * If, however, the standard output is not a teletype, the default ! 21: * is one-per-line. ! 22: * ! 23: * With columnar output, the items are sorted down the columns. ! 24: * We use columns only for a directory we are interpreting. ! 25: * Thus, in particular, we do not use columns for ! 26: * ! 27: * ls /usr/bin/p* ! 28: * ! 29: * This version of ls also prints non-printing characters as '?' if ! 30: * the standard output is a teletype. ! 31: * ! 32: * Flags relating to these and other new features are: ! 33: * ! 34: * -m force stream output. ! 35: * ! 36: * -1 force one entry per line, e.g. to a teletype ! 37: * ! 38: * -q force non-printings to be '?'s, e.g. to a file ! 39: * ! 40: * -C force columnar output, e.g. into a file ! 41: * ! 42: * -n like -l, but user/group id's in decimal rather than ! 43: * looking in /etc/passwd to save time ! 44: * ! 45: * -F turns on the "flagging" of executables and directories ! 46: * ! 47: * -R causes ls to recurse through the branches of the subtree ! 48: * ala find ! 49: */ ! 50: ! 51: #include <sys/param.h> ! 52: #include <sys/stat.h> ! 53: #include <sys/dir.h> ! 54: #include <stdio.h> ! 55: #include <ctype.h> ! 56: #include <pwd.h> ! 57: #include <grp.h> ! 58: #include <utmp.h> ! 59: ! 60: struct utmp utmp; ! 61: #define NMAX (sizeof utmp.ut_name) ! 62: ! 63: #define MAXFILEWIDTH 14 ! 64: #define NFILES 1024 ! 65: FILE *pwdf, *dirf; ! 66: ! 67: struct lbuf { ! 68: union { ! 69: char lname[15]; ! 70: char *namep; ! 71: } ln; ! 72: char ltype; ! 73: ino_t lnum; ! 74: short lflags; ! 75: short lnl; ! 76: short luid; ! 77: short lgid; ! 78: long lsize; ! 79: long lmtime; ! 80: }; ! 81: ! 82: struct dchain { ! 83: char *dc_name; /* the path name */ ! 84: struct dchain *dc_next; /* the next directory on the chain */ ! 85: }; ! 86: ! 87: struct dchain *dfirst; /* the start of the directory chain */ ! 88: struct dchain *cdfirst; /* the start of the current directory chain */ ! 89: struct dchain *dtemp; /* temporary used when linking */ ! 90: char *curdir; /* the current directory */ ! 91: ! 92: int aflg, bflg, dflg, lflg, sflg, tflg, uflg, iflg, fflg, gflg, cflg; ! 93: int Aflg, nflg, qflg, Fflg, Rflg, across, Cflg; ! 94: int nopad; ! 95: int tabflg; ! 96: int rflg = 1; ! 97: long year; ! 98: int flags; ! 99: long tblocks; ! 100: int statreq; ! 101: int xtraent; /* for those switches which print out a total */ ! 102: struct lbuf *flist[NFILES]; ! 103: struct lbuf **lastp = flist; ! 104: struct lbuf **firstp = flist; ! 105: char *dotp = "."; ! 106: ! 107: char *makename(); ! 108: struct lbuf *gstat(); ! 109: char *ctime(); ! 110: long nblock(); ! 111: char *getname(); ! 112: ! 113: #define ISARG 0100000 ! 114: int colwidth; ! 115: int filewidth; ! 116: int fixedwidth; ! 117: int outcol; ! 118: ! 119: char obuf[BUFSIZ]; ! 120: ! 121: main(argc, argv) ! 122: int argc; ! 123: char *argv[]; ! 124: { ! 125: #include <sgtty.h> ! 126: ! 127: int i, width; ! 128: register struct lbuf *ep; ! 129: register struct lbuf **slastp; ! 130: struct lbuf **epp; ! 131: struct lbuf lb; ! 132: char *t; ! 133: char *cp; ! 134: int compar(); ! 135: struct sgttyb sgbuf; ! 136: ! 137: Fflg = 0; ! 138: tabflg = 0; ! 139: Aflg = getuid() == 0; ! 140: setbuf(stdout, obuf); ! 141: lb.lmtime = time((long *) 0); ! 142: year = lb.lmtime - 6L*30L*24L*60L*60L; /* 6 months ago */ ! 143: qflg = gtty(1, &sgbuf) == 0; ! 144: ! 145: /* guarantee at least on column width */ ! 146: fixedwidth = 2; ! 147: ! 148: /* ! 149: * If the standard output is not a teletype, ! 150: * then we default to one-per-line format ! 151: * otherwise decide between stream and ! 152: * columnar based on our name. ! 153: */ ! 154: if (qflg) { ! 155: Cflg = 1; ! 156: if ((sgbuf.sg_flags & XTABS) == 0) ! 157: tabflg++; ! 158: for (cp = argv[0]; cp[0] && cp[1]; cp++) ! 159: continue; ! 160: /* ! 161: * Certain kinds of links (l, ll, lr, lf, lx) cause some ! 162: * various options to be turned on. ! 163: */ ! 164: switch (cp[0]) { ! 165: case 'l': ! 166: if (cp[-1] == 'l') { ! 167: /* ll => -l */ ! 168: lflg = 1; ! 169: statreq++; ! 170: xtraent++; ! 171: } else { ! 172: /* l => -m */ ! 173: nopad = 1; ! 174: Cflg = 0; ! 175: } ! 176: break; ! 177: case 'x': /* lx => -x */ ! 178: across = 1; ! 179: break; ! 180: case 'f': /* lf => -F */ ! 181: Fflg = 1; ! 182: break; ! 183: case 'r': /* lr => -R */ ! 184: Rflg = 1; ! 185: break; ! 186: } ! 187: } else { ! 188: tabflg++; ! 189: } ! 190: ! 191: while (--argc > 0 && *argv[1] == '-') { ! 192: argv++; ! 193: while (*++*argv) switch (**argv) { ! 194: /* ! 195: * C - force columnar output ! 196: */ ! 197: case 'C': ! 198: Cflg = 1; ! 199: nopad = 0; ! 200: continue; ! 201: /* ! 202: * m - force stream output ! 203: */ ! 204: case 'm': ! 205: Cflg = 0; ! 206: nopad = 1; ! 207: continue; ! 208: /* ! 209: * x - force sort across ! 210: */ ! 211: case 'x': ! 212: across = 1; ! 213: nopad = 0; ! 214: Cflg = 1; ! 215: continue; ! 216: /* ! 217: * q - force ?'s in output ! 218: */ ! 219: case 'q': ! 220: qflg = 1; ! 221: bflg = 0; ! 222: continue; ! 223: /* ! 224: * b - force octal value in output ! 225: */ ! 226: case 'b': ! 227: bflg = 1; ! 228: qflg = 0; ! 229: continue; ! 230: /* ! 231: * 1 - force 1/line in output ! 232: */ ! 233: case '1': ! 234: Cflg = 0; ! 235: nopad = 0; ! 236: continue; ! 237: /* STANDARD FLAGS */ ! 238: case 'a': ! 239: aflg++; ! 240: continue; ! 241: ! 242: case 'A': ! 243: Aflg = !Aflg; ! 244: continue; ! 245: ! 246: case 'c': ! 247: cflg++; ! 248: continue; ! 249: ! 250: case 's': ! 251: fixedwidth += 5; ! 252: sflg++; ! 253: statreq++; ! 254: xtraent++; ! 255: continue; ! 256: ! 257: case 'd': ! 258: dflg++; ! 259: continue; ! 260: ! 261: /* ! 262: * n - don't look in password file ! 263: */ ! 264: case 'n': ! 265: nflg++; ! 266: case 'l': ! 267: lflg++; ! 268: statreq++; ! 269: xtraent++; ! 270: continue; ! 271: ! 272: case 'r': ! 273: rflg = -1; ! 274: continue; ! 275: ! 276: case 't': ! 277: tflg++; ! 278: statreq++; ! 279: continue; ! 280: ! 281: case 'u': ! 282: uflg++; ! 283: continue; ! 284: ! 285: case 'i': ! 286: fixedwidth += 6; ! 287: iflg++; ! 288: continue; ! 289: ! 290: case 'f': ! 291: fflg++; ! 292: continue; ! 293: ! 294: case 'g': ! 295: gflg++; ! 296: continue; ! 297: ! 298: case 'F': ! 299: Fflg++; ! 300: continue; ! 301: ! 302: case 'R': ! 303: Rflg++; ! 304: continue; ! 305: ! 306: default: ! 307: fprintf (stderr, "usage: ls [-1ACFRabcdfgilmnqrstux] [files]\n"); ! 308: exit(1); ! 309: } ! 310: } ! 311: if (Fflg) ! 312: #ifdef UCB ! 313: fixedwidth++; ! 314: #else ! 315: fixedwidth += 2; ! 316: #endif ! 317: if (fflg) { ! 318: aflg++; ! 319: lflg = 0; ! 320: sflg = 0; ! 321: tflg = 0; ! 322: statreq = 0; ! 323: xtraent = 0; ! 324: } ! 325: if(lflg) { ! 326: Cflg = 0; ! 327: t = "/etc/passwd"; ! 328: if (gflg) ! 329: t = "/etc/group"; ! 330: nopad = 0; ! 331: fixedwidth = 70; ! 332: pwdf = fopen(t, "r"); ! 333: } ! 334: if (argc==0) { ! 335: argc++; ! 336: argv = &dotp - 1; ! 337: } ! 338: for (i=0; i < argc; i++) { ! 339: argv++; ! 340: if (Cflg) { ! 341: width = strlen (*argv); ! 342: if (width > filewidth) ! 343: filewidth = width; ! 344: } ! 345: if ((ep = gstat(*argv, 1))==NULL) ! 346: continue; ! 347: ep->ln.namep = *argv; ! 348: ep->lflags |= ISARG; ! 349: } ! 350: if (!Cflg) ! 351: filewidth = MAXFILEWIDTH; ! 352: else ! 353: colwidth = fixedwidth + filewidth; ! 354: qsort(firstp, lastp - firstp, sizeof *lastp, compar); ! 355: slastp = lastp; ! 356: /* For each argument user typed */ ! 357: for (epp=firstp; epp<slastp; epp++) { ! 358: ep = *epp; ! 359: if (ep->ltype=='d' && dflg==0 || fflg) ! 360: pdirectory(ep->ln.namep, (argc>1), slastp); ! 361: else ! 362: pentry(ep); ! 363: ! 364: /* -R: print subdirectories found */ ! 365: while (dfirst || cdfirst) { ! 366: /* Place direct subdirs on front in right order */ ! 367: while (cdfirst) { ! 368: /* reverse cdfirst onto front of dfirst */ ! 369: dtemp = cdfirst; ! 370: cdfirst = cdfirst -> dc_next; ! 371: dtemp -> dc_next = dfirst; ! 372: dfirst = dtemp; ! 373: } ! 374: /* take off first dir on dfirst & print it */ ! 375: dtemp = dfirst; ! 376: dfirst = dfirst->dc_next; ! 377: pdirectory (dtemp->dc_name, 1, firstp); ! 378: cfree (dtemp->dc_name); ! 379: cfree (dtemp); ! 380: } ! 381: } ! 382: if (outcol) ! 383: putc('\n', stdout); ! 384: fflush(stdout); ! 385: } ! 386: ! 387: /* ! 388: * pdirectory: print the directory name, labelling it if title is ! 389: * nonzero, using lp as the place to start reading in the dir. ! 390: */ ! 391: pdirectory (name, title, lp) ! 392: char *name; ! 393: int title; ! 394: struct lbuf **lp; ! 395: { ! 396: register struct dchain *dp; ! 397: register struct lbuf *ap; ! 398: register char *pname; ! 399: struct lbuf **app; ! 400: ! 401: filewidth = 0; ! 402: curdir = name; ! 403: if (title) ! 404: printf("\n%s:\n", name); ! 405: lastp = lp; ! 406: readdir(name); ! 407: if (!Cflg) ! 408: filewidth = MAXFILEWIDTH; ! 409: colwidth = fixedwidth + filewidth; ! 410: #ifdef notdef ! 411: /* Taken out because it appears this is done below in pem. */ ! 412: if (tabflg) { ! 413: if (colwidth <= 8) ! 414: colwidth = 8; ! 415: else ! 416: if (colwidth <= 16) ! 417: colwidth = 16; ! 418: } ! 419: #endif ! 420: if (fflg==0) ! 421: qsort(lp,lastp - lp,sizeof *lastp,compar); ! 422: if (Rflg) for (app=lastp-1; app>=lp; app--) { ! 423: ap = *app; ! 424: if (ap->ltype == 'd' && strcmp(ap->ln.lname, ".") && ! 425: strcmp(ap->ln.lname, "..")) { ! 426: dp = (struct dchain *) calloc(1, sizeof(struct dchain)); ! 427: pname = makename (curdir, ap->ln.lname); ! 428: dp->dc_name = (char *) calloc(1, strlen(pname)+1); ! 429: strcpy(dp->dc_name, pname); ! 430: dp -> dc_next = dfirst; ! 431: dfirst = dp; ! 432: } ! 433: } ! 434: if (lflg || sflg) ! 435: printf("total %D", tblocks); ! 436: pem(lp, lastp); ! 437: newline(); ! 438: } ! 439: ! 440: /* ! 441: * pem: print 'em. Print a list of files (e.g. a directory) bounded ! 442: * by slp and lp. ! 443: */ ! 444: pem(slp, lp) ! 445: register struct lbuf **slp, **lp; ! 446: { ! 447: int ncols, nrows, row, col; ! 448: register struct lbuf **ep; ! 449: ! 450: if (tabflg) { ! 451: if (colwidth <= 9) ! 452: colwidth = 8; ! 453: else ! 454: if (colwidth <= 17) ! 455: colwidth = 16; ! 456: } ! 457: ncols = 80 / colwidth; ! 458: if (ncols == 1 || Cflg == 0) { ! 459: for (ep = slp; ep < lp; ep++) ! 460: pentry(*ep); ! 461: return; ! 462: } ! 463: if (across) { ! 464: for (ep = slp; ep < lp; ep++) ! 465: pentry(*ep); ! 466: return; ! 467: } ! 468: if (xtraent) ! 469: slp--; ! 470: nrows = (lp - slp - 1) / ncols + 1; ! 471: for (row = 0; row < nrows; row++) { ! 472: col = row == 0 && xtraent; ! 473: for (; col < ncols; col++) { ! 474: ep = slp + (nrows * col) + row; ! 475: if (ep < lp) ! 476: pentry(*ep); ! 477: } ! 478: if (outcol) ! 479: printf("\n"); ! 480: } ! 481: } ! 482: ! 483: /* ! 484: * pputchar: like putchar but knows how to handle control chars. ! 485: * CAUTION: if you make ctrl chars print in ^x notation, or any ! 486: * other notation which is wider than one character, the column ! 487: * nature of things (such as files with 14 letter names) will be ! 488: * messed up. Weigh this carefully! ! 489: */ ! 490: pputchar(c) ! 491: char c; ! 492: { ! 493: char cc; ! 494: ! 495: switch (c) { ! 496: case '\t': ! 497: outcol = (outcol + 8) &~ 7; ! 498: break; ! 499: case '\n': ! 500: outcol = 0; ! 501: break; ! 502: default: ! 503: if (c < ' ' || c >= 0177) { ! 504: if (qflg) ! 505: c = '?'; ! 506: else if (bflg) { ! 507: outcol += 3; ! 508: putc ('\\', stdout); ! 509: cc = '0' + (c>>6 & 07); ! 510: putc (cc, stdout); ! 511: cc = '0' + (c>>3 & 07); ! 512: putc (cc, stdout); ! 513: c = '0' + (c & 07); ! 514: } ! 515: } ! 516: outcol++; ! 517: break; ! 518: } ! 519: putc(c, stdout); ! 520: } ! 521: ! 522: newline() ! 523: { ! 524: if (outcol) ! 525: putc('\n', stdout); ! 526: outcol = 0; ! 527: } ! 528: ! 529: /* ! 530: * column: get to the beginning of the next column. ! 531: */ ! 532: column() ! 533: { ! 534: ! 535: if (outcol == 0) ! 536: return; ! 537: if (nopad) { ! 538: putc(',', stdout); ! 539: outcol++; ! 540: if (outcol + colwidth + 2 > 80) { ! 541: putc('\n', stdout); ! 542: outcol = 0; ! 543: return; ! 544: } ! 545: putc(' ', stdout); ! 546: outcol++; ! 547: return; ! 548: } ! 549: if (Cflg == 0) { ! 550: putc('\n', stdout); ! 551: return; ! 552: } ! 553: if ((outcol / colwidth + 2) * colwidth > 80) { ! 554: putc('\n', stdout); ! 555: outcol = 0; ! 556: return; ! 557: } ! 558: if (tabflg && (colwidth <= 16)) { ! 559: if (colwidth > 8) ! 560: if ((outcol % 16) < 8) { ! 561: outcol += 8 - (outcol % 8); ! 562: putc ('\t', stdout); ! 563: } ! 564: outcol += 8 - (outcol % 8); ! 565: putc ('\t', stdout); ! 566: return; ! 567: } ! 568: do { ! 569: outcol++; ! 570: putc(' ', stdout); ! 571: } while (outcol % colwidth); ! 572: } ! 573: ! 574: ! 575: /* ! 576: * nblock: the number of 512 byte blocks a size byte file takes up. ! 577: * (Note: the number stays 512 no matter what BUFSIZ or the filesystem uses.) ! 578: */ ! 579: long ! 580: nblock(size) ! 581: long size; ! 582: { ! 583: return((size+511)>>9); ! 584: } ! 585: ! 586: /* ! 587: * This code handles the rwx- business. ! 588: * You figure it out. ! 589: */ ! 590: int m1[] = { 1, S_IREAD>>0, 'r', '-' }; ! 591: int m2[] = { 1, S_IWRITE>>0, 'w', '-' }; ! 592: int m3[] = { 2, S_ISUID, 's', S_IEXEC>>0, 'x', '-' }; ! 593: int m4[] = { 1, S_IREAD>>3, 'r', '-' }; ! 594: int m5[] = { 1, S_IWRITE>>3, 'w', '-' }; ! 595: int m6[] = { 2, S_ISGID, 's', S_IEXEC>>3, 'x', '-' }; ! 596: int m7[] = { 1, S_IREAD>>6, 'r', '-' }; ! 597: int m8[] = { 1, S_IWRITE>>6, 'w', '-' }; ! 598: int m9[] = { 2, S_ISVTX, 't', S_IEXEC>>6, 'x', '-' }; ! 599: ! 600: int *m[] = { m1, m2, m3, m4, m5, m6, m7, m8, m9}; ! 601: ! 602: pmode(aflag) ! 603: { ! 604: register int **mp; ! 605: ! 606: flags = aflag; ! 607: for (mp = &m[0]; mp < &m[sizeof(m)/sizeof(m[0])];) ! 608: select(*mp++); ! 609: } ! 610: ! 611: select(pairp) ! 612: register int *pairp; ! 613: { ! 614: register int n; ! 615: ! 616: n = *pairp++; ! 617: while (--n>=0 && (flags&*pairp++)==0) ! 618: pairp++; ! 619: pputchar(*pairp); ! 620: } ! 621: ! 622: /* ! 623: * returns cat(dir, "/", file), unless dir ends in /, when it doesn't // ! 624: */ ! 625: char * ! 626: makename(dir, file) ! 627: char *dir, *file; ! 628: { ! 629: static char dfile[100]; ! 630: register char *dp, *fp; ! 631: register int i; ! 632: ! 633: dp = dfile; ! 634: fp = dir; ! 635: while (*fp) ! 636: *dp++ = *fp++; ! 637: if (*(dp-1) != '/') ! 638: *dp++ = '/'; ! 639: fp = file; ! 640: for (i=0; i<DIRSIZ; i++) ! 641: *dp++ = *fp++; ! 642: *dp = 0; ! 643: return(dfile); ! 644: } ! 645: ! 646: /* ! 647: * readdir: read in the directory whose name is dir, ! 648: * starting at lastp. ! 649: */ ! 650: readdir(dir) ! 651: char *dir; ! 652: { ! 653: static struct direct dentry; ! 654: register int j, width; ! 655: register struct lbuf *ep; ! 656: ! 657: if ((dirf = fopen(dir, "r")) == NULL) { ! 658: printf("%s unreadable\n", dir); ! 659: return; ! 660: } ! 661: tblocks = 0; ! 662: for(;;) { ! 663: if (fread(&dentry, sizeof(dentry), 1, dirf) != 1) ! 664: break; ! 665: if (dentry.d_ino==0 || ! 666: aflg==0 && dentry.d_name[0]=='.' && ( ! 667: !Aflg || ! 668: dentry.d_name[1]=='\0' ! 669: || dentry.d_name[1]=='.' && dentry.d_name[2]=='\0')) ! 670: continue; ! 671: if (Cflg) { ! 672: width = strlen (dentry.d_name); ! 673: if (width > filewidth) ! 674: filewidth = width; ! 675: } ! 676: ep = gstat(makename(dir, dentry.d_name), Fflg || Rflg); ! 677: if (ep==NULL) ! 678: continue; ! 679: if (ep->lnum != -1) ! 680: ep->lnum = dentry.d_ino; ! 681: for (j=0; j<DIRSIZ; j++) ! 682: ep->ln.lname[j] = dentry.d_name[j]; ! 683: } ! 684: fclose(dirf); ! 685: } ! 686: ! 687: /* ! 688: * stat the given file and return an lbuf containing it. ! 689: * argfl is nonzero if a stat is required because the file is ! 690: * an argument, rather than having been found in a directory. ! 691: */ ! 692: struct lbuf * ! 693: gstat(file, argfl) ! 694: char *file; ! 695: { ! 696: struct stat statb; ! 697: register struct lbuf *rep; ! 698: static int nomocore; ! 699: ! 700: if (nomocore) ! 701: return(NULL); ! 702: rep = (struct lbuf *)malloc(sizeof(struct lbuf)); ! 703: if (rep==NULL) { ! 704: fprintf(stderr, "ls: out of memory\n"); ! 705: nomocore = 1; ! 706: return(NULL); ! 707: } ! 708: if (lastp >= &flist[NFILES]) { ! 709: static int msg; ! 710: lastp--; ! 711: if (msg==0) { ! 712: fprintf(stderr, "ls: too many files\n"); ! 713: msg++; ! 714: } ! 715: } ! 716: *lastp++ = rep; ! 717: rep->lflags = 0; ! 718: rep->lnum = 0; ! 719: rep->ltype = '-'; ! 720: if (argfl || statreq) { ! 721: if (stat(file, &statb)<0) { ! 722: printf("%s not found\n", file); ! 723: statb.st_ino = -1; ! 724: statb.st_size = 0; ! 725: statb.st_mode = 0; ! 726: if (argfl) { ! 727: lastp--; ! 728: return(0); ! 729: } ! 730: } ! 731: rep->lnum = statb.st_ino; ! 732: rep->lsize = statb.st_size; ! 733: switch(statb.st_mode&S_IFMT) { ! 734: ! 735: case S_IFDIR: ! 736: rep->ltype = 'd'; ! 737: break; ! 738: ! 739: case S_IFBLK: ! 740: rep->ltype = 'b'; ! 741: rep->lsize = statb.st_rdev; ! 742: break; ! 743: ! 744: case S_IFCHR: ! 745: rep->ltype = 'c'; ! 746: rep->lsize = statb.st_rdev; ! 747: break; ! 748: ! 749: case S_IFMPB: ! 750: rep->ltype = 'M'; ! 751: rep->lsize = statb.st_rdev; ! 752: break; ! 753: ! 754: case S_IFMPC: ! 755: rep->ltype = 'm'; ! 756: rep->lsize = statb.st_rdev; ! 757: break; ! 758: } ! 759: rep->lflags = statb.st_mode & ~S_IFMT; ! 760: rep->luid = statb.st_uid; ! 761: rep->lgid = statb.st_gid; ! 762: rep->lnl = statb.st_nlink; ! 763: if(uflg) ! 764: rep->lmtime = statb.st_atime; ! 765: else if (cflg) ! 766: rep->lmtime = statb.st_ctime; ! 767: else ! 768: rep->lmtime = statb.st_mtime; ! 769: tblocks += nblock(statb.st_size); ! 770: } ! 771: return(rep); ! 772: } ! 773: ! 774: /* ! 775: * decide whether to print pp1 before or after pp2, based on their ! 776: * names, various times, and the r flag. ! 777: */ ! 778: compar(pp1, pp2) ! 779: struct lbuf **pp1, **pp2; ! 780: { ! 781: register struct lbuf *p1, *p2; ! 782: ! 783: p1 = *pp1; ! 784: p2 = *pp2; ! 785: if (dflg==0) { ! 786: if (p1->lflags&ISARG && p1->ltype=='d') { ! 787: if (!(p2->lflags&ISARG && p2->ltype=='d')) ! 788: return(1); ! 789: } else { ! 790: if (p2->lflags&ISARG && p2->ltype=='d') ! 791: return(-1); ! 792: } ! 793: } ! 794: if (tflg) { ! 795: if(p2->lmtime == p1->lmtime) ! 796: return(0); ! 797: if(p2->lmtime > p1->lmtime) ! 798: return(rflg); ! 799: return(-rflg); ! 800: } ! 801: return(rflg * strcmp(p1->lflags&ISARG? p1->ln.namep: p1->ln.lname, ! 802: p2->lflags&ISARG? p2->ln.namep: p2->ln.lname)); ! 803: } ! 804: ! 805: /* ! 806: * print the entry pointed at by ap ! 807: */ ! 808: pentry(ap) ! 809: struct lbuf *ap; ! 810: { ! 811: struct { char dminor, dmajor;}; ! 812: register struct lbuf *p; ! 813: register char *cp; ! 814: char fname[100]; ! 815: char *pname; ! 816: struct passwd *getpwuid(); ! 817: struct passwd *pwptr; ! 818: struct group *getgrgid(); ! 819: struct group *grptr; ! 820: ! 821: fname[0] = 0; ! 822: p = ap; ! 823: if (p->lnum == -1) ! 824: return; ! 825: column(); ! 826: if (iflg) ! 827: if (nopad && !lflg) ! 828: printf("%d ", p->lnum); ! 829: else ! 830: printf("%5d ", p->lnum); ! 831: if (sflg) ! 832: if (nopad && !lflg) ! 833: printf("%D ", nblock(p->lsize)); ! 834: else ! 835: printf("%4D ", nblock(p->lsize)); ! 836: if (lflg) { ! 837: pputchar(p->ltype); ! 838: pmode(p->lflags); ! 839: printf("%2d ", p->lnl); ! 840: if(gflg) { ! 841: grptr = getgrgid(p->lgid); ! 842: if (nflg == 0 && grptr != 0) ! 843: printf("%-8.8s", grptr->gr_name); ! 844: else ! 845: printf("%-8d", p->lgid); ! 846: } else { ! 847: #ifndef UCB_PWHASH ! 848: char *name; ! 849: if (nflg == 0 && (name = getname(p->luid))) { ! 850: printf("%-8.8s", name); ! 851: } ! 852: #else ! 853: pwptr = getpwuid(p->luid); ! 854: if (nflg == 0 && pwptr != 0) ! 855: printf("%-8.8s", pwptr->pw_name); ! 856: #endif ! 857: else ! 858: printf("%-8d", p->luid); ! 859: } ! 860: switch (p->ltype) { ! 861: ! 862: case 'b': ! 863: case 'c': ! 864: case 'm': ! 865: case 'M': ! 866: printf("%3d,%3d", ! 867: major((int)p->lsize), minor((int)p->lsize)); ! 868: break; ! 869: default: ! 870: printf("%7ld", p->lsize); ! 871: } ! 872: cp = ctime(&p->lmtime); ! 873: if(p->lmtime < year) ! 874: printf(" %-7.7s %-4.4s ", cp+4, cp+20); else ! 875: printf(" %-12.12s ", cp+4); ! 876: } ! 877: #ifndef UCB ! 878: if (Fflg) { ! 879: if (p->ltype == 'd') ! 880: strcat (fname, "["); ! 881: else if (p->lflags & 0111) ! 882: strcat (fname, "*"); ! 883: else if (!nopad) ! 884: strcat (fname, " "); ! 885: } ! 886: #endif ! 887: if (p->lflags & ISARG) ! 888: strncat (fname, p->ln.namep, 98); ! 889: else ! 890: strncat (fname, p->ln.lname, 14); ! 891: #ifndef UCB ! 892: if (Fflg) { ! 893: if (p->ltype == 'd') ! 894: strcat (fname, "]"); ! 895: else if (!nopad) ! 896: strcat (fname, " "); ! 897: } ! 898: #else ! 899: if (Fflg) { ! 900: if (p->ltype == 'd') ! 901: strcat (fname, "/"); ! 902: else if (p->lflags & 0111) ! 903: strcat (fname, "*"); ! 904: else if (!nopad) ! 905: strcat (fname, " "); ! 906: } ! 907: #endif ! 908: printf ("%s", fname); ! 909: free(ap); ! 910: } ! 911: ! 912: /* char printf_id[] = "@(#) printf.c:2.2 6/5/79";*/ ! 913: ! 914: #include "varargs.h" ! 915: ! 916: /* ! 917: * This version of printf is compatible with the Version 7 C ! 918: * printf. The differences are only minor except that this ! 919: * printf assumes it is to print through pputchar. Version 7 ! 920: * printf is more general (and is much larger) and includes ! 921: * provisions for floating point. ! 922: */ ! 923: ! 924: #define MAXOCT 11 /* Maximum octal digits in a long */ ! 925: #define MAXINT 32767 /* largest normal length positive integer */ ! 926: #define BIG 1000000000 /* largest power of 10 less than an unsigned long */ ! 927: #define MAXDIGS 10 /* number of digits in BIG */ ! 928: ! 929: static int width, sign, fill; ! 930: ! 931: char *b_dconv(); ! 932: ! 933: printf(va_alist) ! 934: va_dcl ! 935: { ! 936: va_list ap; ! 937: register char *fmt; ! 938: char fcode; ! 939: int prec; ! 940: int length,mask1,nbits,n; ! 941: long int mask2, num; ! 942: register char *bptr; ! 943: char *ptr; ! 944: char buf[134]; ! 945: ! 946: va_start(ap); ! 947: fmt = va_arg(ap,char *); ! 948: for (;;) { ! 949: /* process format string first */ ! 950: while ((fcode = *fmt++)!='%') { ! 951: /* ordinary (non-%) character */ ! 952: if (fcode=='\0') ! 953: return; ! 954: pputchar(fcode); ! 955: } ! 956: /* length modifier: -1 for h, 1 for l, 0 for none */ ! 957: length = 0; ! 958: /* check for a leading - sign */ ! 959: sign = 0; ! 960: if (*fmt == '-') { ! 961: sign++; ! 962: fmt++; ! 963: } ! 964: /* a '0' may follow the - sign */ ! 965: /* this is the requested fill character */ ! 966: fill = 1; ! 967: if (*fmt == '0') { ! 968: fill--; ! 969: fmt++; ! 970: } ! 971: ! 972: /* Now comes a digit string which may be a '*' */ ! 973: if (*fmt == '*') { ! 974: width = va_arg(ap, int); ! 975: if (width < 0) { ! 976: width = -width; ! 977: sign = !sign; ! 978: } ! 979: fmt++; ! 980: } ! 981: else { ! 982: width = 0; ! 983: while (*fmt>='0' && *fmt<='9') ! 984: width = width * 10 + (*fmt++ - '0'); ! 985: } ! 986: ! 987: /* maybe a decimal point followed by more digits (or '*') */ ! 988: if (*fmt=='.') { ! 989: if (*++fmt == '*') { ! 990: prec = va_arg(ap, int); ! 991: fmt++; ! 992: } ! 993: else { ! 994: prec = 0; ! 995: while (*fmt>='0' && *fmt<='9') ! 996: prec = prec * 10 + (*fmt++ - '0'); ! 997: } ! 998: } ! 999: else ! 1000: prec = -1; ! 1001: ! 1002: /* ! 1003: * At this point, "sign" is nonzero if there was ! 1004: * a sign, "fill" is 0 if there was a leading ! 1005: * zero and 1 otherwise, "width" and "prec" ! 1006: * contain numbers corresponding to the digit ! 1007: * strings before and after the decimal point, ! 1008: * respectively, and "fmt" addresses the next ! 1009: * character after the whole mess. If there was ! 1010: * no decimal point, "prec" will be -1. ! 1011: */ ! 1012: switch (*fmt) { ! 1013: case 'L': ! 1014: case 'l': ! 1015: length = 2; ! 1016: /* no break!! */ ! 1017: case 'h': ! 1018: case 'H': ! 1019: length--; ! 1020: fmt++; ! 1021: break; ! 1022: } ! 1023: ! 1024: /* ! 1025: * At exit from the following switch, we will ! 1026: * emit the characters starting at "bptr" and ! 1027: * ending at "ptr"-1, unless fcode is '\0'. ! 1028: */ ! 1029: switch (fcode = *fmt++) { ! 1030: /* process characters and strings first */ ! 1031: case 'c': ! 1032: buf[0] = va_arg(ap, int); ! 1033: ptr = bptr = &buf[0]; ! 1034: if (buf[0] != '\0') ! 1035: ptr++; ! 1036: break; ! 1037: case 's': ! 1038: bptr = va_arg(ap,char *); ! 1039: if (bptr==0) ! 1040: bptr = "(null pointer)"; ! 1041: if (prec < 0) ! 1042: prec = MAXINT; ! 1043: for (n=0; *bptr++ && n < prec; n++) ; ! 1044: ptr = --bptr; ! 1045: bptr -= n; ! 1046: break; ! 1047: case 'O': ! 1048: length = 1; ! 1049: fcode = 'o'; ! 1050: /* no break */ ! 1051: case 'o': ! 1052: case 'X': ! 1053: case 'x': ! 1054: if (length > 0) ! 1055: num = va_arg(ap,long); ! 1056: else ! 1057: num = (unsigned)va_arg(ap,int); ! 1058: if (fcode=='o') { ! 1059: mask1 = 0x7; ! 1060: mask2 = 0x1fffffffL; ! 1061: nbits = 3; ! 1062: } ! 1063: else { ! 1064: mask1 = 0xf; ! 1065: mask2 = 0x0fffffffL; ! 1066: nbits = 4; ! 1067: } ! 1068: n = (num!=0); ! 1069: bptr = buf + MAXOCT + 3; ! 1070: /* shift and mask for speed */ ! 1071: do ! 1072: if (((int) num & mask1) < 10) ! 1073: *--bptr = ((int) num & mask1) + 060; ! 1074: else ! 1075: *--bptr = ((int) num & mask1) + 0127; ! 1076: while (num = (num >> nbits) & mask2); ! 1077: ! 1078: if (fcode=='o') { ! 1079: if (n) ! 1080: *--bptr = '0'; ! 1081: } ! 1082: else ! 1083: if (!sign && fill <= 0) { ! 1084: pputchar('0'); ! 1085: pputchar(fcode); ! 1086: width -= 2; ! 1087: } ! 1088: else { ! 1089: *--bptr = fcode; ! 1090: *--bptr = '0'; ! 1091: } ! 1092: ptr = buf + MAXOCT + 3; ! 1093: break; ! 1094: case 'D': ! 1095: case 'U': ! 1096: case 'I': ! 1097: length = 1; ! 1098: ! 1099: fcode = fcode + 'a' - 'A'; ! 1100: /* no break */ ! 1101: case 'd': ! 1102: case 'i': ! 1103: case 'u': ! 1104: if (length > 0) ! 1105: num = va_arg(ap,long); ! 1106: else { ! 1107: n = va_arg(ap,int); ! 1108: if (fcode=='u') ! 1109: num = (unsigned) n; ! 1110: else ! 1111: num = (long) n; ! 1112: } ! 1113: if (n = (fcode != 'u' && num < 0)) ! 1114: num = -num; ! 1115: /* now convert to digits */ ! 1116: bptr = b_dconv(num, buf); ! 1117: if (n) ! 1118: *--bptr = '-'; ! 1119: if (fill == 0) ! 1120: fill = -1; ! 1121: ptr = buf + MAXDIGS + 1; ! 1122: break; ! 1123: default: ! 1124: /* not a control character, ! 1125: * print it. ! 1126: */ ! 1127: ptr = bptr = &fcode; ! 1128: ptr++; ! 1129: break; ! 1130: } ! 1131: if (fcode != '\0') ! 1132: b_emit(bptr,ptr); ! 1133: } ! 1134: va_end(ap); ! 1135: } ! 1136: ! 1137: /* b_dconv converts the unsigned long integer "value" to ! 1138: * printable decimal and places it in "buffer", right-justified. ! 1139: * The value returned is the address of the first non-zero character, ! 1140: * or the address of the last character if all are zero. ! 1141: * The result is NOT null terminated, and is MAXDIGS characters long, ! 1142: * starting at buffer[1] (to allow for insertion of a sign). ! 1143: * ! 1144: * This program assumes it is running on 2's complement machine ! 1145: * with reasonable overflow treatment. ! 1146: */ ! 1147: char * ! 1148: b_dconv(value, buffer) ! 1149: long value; ! 1150: char *buffer; ! 1151: { ! 1152: register char *bp; ! 1153: register int svalue; ! 1154: int n; ! 1155: long lval; ! 1156: ! 1157: bp = buffer; ! 1158: ! 1159: /* zero is a special case */ ! 1160: if (value == 0) { ! 1161: bp += MAXDIGS; ! 1162: *bp = '0'; ! 1163: return(bp); ! 1164: } ! 1165: ! 1166: /* develop the leading digit of the value in "n" */ ! 1167: n = 0; ! 1168: while (value < 0) { ! 1169: value -= BIG; /* will eventually underflow */ ! 1170: n++; ! 1171: } ! 1172: while ((lval = value - BIG) >= 0) { ! 1173: value = lval; ! 1174: n++; ! 1175: } ! 1176: ! 1177: /* stash it in buffer[1] to allow for a sign */ ! 1178: bp[1] = n + '0'; ! 1179: /* ! 1180: * Now develop the rest of the digits. Since speed counts here, ! 1181: * we do it in two loops. The first gets "value" down until it ! 1182: * is no larger than MAXINT. The second one uses integer divides ! 1183: * rather than long divides to speed it up. ! 1184: */ ! 1185: bp += MAXDIGS + 1; ! 1186: while (value > MAXINT) { ! 1187: *--bp = (int)(value % 10) + '0'; ! 1188: value /= 10; ! 1189: } ! 1190: ! 1191: /* cannot lose precision */ ! 1192: svalue = value; ! 1193: while (svalue > 0) { ! 1194: *--bp = (svalue % 10) + '0'; ! 1195: svalue /= 10; ! 1196: } ! 1197: ! 1198: /* fill in intermediate zeroes if needed */ ! 1199: if (buffer[1] != '0') { ! 1200: while (bp > buffer + 2) ! 1201: *--bp = '0'; ! 1202: --bp; ! 1203: } ! 1204: return(bp); ! 1205: } ! 1206: ! 1207: /* ! 1208: * This program sends string "s" to pputchar. The character after ! 1209: * the end of "s" is given by "send". This allows the size of the ! 1210: * field to be computed; it is stored in "alen". "width" contains the ! 1211: * user specified length. If width<alen, the width will be taken to ! 1212: * be alen. "sign" is zero if the string is to be right-justified ! 1213: * in the field, nonzero if it is to be left-justified. "fill" is ! 1214: * 0 if the string is to be padded with '0', positive if it is to be ! 1215: * padded with ' ', and negative if an initial '-' should appear before ! 1216: * any padding in right-justification (to avoid printing "-3" as ! 1217: * "000-3" where "-0003" was intended). ! 1218: */ ! 1219: b_emit(s, send) ! 1220: register char *s; ! 1221: char *send; ! 1222: { ! 1223: char cfill; ! 1224: register int alen; ! 1225: int npad; ! 1226: ! 1227: alen = send - s; ! 1228: if (alen > width) ! 1229: width = alen; ! 1230: cfill = fill>0? ' ': '0'; ! 1231: ! 1232: /* we may want to print a leading '-' before anything */ ! 1233: if (*s == '-' && fill < 0) { ! 1234: pputchar(*s++); ! 1235: alen--; ! 1236: width--; ! 1237: } ! 1238: npad = width - alen; ! 1239: ! 1240: /* emit any leading pad characters */ ! 1241: if (!sign) ! 1242: while (--npad >= 0) ! 1243: pputchar(cfill); ! 1244: ! 1245: /* emit the string itself */ ! 1246: while (--alen >= 0) ! 1247: pputchar(*s++); ! 1248: ! 1249: /* emit trailing pad characters */ ! 1250: if (sign) ! 1251: while (--npad >= 0) ! 1252: pputchar(cfill); ! 1253: } ! 1254: ! 1255: #ifndef UCB_PWHASH ! 1256: #define NUID 2048 ! 1257: ! 1258: char names[NUID][NMAX+1]; ! 1259: ! 1260: char * ! 1261: getname(uid) ! 1262: { ! 1263: register struct passwd *pw; ! 1264: static init; ! 1265: struct passwd *getpwent(); ! 1266: ! 1267: if (uid >= 0 && uid < NUID && names[uid][0]) ! 1268: return (&names[uid][0]); ! 1269: if (init == 2) ! 1270: return (0); ! 1271: if (init == 0) ! 1272: setpwent(), init = 1; ! 1273: while (pw = getpwent()) { ! 1274: if (pw->pw_uid < 0 || pw->pw_uid >= NUID) ! 1275: continue; ! 1276: if (names[pw->pw_uid][0]) ! 1277: continue; ! 1278: strncpy(names[pw->pw_uid], pw->pw_name, NMAX); ! 1279: if (pw->pw_uid == uid) ! 1280: return (&names[uid][0]); ! 1281: } ! 1282: init = 2; ! 1283: endpwent(); ! 1284: return (0); ! 1285: } ! 1286: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.