![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dired.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / dired|
Return to dired.c CVS log | Up to [Research Unix] / researchv10no / cmd / dired |
1.1 root 1: /*
2: **********************************************************************
3: * *
4: * dired [][dir][files] Stuart Cracraft (mclure@sri-unix) Sept 1980 *
5: * *
6: * Directory editor. *
7: * edit/delete files in a directory or a file list *
8: * compile with the berkeley termlib archive *
9: * and don't forget to change the 'helpfile' and *
10: * 'dirednam' strings to reflect your own setup. *
11: * *
12: * Note: if you make improvements, I'd like to get them too. *
13: * Stuart Cracraft mclure@sri-unix, *
14: * ucbvax!menlo70!sri-unix!mclure *
15: * so would I: Jay Lepreau lepreau@utah-20, *
16: * decvax!randvax!utah-cs!lepreau *
17: **********************************************************************
18: */
19:
20: /*
21: * Enhanced by J.Lepreau, Univ of Utah, 8-10/81:
22: * --bunch of stuff, including more cmds, 2 window mode,
23: * buffering output, pathname substition in !escapes,
24: * initial sort options, ^G escape from sorts, ^U escape
25: * from !escapes, empty dir check.
26: */
27:
28: #ifdef COMMENT
29:
30: Modified 12/81 by Lepreau:
31: 1. Fix up aborting of command escapes, with mildy tricky re-display.
32: 2. Make default window size be half-screen (2 window mode).
33: Added option -wf to get full screen.
34: 3. Add check for too many files to avoid core-dump.
35: 4. Fix bug in cmd escapes: must reset caught signals before invocation.
36:
37: #endif COMMENT
38:
39: /*
40: things to consider
41: - perhaps should be able to edit protection field and
42: be able to change protection instantly at the
43: touch of a key (or queue the change for later exit)
44:
45: -- Would be nice if there were cmds (e.g. 'c') which would update
46: 1) the file-info & re-display it, & 2) update whole
47: display's info.
48: */
49:
50: #ifdef vax /* this does for now */
51: # define VFORK
52: #endif
53:
54: #ifndef VFORK
55: # define vfork fork
56: #endif
57:
58: #define FALSE 0
59: #define TRUE 1
60: #define NOTDELETED 0
61: #define DELETED 1
62:
63: /* Sort Orders */
64: #define NAME 0
65: #define SIZE 1
66: #define WRITE 2
67: #define READ 3
68: char sortstr[] = "nswr"; /* must be in order by above */
69:
70: #define ESC '\033'
71: #define CURSOR 48 /* X-coord of cursor, just b4 file */
72: #define CTRL(c) ('c' & 037)
73:
74: #include <stdio.h>
75: #include <sys/types.h>
76: #include <signal.h>
77: #include <sgtty.h>
78: #include <sys/stat.h>
79: #ifdef BSD
80: #include <sys/dir.h>
81: #else
82: #include <ndir.h>
83: #define index strchr
84: #endif
85:
86: #ifdef UTAH
87: char *dirednam = "/usr/local/dired "; /* Where dired lives - need blnk */
88: char *helpfile = "/usr/help/dired.hlp"; /* Where helpfile lives */
89: #else
90: char *dirednam = "dired "; /* Where dired lives - need blnk */
91: char *helpfile = "/usr/lib/dired"; /* Where helpfile lives */
92: #endif
93:
94: char divider[132]; /* divides the windows */
95: #define DIVCHAR '-' /* makes up the divider */
96:
97: #define MOREPGM "p " /* program to page thru a file */
98:
99: #define MAXFILES 2000 /* Max number of files we can handle */
100: #define MAXN 30
101:
102: struct lbuf
103: {
104: union
105: {
106: char lname[MAXN];
107: char *namep;
108: } ln;
109: short deleted;
110: char ltype;
111: short lnum;
112: short lflags;
113: short lnl;
114: unsigned short luid;
115: unsigned short lgid;
116: long lsize;
117: long latime;
118: long lctime;
119: long lmtime;
120: };
121:
122: struct lbuf file[MAXFILES];
123:
124: struct stat statbuf;
125: struct sgttyb ioctlb;
126:
127: #define ISARG 0100000
128:
129: int gflg,
130: iflg,
131: lflg,
132: sflg; /* Random flags */
133: int splitflg; /* Split screen? */
134: int sortyp; /* Key to sort on */
135: int errcode; /* Error variable used by rm */
136: int rflg = 1; /* Reverse sort flag */
137: int totfiles = 0; /* Total files */
138: int flags; /* Gets flags */
139: int blurb; /* 1=>thing in echo area,0 otherwise */
140: int numdeleted; /* Number of files marked deleted */
141: long ttime; /* Temp time variable */
142: long year; /* Six months ago */
143: long totblocks = 0; /* Total blocks */
144: int lastuid = -1; /* Last uid/gid we handled */
145: char tempbuf[128]; /* Random temporary buffer */
146: char userbuf[35]; /* Temporary buffer for user name */
147: FILE *pwdf; /* Password/group file */
148:
149: int curfile = 0; /* Current file */
150: int topfile = 0; /* File at top of screen */
151: int curline = 0; /* Line that we're on */
152: int scrlen = 999; /* Length of screen - dired part: half size */
153: int Worklen = 0; /* Length of 'working window', the other part*/
154: int Worktop = 0; /* Top of " " */
155: int Tscrlen; /*Total length of screen,minus 1 for cmd line*/
156: int scrwid = 79; /* Width of screen */
157: char *CL,
158: *UP, /* Termcap strings we'll use */
159: *HO,
160: *CM,
161: *CD, /* clear to end of display */
162: *CE,
163: *AL; /* insert line */
164: char PC;
165: char tbuf[1024],
166: tcapbuf[128];
167: char *tgetstr (), *tgoto ();
168: char *getenv ();
169: int compar ();
170: char *ctime ();
171: char *index();
172: char *makename ();
173: char *catargs();
174: char *bldnam();
175: long nblock ();
176: int catchint();
177: int sigint;
178:
179: char bufout[BUFSIZ];
180:
181: main (argc, argv)
182: int argc;
183: char *argv[];
184: {
185: register int i,
186: cc;
187: int numarg,
188: special, /* flag says had % or # in cmd */
189: status;
190: char nambuf[128];
191: char command; /* Holds last command */
192: char **oldargv;
193: register char *t,
194: *tt;
195:
196: /* Get terminal type */
197:
198: getcap ();
199:
200: /* Process arg flags. They must be first! */
201: for (i=1; i<argc; i++) {
202: if (argv[i][0] != '-')
203: break;
204: switch (cc = argv[i][1]) {
205: case 'w': /* Window size */
206: if (argv[i][2] == 'h')
207: scrlen = 999; /* Half */
208: else if (argv[i][2] == 'f')
209: scrlen = 0; /* Full */
210: else
211: scrlen = atoi(&argv[i][2]);
212: break;
213: case 's': /* Initial sort order */
214: case 'r':
215: sortyp = index(sortstr, argv[i][2]) - sortstr;
216: rflg = (cc == 's') ? 1 : -1;
217: break;
218: default:
219: printf("Unknown option %s, ignored.\n", argv[i]);
220: break;
221: }
222: }
223: argc -= (i - 1);
224: oldargv = argv;
225: argv += (i - 1);
226:
227: if (scrlen == 0) /* full screen */
228: scrlen = Tscrlen;
229: else if (scrlen == 999) /* means split in half */
230: scrlen = (Tscrlen - 1) >> 1;
231: if (scrlen < 2)
232: scrlen = 2;
233: if (Tscrlen < scrlen)
234: scrlen = Tscrlen;
235: splitflg = (Tscrlen > scrlen+1); /* 1 extra line for separator */
236: if (splitflg) {
237: Worklen = Tscrlen - (scrlen+1); /* size of 'working' window */
238: Worktop = scrlen + 1; /* bottom half for now */
239: }
240: else
241: Worklen = 0;
242:
243: tt = divider + scrwid - 14;
244: for (t = divider; t < tt;) /* arbitrary length */
245: *t++ = DIVCHAR;
246: *t = '\0';
247:
248: signal (SIGINT, SIG_IGN);
249: signal (SIGQUIT, SIG_IGN);
250:
251: setdpy ();
252: printf ("Reading");
253:
254: time (&ttime);
255: year = ttime - 6L * 30L * 24L * 60L * 60L;/* 6 months ago */
256:
257: lflg = 1;
258: gflg = iflg = sflg = 0;
259: if (lflg)
260: {
261: t = "/etc/passwd";
262: if (gflg)
263: t = "/etc/group";
264: pwdf = fopen (t, "r");
265: }
266:
267:
268: numarg = argc;
269: if (argc == 1)
270: getdir (".");
271: else
272: if (argc == 2)
273: getdir (argv[1]);
274: else
275: {
276: while (--argc > 0)
277: {
278: if (totfiles == MAXFILES) {
279: overflow();
280: break;
281: }
282: if ((totfiles % 10) == 0)
283: putchar ('.');
284: if (gstat(*++argv) == 0) {
285: file[totfiles].ln.namep = *argv;
286: file[totfiles].lflags |= ISARG;
287: totfiles++;
288: }
289: }
290: }
291: if (totfiles == 0) {
292: printf("\n?Empty directory\n");
293: unsetdpy();
294: sleep(1); /* So user can see it - don't worry if less */
295: exit(0);
296: }
297: qsort (file, totfiles, sizeof (struct lbuf), compar);
298: blank ();
299: showscreen ();
300: curxy (0, Tscrlen);
301: ceol ();
302: curxy (CURSOR, 0);
303: startup:
304: while ((command = readchar()) != 'q')
305: {
306: if (blurb)
307: {
308: telluser ("");
309: blurb = 0;
310: }
311: switch (command)
312: {
313: case 'a': /* Abort completely */
314: blank ();
315: unsetdpy ();
316: exit (1);
317: break;
318: case 'P': /* Print a file */
319: case 'p': /* do a pr2 */
320: if (file[curfile].ltype == 'd')
321: {
322: telluser ("?Can only print files");
323: break;
324: }
325: tempbuf[0] = '\0';
326: bldnam(tempbuf, numarg, curfile, argv);
327: telluser ("Printing...");
328: while ((i = vfork ()) == -1)
329: sleep (3);
330: if (i == 0) {
331: #ifdef UTAH
332: if (command == 'p') /* little print */
333: execlp("pr2", "pr2", tempbuf, 0);
334: else /* big print */
335: #endif
336: execlp ("print", "print", tempbuf, 0);
337: telluser ("?Can't find program to list file.\n");
338: _exit(1);
339: }
340: wait (&status);
341: break;
342:
343: case '!': /* Execute a system command */
344: telluser ("");
345: curxy (0, Tscrlen);
346: unsetdpy ();
347: printf ("Command: ");
348: tempbuf[0] = 'x'; /* dummy kludge */
349: if (gets(tempbuf) != NULL && tempbuf[0] != '\0') {
350: extern char *skipto();
351: register char *op, /* old ptr */
352: *np; /* new ptr */
353: char bldbuf[70];
354:
355: bldbuf[0] = '\0';
356: op = tempbuf;
357: special = 0;
358: while (cc = *(np = skipto(op, "%#"))) {
359: special++; /* set flag */
360: *np++ = '\0'; /* zap the %/# and bump past it */
361: strcat(bldbuf, op); /* 1st part */
362: if (cc == '%') /* complete file name */
363: bldnam(bldbuf, numarg, curfile, argv);
364: else { /* Had # sign, trailing comp only */
365: if (numarg <= 2)
366: strcat (bldbuf, file[curfile].ln.lname);
367: else
368: strcat (bldbuf, file[curfile].ln.namep);
369: }
370:
371: op = np;
372: }
373: strcat(bldbuf, op);
374:
375: blank ();
376: if (special) { /* display expanded command */
377: printf( "%s\n", bldbuf);
378: } /* "system" takes long enuf for him to see it */
379: signal(SIGINT, SIG_DFL); /* temp kludge here... */
380: signal(SIGQUIT, SIG_DFL); /* should not use 'system' */
381: system (bldbuf);
382: signal (SIGINT, SIG_IGN);
383: signal (SIGQUIT, SIG_IGN);
384: printf ("\nCR to return...");
385: setdpy ();
386: readchar();
387: blank ();
388: showscreen ();
389: telluser ("");
390: }
391: else { /* CR only, or EOF, or error */
392: /*
393: * He changed his mind, skip it. Since we were in
394: * cooked mode, the CR ending the gets is echoed and
395: * we lost the first line of the display. So we
396: * re-insert it.
397: */
398: setdpy();
399: if (tempbuf[0] == 'x') /* means EOF */
400: telluser("");
401: /* null entry, normal case */
402: else if (AL == 0) { /* no insert line capability */
403: blank();
404: showscreen();
405: }
406: else { /* be a little sneakier */
407: curxy(0, Tscrlen-1); /* go back to where prompt */
408: ceol(); /* is now, and blank it */
409: home();
410: insline(); /* make some room */
411: pentry(topfile);
412: putchar('\n');
413: }
414: curxy(CURSOR, curline);
415: }
416: break;
417:
418: case 'r': /* Reverse sort */
419: curxy (0, Tscrlen);
420: printf ("reverse ");
421: rflg = -1;
422: case 's': /* Normal sort */
423: if (command == 's')
424: {
425: curxy (0, Tscrlen);
426: rflg = 1;
427: }
428: printf ("sort by [s,n,r,w]: ");
429: command = readchar();
430: while ((command == '?') || !((command == 'n') ||
431: (command == 'r') || (command == 'w') || (command == 's') ||
432: (command == CTRL(g))))
433: {
434: curxy (0, Tscrlen);
435: ceol ();
436: if (rflg == -1)
437: printf ("reverse ");
438: printf ("sort by size, name, read or write date: ");
439: command = readchar();
440: }
441:
442: if (command == CTRL(g)) { /* abort */
443: putchar(CTRL(g)); /* echo it */
444: telluser("");
445: curxy(CURSOR, curline);
446: break;
447: }
448:
449: if (command == 's')
450: sortyp = SIZE;
451: else
452: if (command == 'w')
453: sortyp = WRITE;
454: else
455: if (command == 'r')
456: sortyp = READ;
457: else
458: sortyp = 0;
459: printf ("%c", command);
460: qsort (file, totfiles, sizeof (struct lbuf), compar);
461: topfile = 0;
462: curfile = 0;
463: curline = 0;
464: blank ();
465: showscreen ();
466: curxy (CURSOR, 0);
467: break;
468:
469: case 'e': /* Edit a file or directory */
470: if (file[curfile].ltype == 'd') {
471: strcpy (tempbuf, dirednam);
472: catargs(tempbuf, oldargv);
473: }
474: else {
475: if ((t = getenv("EDITOR")) != NULL)
476: strcat(strcpy(tempbuf, t), " ");
477: else
478: strcpy (tempbuf, "ed ");
479: }
480: bldnam(tempbuf, numarg, curfile, argv);
481: blank ();
482: unsetdpy ();
483: system (tempbuf);
484: setdpy ();
485: blank ();
486: showscreen ();
487: telluser ("");
488: break;
489:
490: case 'm': /* 'more' a file */
491: if (file[curfile].ltype == 'd')
492: {
493: telluser ("?Can only page thru files");
494: break;
495: }
496: strcpy (tempbuf, MOREPGM);
497: bldnam(tempbuf, numarg, curfile, argv);
498: blank ();
499: unsetdpy ();
500: system (tempbuf);
501: /* if (!sigint) { */
502: printf ("\nCR to return...");
503: /* } */
504: setdpy ();
505: readchar();
506: blank ();
507: showscreen ();
508: telluser ("");
509: break;
510:
511: case 'T': /* don't wait at page end */
512: case 't': /* quickly type the file -- added 5/81, J.Lepreau */
513: if (file[curfile].ltype == 'd')
514: {
515: telluser ("?Can only type files");
516: break;
517: }
518: tempbuf[0] = '\0';
519: bldnam(tempbuf, numarg, curfile, argv);
520: if (type(tempbuf, command == 't')) /* little t means wait */
521: showscreen ();
522: curxy (CURSOR, curline);
523: break;
524:
525: case 'l': /* Refresh screen */
526: case CTRL(l): /* added for editor compatibility -fjl */
527: blank ();
528: showscreen ();
529: telluser ("");
530: break;
531: case 'c': /* Refresh current line */
532: curxy (0, curline);
533: pentry (curfile);
534: curxy (CURSOR, curline);
535: break;
536: case CTRL(v):
537: case 'f': /* forward window */
538: fscreen ();
539: break;
540: /* wish we could do meta-v */
541: case 'b': /* backward window */
542: bscreen ();
543: break;
544: case CTRL(n):
545: case '\r':
546: case '\n': /* next file */
547: if (curfile == totfiles - 1)
548: telluser ("?At end of files");
549: else
550: if (curline == scrlen - 1)
551: {
552: topfile = curfile;
553: curline = 0;
554: blank ();
555: showscreen ();
556: curxy (CURSOR, 0);
557: downline ();
558: }
559: else
560: downline ();
561: break;
562: case '^': /* previous file */
563: case CTRL(h): /* backspace */
564: case '-':
565: case CTRL(p):
566: if (curfile == 0)
567: telluser ("?At start of files");
568: else
569: if (curline == 0)
570: {
571: topfile = curfile - scrlen + 1;
572: curline = scrlen - 1;
573: blank ();
574: showscreen ();
575: curxy (CURSOR, curline);
576: upline ();
577: }
578: else
579: upline ();
580: break;
581: case 'h': /* Help */
582: case '?':
583: if (type(helpfile, 1)) /* wait */
584: showscreen ();
585: curxy (CURSOR, curline);
586: break;
587: case 'd': /* delete file */
588: if (file[curfile].deleted == DELETED)
589: telluser ("?Already marked deleted");
590: else
591: {
592: numdeleted++;
593: file[curfile].deleted = DELETED;
594: printf ("D%c", 010);
595: if (curline + 1 == scrlen)
596: {
597: fscreen ();
598: downline ();
599: }
600: else
601: if (curfile != totfiles - 1)
602: downline ();
603: }
604: break;
605: case 'u': /* undelete file */
606: if (file[curfile].deleted == NOTDELETED)
607: telluser ("?Not marked deleted");
608: else
609: {
610: numdeleted--;
611: file[curfile].deleted = NOTDELETED;
612: printf (" %c", 010);
613: }
614: break;
615: default:
616: telluser ("Unknown command. Type ? or h for help");
617: break;
618: }
619: }
620: if (numdeleted)
621: {
622: blank ();
623: printf ("The following %s marked for deletion:\n",
624: (numdeleted == 1) ? "is" : "are");
625: typefiles ();
626: printf ("\nShall I delete %s? ",
627: (numdeleted == 1) ? "this" : "these");
628: if ((command = readchar()) != 'y')
629: {
630: blank ();
631: showscreen ();
632: curxy (0, Tscrlen);
633: ceol ();
634: curxy (CURSOR, curline);
635: goto startup;
636: }
637: else
638: {
639: printf ("y\n");
640: for (i = 0; i < totfiles; i++)
641: if (file[i].deleted == DELETED) {
642: nambuf[0] = '\0';
643: bldnam(nambuf, numarg, i, argv);
644: if (file[i].ltype == 'd')
645: rm (nambuf, 0);
646: else
647: if (unlink (nambuf) < 0)
648: printf ("Delete of %s failed.\n", nambuf);
649: }
650: }
651: }
652: else
653: blank ();
654:
655: unsetdpy ();
656: exit(0);
657: }
658:
659: typefiles ()
660: {
661: int longsiz,
662: i,
663: j,
664: maxperln,
665: numout,
666: longthis;
667: longsiz = numout = 0;
668: for (i = 0; i < totfiles; i++)
669: if (file[i].deleted == DELETED)
670: if (file[i].lflags & ISARG)
671: {
672: if (strlen (file[i].ln.namep) > longsiz)
673: {
674: longsiz = strlen (file[i].ln.namep);
675: }
676: }
677: else
678: {
679: if (strlen (file[i].ln.lname) > longsiz)
680: {
681: longsiz = strlen (file[i].ln.lname);
682: }
683: }
684: maxperln = scrwid / (longsiz + 3);
685: for (i = 0; i < totfiles; i++)
686: if (file[i].deleted == DELETED)
687: {
688: if (file[i].lflags & ISARG)
689: {
690: printf ("%s", file[i].ln.namep);
691: longthis = strlen (file[i].ln.namep);
692: }
693: else
694: {
695: printf ("%.14s", file[i].ln.lname);
696: longthis = strlen (file[i].ln.lname);
697: }
698: numout++;
699: if ((numout % maxperln) == 0)
700: putchar ('\n');
701: else if (numout != numdeleted)
702: for (j = 0; j < (longsiz + 3 - longthis); j++)
703: putchar (' ');
704: }
705: }
706:
707: rm (arg, level)
708: char arg[];
709: {
710: struct stat buf;
711: struct direct direct;
712: char name[100];
713: int d;
714:
715: if (stat (arg, &buf))
716: {
717: return;
718: }
719: if ((buf.st_mode & S_IFMT) == S_IFDIR)
720: {
721: if (access (arg, 02) < 0)
722: {
723: printf ("%s not deleted.\n", arg);
724: return;
725: }
726: if ((d = open (arg, 0)) < 0)
727: {
728: printf ("rm: %s: cannot read\n", arg);
729: return;
730: }
731: while (read (d, (char *) & direct, sizeof (direct)) == sizeof (direct))
732: {
733: if (direct.d_ino != 0 && !dotname (direct.d_name))
734: {
735: sprintf (name, "%s/%.14s", arg, direct.d_name);
736: rm (name, level + 1);
737: }
738: }
739: close (d);
740: errcode += rmdir (arg);
741: return;
742: }
743:
744: if (unlink (arg))
745: {
746: ++errcode;
747: printf ("%s not deleted.\n", arg);
748: }
749: }
750:
751: dotname (s)
752: char *s;
753: {
754: if (s[0] == '.')
755: if (s[1] == '.')
756: if (s[2] == '\0')
757: return (1);
758: else
759: return (0);
760: else
761: if (s[1] == '\0')
762: return (1);
763: return (0);
764: }
765:
766: rmdir (f)
767: char *f;
768: {
769: int status,
770: i;
771:
772: if (dotname (f))
773: return (0);
774: while ((i = vfork ()) == -1)
775: sleep (3);
776: if (i == 0) {
777: execl ("/bin/rmdir", "rmdir", f, 0);
778: execl ("/usr/bin/rmdir", "rmdir", f, 0);
779: printf ("rm: can't find rmdir\n");
780: _exit(1);
781: }
782: wait (&status);
783: return (status);
784: }
785:
786: fscreen ()
787: {
788: if (topfile + scrlen - 1 > totfiles - 1)
789: telluser ("?No remaining windows");
790: else
791: {
792: topfile = topfile + scrlen - 1;
793: curfile = topfile;
794: curline = 0;
795: blank ();
796: showscreen ();
797: curxy (CURSOR, 0);
798: }
799: }
800:
801: bscreen ()
802: {
803: if (topfile - scrlen + 1 < 0)
804: telluser ("?No previous windows");
805: else
806: {
807: topfile = topfile - scrlen + 1;
808: curfile = topfile;
809: curline = 0;
810: blank ();
811: showscreen ();
812: curxy (CURSOR, 0);
813: }
814: }
815:
816: showscreen ()
817: {
818: int i,
819: numprint;
820: home ();
821: numprint = 0;
822: for (i = topfile; (numprint < scrlen) && (i < totfiles); i++)
823: {
824: numprint++;
825: pentry (i);
826: putchar ('\n');
827: }
828: if (splitflg)
829: printf ("%s\n", divider);
830: }
831:
832: getdir (dir) /* Reads directory dir */
833: char *dir;
834: {
835: static struct direct dentry;
836: register int j;
837: struct direct *dp;
838: DIR *dirf;
839:
840: if ((dirf = opendir (dir)) == NULL)
841: {
842: printf ("\nSorry, %s unreadable.\n", dir);
843: unsetdpy ();
844: exit(1);
845: }
846: for (;;)
847: {
848: if ((dp = readdir(dirf)) == NULL)
849: break;
850: dentry = *dp;
851: if (dentry.d_ino == 0
852: || dentry.d_name[0] == '.' && (dentry.d_name[1] == '\0'
853: || dentry.d_name[1] == '.' && dentry.d_name[2] == '\0'))
854: continue;
855:
856: if (totfiles == MAXFILES)
857: overflow(); /* abort, too may files */
858: /* Just ignore if can't find the file, dir may be changing */
859: if (gstat (makename (dir, dentry.d_name)) == 0) { /* 0 == Ok */
860: file[totfiles].lnum = dentry.d_ino;
861: strncpy(file[totfiles].ln.lname, dentry.d_name, MAXN);
862: totfiles++;
863: if (totfiles % 10 == 0)
864: putchar ('.');
865: }
866: }
867: closedir (dirf);
868: }
869:
870: gstat (name) /* Stats the file with name */
871: char *name;
872: {
873:
874: file[totfiles].lflags = 0;
875: file[totfiles].lnum = 0;
876: file[totfiles].ltype = '-';
877:
878: if (stat (name, &statbuf) < 0)
879: {
880: return(-1);
881: }
882: file[totfiles].lnum = statbuf.st_ino;
883: file[totfiles].lsize = statbuf.st_size;
884: switch (statbuf.st_mode & S_IFMT)
885: {
886: case S_IFLNK:
887: file[totfiles].ltype = 'l';
888: break;
889: case S_IFDIR:
890: file[totfiles].ltype = 'd';
891: break;
892: case S_IFBLK:
893: file[totfiles] .ltype = 'b';
894: file[totfiles].lsize = statbuf.st_rdev;
895: break;
896: case S_IFCHR:
897: file[totfiles].ltype = 'c';
898: file[totfiles].lsize = statbuf.st_rdev;
899: break;
900: }
901: file[totfiles].lflags = statbuf.st_mode & ~S_IFMT;
902: file[totfiles].luid = statbuf.st_uid;
903: file[totfiles].lgid = statbuf.st_gid;
904: file[totfiles].lnl = statbuf.st_nlink;
905: file[totfiles].latime = statbuf.st_atime;
906: file[totfiles].lctime = statbuf.st_ctime;
907: file[totfiles].lmtime = statbuf.st_mtime;
908: totblocks += nblock (statbuf.st_size);
909: return(0);
910: }
911:
912: char *
913: makename (dir, filen)
914: char *dir,
915: *filen;
916: {
917: static char dfile[100];
918: register char *dp,
919: *fp;
920: register int i;
921:
922: dp = dfile;
923: fp = dir;
924: while (*fp)
925: *dp++ = *fp++;
926: *dp++ = '/';
927: fp = filen;
928: strcpy(dp, fp);
929: return (dfile);
930: }
931:
932: long
933: nblock (size)
934: long size;
935: {
936: return ((size + 511) >> 9);
937: }
938:
939: pentry (whichone)
940: int whichone;
941: {
942: struct
943: {
944: char dminor,
945: dmajor;
946: };
947: register t;
948: register char *cp;
949:
950: if (file[whichone].lnum == -1)
951: return;
952: if (iflg)
953: printf ("%5u ", file[whichone].lnum);
954: if (sflg)
955: printf ("%4D ", nblock (file[whichone].lsize));
956: if (lflg)
957: {
958: putchar (file[whichone].ltype);
959: pmode (file[whichone].lflags);
960: printf ("%2d ", file[whichone].lnl);
961: t = file[whichone].luid;
962: if (gflg)
963: t = file[whichone].lgid;
964: if (getname (t, userbuf) == 0)
965: printf ("%-14.14s", userbuf);
966: else
967: printf ("%-14d", t);
968: if (file[whichone].ltype == 'b' || file[whichone].ltype == 'c')
969: printf ("%3d,%3d", major ((int) file[whichone].lsize),
970: minor ((int) file[whichone].lsize));
971: else
972: printf ("%7ld", file[whichone].lsize);
973: if ((sortyp == WRITE) || (sortyp == 0) || (sortyp == SIZE))
974: {
975: cp = ctime (&file[whichone].lmtime);
976: if (file[whichone].lmtime < year)
977: printf (" %-7.7s %-4.4s ", cp + 4, cp + 20);
978: else
979: printf (" %-12.12s ", cp + 4);
980: }
981: else
982: if (sortyp == READ)
983: {
984: cp = ctime (&file[whichone].latime);
985: if (file[whichone].latime < year)
986: printf (" %-7.7s %-4.4s ", cp + 4, cp + 20);
987: else
988: printf (" %-12.12s ", cp + 4);
989: }
990: }
991: printf ("%c", file[whichone].deleted ? 'D' : ' ');
992: if (file[whichone].lflags & ISARG)
993: printf (" %s", file[whichone].ln.namep);
994: else {
995: putchar(' ');
996: for (t=0; t<14; t++) {
997: register c = file[whichone].ln.lname[t] & 0377;;
998: if (c == '\0')
999: break;
1000: if (c<' ' || c>=0200) {
1001: c &= 0177;
1002: c |= 0100;
1003: putchar('^');
1004: }
1005: putchar(c);
1006: }
1007: }
1008: }
1009:
1010: getname (uid, buf)
1011: int uid;
1012: char buf[];
1013: {
1014: int j,
1015: c,
1016: n, sign,
1017: i;
1018:
1019: if (uid == lastuid)
1020: return (0);
1021: if (pwdf == NULL)
1022: return (-1);
1023: rewind (pwdf);
1024: lastuid = -1;
1025: do
1026: {
1027: i = 0;
1028: j = 0;
1029: n = 0;
1030: sign = 0;
1031: while ((c = fgetc (pwdf)) != '\n')
1032: {
1033: if (c == EOF)
1034: return (-1);
1035: if (c == ':')
1036: {
1037: j++;
1038: c = '0';
1039: }
1040: if (j == 0)
1041: buf[i++] = c;
1042: if (j == 2) {
1043: if (c=='-')
1044: sign = 1;
1045: else
1046: n = n * 10 + c - '0';
1047: }
1048: }
1049: if (sign)
1050: n = -n;
1051: n = (unsigned short)n;
1052: } while (n != uid);
1053: buf[i++] = '\0';
1054: lastuid = uid;
1055: return (0);
1056: }
1057:
1058: int m1[] =
1059: {
1060: 1, S_IREAD >> 0, 'r', '-'
1061: };
1062: int m2[] =
1063: {
1064: 1, S_IWRITE >> 0, 'w', '-'
1065: };
1066: int m3[] =
1067: {
1068: 2, S_ISUID, 's', S_IEXEC >> 0, 'x', '-'
1069: };
1070: int m4[] =
1071: {
1072: 1, S_IREAD >> 3, 'r', '-'
1073: };
1074: int m5[] =
1075: {
1076: 1, S_IWRITE >> 3, 'w', '-'
1077: };
1078: int m6[] =
1079: {
1080: 2, S_ISGID, 's', S_IEXEC >> 3, 'x', '-'
1081: };
1082: int m7[] =
1083: {
1084: 1, S_IREAD >> 6, 'r', '-'
1085: };
1086: int m8[] =
1087: {
1088: 1, S_IWRITE >> 6, 'w', '-'
1089: };
1090: int m9[] =
1091: {
1092: 2, 0/*S_ISVTX*/, 't', S_IEXEC >> 6, 'x', '-'
1093: };
1094:
1095: int *m[] =
1096: {
1097: m1, m2, m3, m4, m5, m6, m7, m8, m9
1098: };
1099:
1100: pmode (aflag)
1101: {
1102: register int **mp;
1103:
1104: flags = aflag;
1105: for (mp = &m[0]; mp < &m[sizeof (m) / sizeof (m[0])];)
1106: select (*mp++);
1107: }
1108:
1109: select (pairp)
1110: register int *pairp;
1111: {
1112: register int n;
1113:
1114: n = *pairp++;
1115: while (--n >= 0 && (flags & *pairp++) == 0)
1116: pairp++;
1117: putchar (*pairp);
1118: }
1119:
1120: compar (pp1, pp2)
1121: struct lbuf *pp1,
1122: *pp2;
1123: {
1124: register struct lbuf *p1,
1125: *p2;
1126:
1127: p1 = pp1;
1128: p2 = pp2;
1129: if (p1 -> lflags & ISARG && p1 -> ltype == 'd')
1130: {
1131: if (!(p2 -> lflags & ISARG && p2 -> ltype == 'd'))
1132: return (1);
1133: }
1134: else
1135: {
1136: if (p2 -> lflags & ISARG && p2 -> ltype == 'd')
1137: return (-1);
1138: }
1139: if (sortyp == SIZE)
1140: {
1141: if (p2 -> lsize == p1 -> lsize)
1142: return (0);
1143: if (p2 -> lsize > p1 -> lsize)
1144: return (rflg);
1145: return (-rflg);
1146: }
1147: else
1148: if (sortyp == WRITE)
1149: {
1150: if (p2 -> lmtime == p1 -> lmtime)
1151: return (0);
1152: if (p2 -> lmtime > p1 -> lmtime)
1153: return (rflg);
1154: return (-rflg);
1155: }
1156: else
1157: if (sortyp == READ)
1158: {
1159: if (p2 -> latime == p1 -> latime)
1160: return (0);
1161: if (p2 -> latime > p1 -> latime)
1162: return (rflg);
1163: return (-rflg);
1164: }
1165: return (rflg * strcmp (p1 -> lflags & ISARG ? p1 -> ln.namep : p1 -> ln.lname,
1166: p2 -> lflags & ISARG ? p2 -> ln.namep : p2 -> ln.lname));
1167: }
1168:
1169: ceod()
1170: {
1171: putpad(CD);
1172: }
1173:
1174: ceol ()
1175: {
1176: putpad (CE);
1177: }
1178: blank ()
1179: {
1180: putpad (CL);
1181: }
1182: home ()
1183: {
1184: if (HO)
1185: putpad (HO);
1186: else
1187: curxy(0,0);
1188: }
1189: insline ()
1190: {
1191: putpad (AL);
1192: }
1193:
1194: /* Yes, folks, we use direct cursor addressing to get to next line!
1195: Before you mumble "What sort of cretin would do this?" here's
1196: the reason. We don't use \n since that obviously won't work.
1197: We don't use \012 since virgin version 7 makes that into a crlf.
1198: We don't use raw mode since we type out help files efficently,
1199: and we don't want to switch modes all the time. So enjoy. -- SMC */
1200:
1201: downline ()
1202: {
1203: curxy (CURSOR, ++curline);
1204: curfile++;
1205: }
1206: upline ()
1207: {
1208: putpad (UP);
1209: curline--;
1210: curfile--;
1211: }
1212:
1213: /*VARARGS1*/
1214: telluser (msg, args)
1215: char *msg;
1216: {
1217: curxy (0, Tscrlen);
1218: ceol ();
1219: printf (msg, args);
1220: curxy (CURSOR, curline);
1221: blurb++;
1222: }
1223: curxy (col, lin)
1224: {
1225: char *cmstr = tgoto (CM, col, lin);
1226: putpad (cmstr);
1227: }
1228:
1229: char *fgets();
1230:
1231: type (filestr, waitflg) /* Modified to type help file & others. fjl 5/81 */
1232: char *filestr; /* Kludgy now with split screen stuff! */
1233: {
1234: int helpfd = 5;
1235: FILE *fd = stdin;
1236: char *eof;
1237: register int i, n;
1238: register int cc = 0;
1239: int cur_scrl; /* current screen length */
1240: char helpbuf[512];
1241:
1242: if (!splitflg)
1243: helpfd = open(filestr, 0);
1244: else
1245: fd = fopen(filestr, "r");
1246: if (helpfd < 0 || fd == NULL) {
1247: telluser("?Unable to open %sfile",strcmp(filestr,helpfile)?"":"help ");
1248: return (FALSE);
1249: }
1250:
1251: signal(SIGINT, catchint);
1252: sigint = 0;
1253:
1254: if (!splitflg) {
1255: blank();
1256: fflush(stdout);
1257: while ((i = read (helpfd, helpbuf, 512)) > 0 && !sigint)
1258: write (1, helpbuf, i);
1259: close(helpfd);
1260: }
1261: else {
1262: cur_scrl = totfiles - topfile + 1; /* topfile starts at 0 */
1263: Worktop = ((cur_scrl < scrlen) ? cur_scrl : scrlen) + 1;
1264: do {
1265: curxy(0, Worktop);
1266: ceod();
1267: for (i = Worktop; (i < Tscrlen) && !sigint && (cc != EOF); i++) {
1268: n = 0;
1269: while ((cc = getc(fd)) != EOF) {
1270: if (cc == '\t')
1271: n |= 07;
1272: chklen: if (n++ == scrwid-1) { /* Use most of screen */
1273: if (cc != '\n') {
1274: ungetc(cc, fd);
1275: cc = '\n';
1276: }
1277: }
1278: if (cc < ' ' && cc!='\n' && cc!='\t' || cc>=0200) {
1279: putchar('^');
1280: cc &= 0177;
1281: cc |= 0100;
1282: goto chklen;
1283: }
1284: putchar(cc);
1285: if (cc == '\n')
1286: break;
1287: }
1288: }
1289: } while (!sigint && (cc != EOF) && waitchk(waitflg));
1290:
1291: if (feof(fd))
1292: printf("===== End-of-File =====\n");
1293: fflush(stdout);
1294: fclose(fd);
1295: return(FALSE); /* means needs no re-display */
1296: }
1297:
1298: if (!splitflg) { /* redundant now... */
1299: if (!sigint) {
1300: curxy(0, Tscrlen);
1301: printf ("CR to return...");
1302: readchar();
1303: }
1304: blank ();
1305: return (TRUE);
1306: }
1307: }
1308:
1309: waitchk(waitflg)
1310: {
1311: if (!waitflg)
1312: return(1);
1313: fflush(stdout);
1314: curxy(0, Tscrlen);
1315: printf ("---Continue---");
1316: ceol();
1317: curxy(0, Tscrlen);
1318: readchar();
1319: ceol();
1320: if (sigint)
1321: return(0); /* avoids clear of screen */
1322: return(1);
1323: }
1324:
1325: setdpy ()
1326: {
1327: ioctl (0, TIOCGETP, &ioctlb);
1328: ioctlb.sg_flags |= CBREAK;
1329: ioctlb.sg_flags &= ~ECHO;
1330: ioctl (0, TIOCSETP, &ioctlb);
1331: }
1332:
1333: unsetdpy ()
1334: {
1335: ioctlb.sg_flags &= ~CBREAK;
1336: ioctlb.sg_flags |= ECHO;
1337: ioctl (0, TIOCSETP, &ioctlb);
1338: }
1339:
1340: getcap ()
1341: {
1342: char *ap;
1343: char *term;
1344: char *xPC;
1345:
1346: term = getenv ("TERM");
1347: if (term == 0)
1348: {
1349: printf("No TERM in environment\n");
1350: exit(1);
1351: }
1352:
1353: switch (tgetent (tbuf, term))
1354: {
1355: case -1:
1356: printf("Cannot open termcap file\n");
1357: exit (2);
1358: case 0:
1359: printf("%s: unknown terminal", term);
1360: exit (3);
1361: }
1362:
1363: ap = tcapbuf;
1364:
1365: Tscrlen = tgetnum ("li") - 1;
1366: scrwid = tgetnum ("co") - 1;/* lose 1 so won't scroll in last line */
1367:
1368: UP = tgetstr ("up", &ap);
1369: CD = tgetstr ("cd", &ap);
1370: CE = tgetstr ("ce", &ap);
1371: HO = tgetstr ("ho", &ap);
1372: CL = tgetstr ("cl", &ap);
1373: CM = tgetstr ("cm", &ap);
1374: AL = tgetstr ("al", &ap); /* insert line, optional */
1375:
1376: xPC = tgetstr ("pc", &ap);
1377: if (xPC)
1378: PC = *xPC;
1379:
1380: if ((CM == 0) || (CL == 0) || (UP == 0))
1381: {
1382: printf("Tty must have cursor addr, clear, and 4 cursor motions.\n");
1383: exit (1);
1384: }
1385: if (Tscrlen <= 0 || scrwid <= 0)
1386: {
1387: printf("Must know the screen size\n");
1388: exit (1);
1389: }
1390: }
1391:
1392: outch (c)
1393: {
1394: putchar (c);
1395: }
1396:
1397: putpad (str)
1398: char *str;
1399: {
1400: if (str)
1401: tputs (str, 0, outch);
1402: }
1403:
1404: catchint(sig)
1405: {
1406: signal(SIGINT, SIG_IGN); /* reset it */
1407: sigint = 1;
1408: }
1409:
1410: char *
1411: bldnam(str, numarg, filidx, argv)
1412: char *str;
1413: char *argv[];
1414: {
1415:
1416: if (numarg == 1)
1417: strcat (str, file[filidx].ln.lname);
1418: else
1419: if (numarg == 2) {
1420: strcat (str, argv[1]);
1421: strcat (str, "/");
1422: strcat (str, file[filidx].ln.lname);
1423: }
1424: else
1425: strcat (str, file[filidx].ln.namep);
1426: return(str);
1427: }
1428:
1429: char *
1430: catargs(str, argv)
1431: char *str;
1432: char *argv[];
1433: {
1434: register int i;
1435:
1436: for (++argv; *argv; argv++) {
1437: if (**argv == '-') {
1438: strcat(str, *argv);
1439: strcat(str, " ");
1440: }
1441: }
1442: return(str);
1443: }
1444:
1445: overflow()
1446: {
1447: printf("\n?Too many files\007\n");
1448: fflush(stdout);
1449: sleep(1); /* So user can see it - don't worry if less */
1450: }
1451:
1452: char *skipto (string,charset)
1453: char *charset,*string;
1454: {
1455: register char *setp,*strp;
1456: register int found;
1457:
1458: found = 0; /* not found yet */
1459: strp = string; /* start at first char */
1460:
1461: while (*strp && !found) { /* until null or found */
1462: /* find first char in charset matching *strp */
1463: for (setp=charset; (*setp) && (*setp != *strp); setp++) ;
1464: if (*setp) found = 1; /* matches a char */
1465: else strp++; /* else keep looking */
1466: }
1467:
1468: return (strp);
1469: }
1470:
1471: readchar()
1472: {
1473: static neofs;
1474: register c;
1475:
1476: fflush(stdout);
1477: c = getchar();
1478: if (c == EOF)
1479: if (++neofs > 100)
1480: exit(1);
1481: return(c);
1482: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.