![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ls.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / bin|
Return to ls.c CVS log | Up to [CSRG BSD Unix] / 42BSD / bin |
1.1 root 1: #ifndef lint
2: static char *sccsid = "@(#)ls.c 4.20 (Berkeley) 9/22/83";
3: #endif
4:
5: /*
6: * ls
7: *
8: * 4.2bsd version for symbolic links, variable length
9: * directory entries, block size in the inode, etc.
10: */
11: #include <sys/param.h>
12: #include <sys/stat.h>
13: #include <sys/dir.h>
14: #include <stdio.h>
15: #include <sgtty.h>
16:
17: #define kbytes(size) (((size) + 1023) / 1024)
18:
19: struct afile {
20: char ftype; /* file type, e.g. 'd', 'c', 'f' */
21: ino_t fnum; /* inode number of file */
22: short fflags; /* mode&~S_IFMT, perhaps ISARG */
23: short fnl; /* number of links */
24: short fuid; /* owner id */
25: short fgid; /* group id */
26: long fsize; /* file size */
27: long fblks; /* number of blocks used */
28: time_t fmtime; /* time (modify or access or create) */
29: char *fname; /* file name */
30: char *flinkto; /* symbolic link value */
31: };
32:
33: #define ISARG 0x8000 /* extra ``mode'' */
34:
35: struct subdirs {
36: char *sd_name;
37: struct subdirs *sd_next;
38: } *subdirs;
39:
40: int aflg, dflg, gflg, lflg, sflg, tflg, uflg, iflg, fflg, cflg, rflg = 1;
41: int qflg, Aflg, Cflg, Fflg, Lflg, Rflg;
42:
43: int usetabs;
44:
45: time_t now, sixmonthsago;
46:
47: char *dotp = ".";
48:
49: struct afile *gstat();
50: int fcmp();
51: char *cat(), *savestr();
52: char *fmtentry();
53: char *getname(), *getgroup();
54:
55: char *ctime();
56: char *malloc(), *calloc(), *realloc();
57: char *sprintf(), *strcpy(), *strcat();
58:
59: main(argc, argv)
60: int argc;
61: char *argv[];
62: {
63: int i;
64: struct afile *fp0, *fplast;
65: register struct afile *fp;
66: struct sgttyb sgbuf;
67:
68: argc--, argv++;
69: if (getuid() == 0)
70: Aflg++;
71: (void) time(&now); sixmonthsago = now - 6L*30L*24L*60L*60L; now += 60;
72: if (isatty(1)) {
73: qflg = Cflg = 1;
74: (void) gtty(1, &sgbuf);
75: if ((sgbuf.sg_flags & XTABS) == 0)
76: usetabs = 1;
77: } else
78: usetabs = 1;
79: while (argc > 0 && **argv == '-') {
80: (*argv)++;
81: while (**argv) switch (*(*argv)++) {
82:
83: case 'C':
84: Cflg = 1; break;
85: case 'q':
86: qflg = 1; break;
87: case '1':
88: Cflg = 0; break;
89: case 'a':
90: aflg++; break;
91: case 'A':
92: Aflg++; break;
93: case 'c':
94: cflg++; break;
95: case 's':
96: sflg++; break;
97: case 'd':
98: dflg++; break;
99: case 'g':
100: gflg++; break;
101: case 'l':
102: lflg++; break;
103: case 'r':
104: rflg = -1; break;
105: case 't':
106: tflg++; break;
107: case 'u':
108: uflg++; break;
109: case 'i':
110: iflg++; break;
111: case 'f':
112: fflg++; break;
113: case 'L':
114: Lflg++; break;
115: case 'F':
116: Fflg++; break;
117: case 'R':
118: Rflg++; break;
119: }
120: argc--, argv++;
121: }
122: if (fflg) {
123: aflg++; lflg = 0; sflg = 0; tflg = 0;
124: }
125: if (lflg)
126: Cflg = 0;
127: if (argc == 0) {
128: argc++;
129: argv = &dotp;
130: }
131: fp = (struct afile *)calloc(argc, sizeof (struct afile));
132: if (fp == 0) {
133: fprintf(stderr, "ls: out of memory\n");
134: exit(1);
135: }
136: fp0 = fp;
137: for (i = 0; i < argc; i++) {
138: if (gstat(fp, *argv, 1, (int *)0)) {
139: fp->fname = *argv;
140: fp->fflags |= ISARG;
141: fp++;
142: }
143: argv++;
144: }
145: fplast = fp;
146: qsort(fp0, fplast - fp0, sizeof (struct afile), fcmp);
147: if (dflg) {
148: formatf(fp0, fplast);
149: exit(0);
150: }
151: if (fflg)
152: fp = fp0;
153: else {
154: for (fp = fp0; fp < fplast && fp->ftype != 'd'; fp++)
155: continue;
156: formatf(fp0, fp);
157: }
158: if (fp < fplast) {
159: if (fp > fp0)
160: printf("\n");
161: for (;;) {
162: formatd(fp->fname, argc > 1);
163: while (subdirs) {
164: struct subdirs *t;
165:
166: t = subdirs; subdirs = t->sd_next;
167: printf("\n");
168: formatd(t->sd_name, 1);
169: cfree(t->sd_name);
170: cfree((char *)t);
171: }
172: if (++fp == fplast)
173: break;
174: printf("\n");
175: }
176: }
177: exit(0);
178: }
179:
180: formatd(name, title)
181: char *name;
182: int title;
183: {
184: register struct afile *fp;
185: register struct subdirs *dp;
186: struct afile *dfp0, *dfplast;
187: int nkb;
188:
189: nkb = getdir(name, &dfp0, &dfplast);
190: if (dfp0 == 0)
191: return;
192: if (fflg == 0)
193: qsort(dfp0, dfplast - dfp0, sizeof (struct afile), fcmp);
194: if (title)
195: printf("%s:\n", name);
196: if (lflg || sflg)
197: printf("total %ld\n", nkb);
198: formatf(dfp0, dfplast);
199: if (Rflg)
200: for (fp = dfplast; fp >= dfp0; fp--) {
201: if (fp->ftype != 'd' ||
202: !strcmp(fp->fname, ".") ||
203: !strcmp(fp->fname, ".."))
204: continue;
205: dp = (struct subdirs *)malloc(sizeof (struct subdirs));
206: dp->sd_name = savestr(cat(name, fp->fname));
207: dp->sd_next = subdirs; subdirs = dp;
208: }
209: for (fp = dfp0; fp < dfplast; fp++) {
210: if ((fp->fflags&ISARG) == 0 && fp->fname)
211: cfree(fp->fname);
212: if (fp->flinkto)
213: cfree(fp->flinkto);
214: }
215: cfree((char *)dfp0);
216: }
217:
218: getdir(dir, pfp0, pfplast)
219: char *dir;
220: struct afile **pfp0, **pfplast;
221: {
222: register struct afile *fp;
223: DIR *dirp;
224: register struct direct *dp;
225: int nb, nent = 20;
226:
227: dirp = opendir(dir);
228: if (dirp == NULL) {
229: *pfp0 = *pfplast = NULL;
230: printf("%s unreadable\n", dir); /* not stderr! */
231: return (0);
232: }
233: fp = *pfp0 = (struct afile *)calloc(nent, sizeof (struct afile));
234: *pfplast = *pfp0 + nent;
235: nb = 0;
236: while (dp = readdir(dirp)) {
237: if (dp->d_ino == 0)
238: continue;
239: if (aflg == 0 && dp->d_name[0]=='.' &&
240: (Aflg == 0 || dp->d_name[1]==0 ||
241: dp->d_name[1]=='.' && dp->d_name[2]==0))
242: continue;
243: if (gstat(fp, cat(dir, dp->d_name), Fflg+Rflg, &nb) == 0)
244: continue;
245: fp->fnum = dp->d_ino;
246: fp->fname = savestr(dp->d_name);
247: fp++;
248: if (fp == *pfplast) {
249: *pfp0 = (struct afile *)realloc((char *)*pfp0,
250: 2 * nent * sizeof (struct afile));
251: if (*pfp0 == 0) {
252: fprintf(stderr, "ls: out of memory\n");
253: exit(1);
254: }
255: fp = *pfp0 + nent;
256: *pfplast = fp + nent;
257: nent *= 2;
258: }
259: }
260: closedir(dirp);
261: *pfplast = fp;
262: return (kbytes(dbtob(nb)));
263: }
264:
265: int stat(), lstat();
266:
267: struct afile *
268: gstat(fp, file, statarg, pnb)
269: register struct afile *fp;
270: char *file;
271: int statarg, *pnb;
272: {
273: int (*statf)() = Lflg ? stat : lstat;
274: char buf[BUFSIZ]; int cc;
275: static struct afile azerofile;
276:
277: *fp = azerofile;
278: fp->fflags = 0;
279: fp->fnum = 0;
280: fp->ftype = '-';
281: if (statarg || sflg || lflg || tflg) {
282: struct stat stb, stb1;
283:
284: if ((*statf)(file, &stb) < 0) {
285: if (statf == lstat || lstat(file, &stb) < 0) {
286: fprintf(stderr, "%s not found\n", file);
287: return (0);
288: }
289: }
290: fp->fblks = stb.st_blocks;
291: fp->fsize = stb.st_size;
292: switch (stb.st_mode & S_IFMT) {
293:
294: case S_IFDIR:
295: fp->ftype = 'd'; break;
296: case S_IFBLK:
297: fp->ftype = 'b'; fp->fsize = stb.st_rdev; break;
298: case S_IFCHR:
299: fp->ftype = 'c'; fp->fsize = stb.st_rdev; break;
300: case S_IFSOCK:
301: fp->ftype = 's'; fp->fsize = 0; break;
302: case S_IFLNK:
303: fp->ftype = 'l';
304: if (lflg) {
305: cc = readlink(file, buf, BUFSIZ);
306: if (cc >= 0) {
307: buf[cc] = 0;
308: fp->flinkto = savestr(buf);
309: }
310: break;
311: }
312: if (stat(file, &stb1) < 0)
313: break;
314: if ((stb1.st_mode & S_IFMT) == S_IFDIR) {
315: stb = stb1;
316: fp->ftype = 'd';
317: fp->fsize = stb.st_size;
318: fp->fblks = stb.st_blocks;
319: }
320: break;
321: }
322: fp->fnum = stb.st_ino;
323: fp->fflags = stb.st_mode & ~S_IFMT;
324: fp->fnl = stb.st_nlink;
325: fp->fuid = stb.st_uid;
326: fp->fgid = stb.st_gid;
327: if (uflg)
328: fp->fmtime = stb.st_atime;
329: else if (cflg)
330: fp->fmtime = stb.st_ctime;
331: else
332: fp->fmtime = stb.st_mtime;
333: if (pnb)
334: *pnb += stb.st_blocks;
335: }
336: return (fp);
337: }
338:
339: formatf(fp0, fplast)
340: struct afile *fp0, *fplast;
341: {
342: register struct afile *fp;
343: int width = 0, w, nentry = fplast - fp0;
344: int i, j, columns, lines;
345: char *cp;
346:
347: if (fp0 == fplast)
348: return;
349: if (lflg || Cflg == 0)
350: columns = 1;
351: else {
352: for (fp = fp0; fp < fplast; fp++) {
353: int len = strlen(fmtentry(fp));
354:
355: if (len > width)
356: width = len;
357: }
358: if (usetabs)
359: width = (width + 8) &~ 7;
360: else
361: width += 2;
362: columns = 80 / width;
363: if (columns == 0)
364: columns = 1;
365: }
366: lines = (nentry + columns - 1) / columns;
367: for (i = 0; i < lines; i++) {
368: for (j = 0; j < columns; j++) {
369: fp = fp0 + j * lines + i;
370: cp = fmtentry(fp);
371: printf("%s", cp);
372: if (fp + lines >= fplast) {
373: printf("\n");
374: break;
375: }
376: w = strlen(cp);
377: while (w < width)
378: if (usetabs) {
379: w = (w + 8) &~ 7;
380: putchar('\t');
381: } else {
382: w++;
383: putchar(' ');
384: }
385: }
386: }
387: }
388:
389: fcmp(f1, f2)
390: register struct afile *f1, *f2;
391: {
392:
393: if (dflg == 0 && fflg == 0) {
394: if ((f1->fflags&ISARG) && f1->ftype == 'd') {
395: if ((f2->fflags&ISARG) == 0 || f2->ftype != 'd')
396: return (1);
397: } else {
398: if ((f2->fflags&ISARG) && f2->ftype == 'd')
399: return (-1);
400: }
401: }
402: if (tflg) {
403: if (f2->fmtime == f1->fmtime)
404: return (0);
405: if (f2->fmtime > f1->fmtime)
406: return (rflg);
407: return (-rflg);
408: }
409: return (rflg * strcmp(f1->fname, f2->fname));
410: }
411:
412: char *
413: cat(dir, file)
414: char *dir, *file;
415: {
416: static char dfile[BUFSIZ];
417:
418: if (strlen(dir)+1+strlen(file)+1 > BUFSIZ) {
419: fprintf(stderr, "ls: filename too long\n");
420: exit(1);
421: }
422: if (!strcmp(dir, "") || !strcmp(dir, ".")) {
423: (void) strcpy(dfile, file);
424: return (dfile);
425: }
426: (void) strcpy(dfile, dir);
427: if (dir[strlen(dir) - 1] != '/' && *file != '/')
428: (void) strcat(dfile, "/");
429: (void) strcat(dfile, file);
430: return (dfile);
431: }
432:
433: char *
434: savestr(str)
435: char *str;
436: {
437: char *cp = malloc(strlen(str) + 1);
438:
439: if (cp == NULL) {
440: fprintf(stderr, "ls: out of memory\n");
441: exit(1);
442: }
443: (void) strcpy(cp, str);
444: return (cp);
445: }
446:
447: char *fmtinum(), *fmtsize(), *fmtlstuff(), *fmtmode();
448:
449: char *
450: fmtentry(fp)
451: register struct afile *fp;
452: {
453: static char fmtres[BUFSIZ];
454: register char *cp, *dp;
455:
456: (void) sprintf(fmtres, "%s%s%s",
457: iflg ? fmtinum(fp) : "",
458: sflg ? fmtsize(fp) : "",
459: lflg ? fmtlstuff(fp) : "");
460: dp = &fmtres[strlen(fmtres)];
461: for (cp = fp->fname; *cp; cp++)
462: if (qflg && (*cp < ' ' || *cp >= 0177))
463: *dp++ = '?';
464: else
465: *dp++ = *cp;
466: if (Fflg) {
467: if (fp->ftype == 'd')
468: *dp++ = '/';
469: else if (fp->ftype == 'l')
470: *dp++ = '@';
471: else if (fp->ftype == 's')
472: *dp++ = '=';
473: else if (fp->fflags & 0111)
474: *dp++ = '*';
475: }
476: if (lflg && fp->flinkto) {
477: (void) strcpy(dp, " -> "); dp += 4;
478: for (cp = fp->flinkto; *cp; cp++)
479: if (qflg && (*cp < ' ' || *cp >= 0177))
480: *dp++ = '?';
481: else
482: *dp++ = *cp;
483: }
484: *dp++ = 0;
485: return (fmtres);
486: }
487:
488: char *
489: fmtinum(p)
490: register struct afile *p;
491: {
492: static char inumbuf[8];
493:
494: (void) sprintf(inumbuf, "%5d ", p->fnum);
495: return (inumbuf);
496: }
497:
498: char *
499: fmtsize(p)
500: register struct afile *p;
501: {
502: static char sizebuf[32];
503:
504: (void) sprintf(sizebuf, "%4ld ", kbytes(dbtob(p->fblks)));
505: return (sizebuf);
506: }
507:
508: char *
509: fmtlstuff(p)
510: register struct afile *p;
511: {
512: static char lstuffbuf[256];
513: char gname[32], uname[32], fsize[32], ftime[32];
514: register char *lp = lstuffbuf;
515:
516: /* type mode uname gname fsize ftime */
517: /* get uname */
518: { char *cp = getname(p->fuid);
519: if (cp)
520: (void) sprintf(uname, "%-9.9s", cp);
521: else
522: (void) sprintf(uname, "%-9d", p->fuid);
523: }
524: /* get gname */
525: if (gflg) {
526: char *cp = getgroup(p->fgid);
527: if (cp)
528: (void) sprintf(gname, "%-9.9s", cp);
529: else
530: (void) sprintf(gname, "%-9d", p->fgid);
531: }
532: /* get fsize */
533: if (p->ftype == 'b' || p->ftype == 'c')
534: (void) sprintf(fsize, "%3d,%4d",
535: major(p->fsize), minor(p->fsize));
536: else if (p->ftype == 's')
537: (void) sprintf(fsize, "%8ld", 0);
538: else
539: (void) sprintf(fsize, "%8ld", p->fsize);
540: /* get ftime */
541: { char *cp = ctime(&p->fmtime);
542: if ((p->fmtime < sixmonthsago) || (p->fmtime > now))
543: (void) sprintf(ftime, " %-7.7s %-4.4s ", cp+4, cp+20);
544: else
545: (void) sprintf(ftime, " %-12.12s ", cp+4);
546: }
547: /* splat */
548: *lp++ = p->ftype;
549: lp = fmtmode(lp, p->fflags);
550: (void) sprintf(lp, "%3d %s%s%s%s",
551: p->fnl, uname, gflg ? gname : "", fsize, ftime);
552: return (lstuffbuf);
553: }
554:
555: int m1[] = { 1, S_IREAD>>0, 'r', '-' };
556: int m2[] = { 1, S_IWRITE>>0, 'w', '-' };
557: int m3[] = { 2, S_ISUID, 's', S_IEXEC>>0, 'x', '-' };
558: int m4[] = { 1, S_IREAD>>3, 'r', '-' };
559: int m5[] = { 1, S_IWRITE>>3, 'w', '-' };
560: int m6[] = { 2, S_ISGID, 's', S_IEXEC>>3, 'x', '-' };
561: int m7[] = { 1, S_IREAD>>6, 'r', '-' };
562: int m8[] = { 1, S_IWRITE>>6, 'w', '-' };
563: int m9[] = { 2, S_ISVTX, 't', S_IEXEC>>6, 'x', '-' };
564:
565: int *m[] = { m1, m2, m3, m4, m5, m6, m7, m8, m9};
566:
567: char *
568: fmtmode(lp, flags)
569: char *lp;
570: int flags;
571: {
572: int **mp;
573:
574: for (mp = &m[0]; mp < &m[sizeof(m)/sizeof(m[0])]; ) {
575: register int *pairp = *mp++;
576: register int n = *pairp++;
577:
578: while (--n >= 0 && (flags&*pairp++) == 0)
579: pairp++;
580: *lp++ = *pairp;
581: }
582: return (lp);
583: }
584:
585: /* rest should be done with nameserver or database */
586:
587: #include <pwd.h>
588: #include <grp.h>
589: #include <utmp.h>
590:
591: struct utmp utmp;
592: #define NMAX (sizeof (utmp.ut_name))
593: #define SCPYN(a, b) strncpy(a, b, NMAX)
594:
595: #define NUID 2048
596: #define NGID 300
597:
598: char names[NUID][NMAX+1];
599: char outrangename[NMAX+1];
600: int outrangeuid = -1;
601: char groups[NGID][NMAX+1];
602: char outrangegroup[NMAX+1];
603: int outrangegid = -1;
604:
605: char *
606: getname(uid)
607: {
608: register struct passwd *pw;
609: static init;
610: struct passwd *getpwent();
611:
612: if (uid >= 0 && uid < NUID && names[uid][0])
613: return (&names[uid][0]);
614: if (uid >= 0 && uid == outrangeuid)
615: return (outrangename);
616: rescan:
617: if (init == 2) {
618: if (uid < NUID)
619: return (0);
620: setpwent();
621: while (pw = getpwent()) {
622: if (pw->pw_uid != uid)
623: continue;
624: outrangeuid = pw->pw_uid;
625: SCPYN(outrangename, pw->pw_name);
626: endpwent();
627: return (outrangename);
628: }
629: endpwent();
630: return (0);
631: }
632: if (init == 0)
633: setpwent(), init = 1;
634: while (pw = getpwent()) {
635: if (pw->pw_uid < 0 || pw->pw_uid >= NUID) {
636: if (pw->pw_uid == uid) {
637: outrangeuid = pw->pw_uid;
638: SCPYN(outrangename, pw->pw_name);
639: return (outrangename);
640: }
641: continue;
642: }
643: if (names[pw->pw_uid][0])
644: continue;
645: SCPYN(names[pw->pw_uid], pw->pw_name);
646: if (pw->pw_uid == uid)
647: return (&names[uid][0]);
648: }
649: init = 2;
650: goto rescan;
651: }
652:
653: char *
654: getgroup(gid)
655: {
656: register struct group *gr;
657: static init;
658: struct group *getgrent();
659:
660: if (gid >= 0 && gid < NGID && groups[gid][0])
661: return (&groups[gid][0]);
662: if (gid >= 0 && gid == outrangegid)
663: return (outrangegroup);
664: rescan:
665: if (init == 2) {
666: if (gid < NGID)
667: return (0);
668: setgrent();
669: while (gr = getgrent()) {
670: if (gr->gr_gid != gid)
671: continue;
672: outrangegid = gr->gr_gid;
673: SCPYN(outrangegroup, gr->gr_name);
674: endgrent();
675: return (outrangegroup);
676: }
677: endgrent();
678: return (0);
679: }
680: if (init == 0)
681: setgrent(), init = 1;
682: while (gr = getgrent()) {
683: if (gr->gr_gid < 0 || gr->gr_gid >= NGID) {
684: if (gr->gr_gid == gid) {
685: outrangegid = gr->gr_gid;
686: SCPYN(outrangegroup, gr->gr_name);
687: return (outrangegroup);
688: }
689: continue;
690: }
691: if (groups[gr->gr_gid][0])
692: continue;
693: SCPYN(groups[gr->gr_gid], gr->gr_name);
694: if (gr->gr_gid == gid)
695: return (&groups[gid][0]);
696: }
697: init = 2;
698: goto rescan;
699: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.