![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to interactive.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / etc / restore|
Return to interactive.c CVS log | Up to [CSRG BSD Unix] / 43BSD / etc / restore |
1.1 root 1: /*
2: * Copyright (c) 1985 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)interactive.c 5.3 (Berkeley) 7/21/85";
9: #endif not lint
10:
11: #include "restore.h"
12: #include <protocols/dumprestore.h>
13: #include <setjmp.h>
14:
15: #define round(a, b) (((a) + (b) - 1) / (b) * (b))
16:
17: /*
18: * Things to handle interruptions.
19: */
20: static jmp_buf reset;
21: static char *nextarg = NULL;
22:
23: /*
24: * Structure and routines associated with listing directories.
25: */
26: struct afile {
27: ino_t fnum; /* inode number of file */
28: char *fname; /* file name */
29: short fflags; /* extraction flags, if any */
30: char ftype; /* file type, e.g. LEAF or NODE */
31: };
32: struct arglist {
33: struct afile *head; /* start of argument list */
34: struct afile *last; /* end of argument list */
35: struct afile *base; /* current list arena */
36: int nent; /* maximum size of list */
37: char *cmd; /* the current command */
38: };
39: extern int fcmp();
40: extern char *fmtentry();
41: char *copynext();
42:
43: /*
44: * Read and execute commands from the terminal.
45: */
46: runcmdshell()
47: {
48: register struct entry *np;
49: ino_t ino;
50: static struct arglist alist = { 0, 0, 0, 0, 0 };
51: char curdir[MAXPATHLEN];
52: char name[MAXPATHLEN];
53: char cmd[BUFSIZ];
54:
55: canon("/", curdir);
56: loop:
57: if (setjmp(reset) != 0) {
58: for (; alist.head < alist.last; alist.head++)
59: freename(alist.head->fname);
60: nextarg = NULL;
61: volno = 0;
62: }
63: getcmd(curdir, cmd, name, &alist);
64: switch (cmd[0]) {
65: /*
66: * Add elements to the extraction list.
67: */
68: case 'a':
69: ino = dirlookup(name);
70: if (ino == 0)
71: break;
72: if (mflag)
73: pathcheck(name);
74: treescan(name, ino, addfile);
75: break;
76: /*
77: * Change working directory.
78: */
79: case 'c':
80: ino = dirlookup(name);
81: if (ino == 0)
82: break;
83: if (inodetype(ino) == LEAF) {
84: fprintf(stderr, "%s: not a directory\n", name);
85: break;
86: }
87: (void) strcpy(curdir, name);
88: break;
89: /*
90: * Delete elements from the extraction list.
91: */
92: case 'd':
93: np = lookupname(name);
94: if (np == NIL || (np->e_flags & NEW) == 0) {
95: fprintf(stderr, "%s: not on extraction list\n", name);
96: break;
97: }
98: treescan(name, np->e_ino, deletefile);
99: break;
100: /*
101: * Extract the requested list.
102: */
103: case 'e':
104: createfiles();
105: createlinks();
106: setdirmodes();
107: if (dflag)
108: checkrestore();
109: volno = 0;
110: break;
111: /*
112: * List available commands.
113: */
114: case 'h':
115: case '?':
116: fprintf(stderr, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
117: "Available commands are:\n",
118: "\tls [arg] - list directory\n",
119: "\tcd arg - change directory\n",
120: "\tpwd - print current directory\n",
121: "\tadd [arg] - add `arg' to list of",
122: " files to be extracted\n",
123: "\tdelete [arg] - delete `arg' from",
124: " list of files to be extracted\n",
125: "\textract - extract requested files\n",
126: "\tsetmodes - set modes of requested directories\n",
127: "\tquit - immediately exit program\n",
128: "\tverbose - toggle verbose flag",
129: " (useful with ``ls'')\n",
130: "\thelp or `?' - print this list\n",
131: "If no `arg' is supplied, the current",
132: " directory is used\n");
133: break;
134: /*
135: * List a directory.
136: */
137: case 'l':
138: ino = dirlookup(name);
139: if (ino == 0)
140: break;
141: printlist(name, ino, curdir);
142: break;
143: /*
144: * Print current directory.
145: */
146: case 'p':
147: if (curdir[1] == '\0')
148: fprintf(stderr, "/\n");
149: else
150: fprintf(stderr, "%s\n", &curdir[1]);
151: break;
152: /*
153: * Quit.
154: */
155: case 'q':
156: case 'x':
157: return;
158: /*
159: * Toggle verbose mode.
160: */
161: case 'v':
162: if (vflag) {
163: fprintf(stderr, "verbose mode off\n");
164: vflag = 0;
165: break;
166: }
167: fprintf(stderr, "verbose mode on\n");
168: vflag++;
169: break;
170: /*
171: * Just restore requested directory modes.
172: */
173: case 's':
174: setdirmodes();
175: break;
176: /*
177: * Turn on debugging.
178: */
179: case 'D':
180: if (dflag) {
181: fprintf(stderr, "debugging mode off\n");
182: dflag = 0;
183: break;
184: }
185: fprintf(stderr, "debugging mode on\n");
186: dflag++;
187: break;
188: /*
189: * Unknown command.
190: */
191: default:
192: fprintf(stderr, "%s: unknown command; type ? for help\n", cmd);
193: break;
194: }
195: goto loop;
196: }
197:
198: /*
199: * Read and parse an interactive command.
200: * The first word on the line is assigned to "cmd". If
201: * there are no arguments on the command line, then "curdir"
202: * is returned as the argument. If there are arguments
203: * on the line they are returned one at a time on each
204: * successive call to getcmd. Each argument is first assigned
205: * to "name". If it does not start with "/" the pathname in
206: * "curdir" is prepended to it. Finally "canon" is called to
207: * eliminate any embedded ".." components.
208: */
209: getcmd(curdir, cmd, name, ap)
210: char *curdir, *cmd, *name;
211: struct arglist *ap;
212: {
213: register char *cp;
214: static char input[BUFSIZ];
215: char output[BUFSIZ];
216: # define rawname input /* save space by reusing input buffer */
217:
218: /*
219: * Check to see if still processing arguments.
220: */
221: if (ap->head != ap->last) {
222: strcpy(name, ap->head->fname);
223: freename(ap->head->fname);
224: ap->head++;
225: return;
226: }
227: if (nextarg != NULL)
228: goto getnext;
229: /*
230: * Read a command line and trim off trailing white space.
231: */
232: do {
233: fprintf(stderr, "restore > ");
234: (void) fflush(stderr);
235: (void) fgets(input, BUFSIZ, terminal);
236: } while (!feof(terminal) && input[0] == '\n');
237: if (feof(terminal)) {
238: (void) strcpy(cmd, "quit");
239: return;
240: }
241: for (cp = &input[strlen(input) - 2]; *cp == ' ' || *cp == '\t'; cp--)
242: /* trim off trailing white space and newline */;
243: *++cp = '\0';
244: /*
245: * Copy the command into "cmd".
246: */
247: cp = copynext(input, cmd);
248: ap->cmd = cmd;
249: /*
250: * If no argument, use curdir as the default.
251: */
252: if (*cp == '\0') {
253: (void) strcpy(name, curdir);
254: return;
255: }
256: nextarg = cp;
257: /*
258: * Find the next argument.
259: */
260: getnext:
261: cp = copynext(nextarg, rawname);
262: if (*cp == '\0')
263: nextarg = NULL;
264: else
265: nextarg = cp;
266: /*
267: * If it an absolute pathname, canonicalize it and return it.
268: */
269: if (rawname[0] == '/') {
270: canon(rawname, name);
271: } else {
272: /*
273: * For relative pathnames, prepend the current directory to
274: * it then canonicalize and return it.
275: */
276: (void) strcpy(output, curdir);
277: (void) strcat(output, "/");
278: (void) strcat(output, rawname);
279: canon(output, name);
280: }
281: expandarg(name, ap);
282: strcpy(name, ap->head->fname);
283: freename(ap->head->fname);
284: ap->head++;
285: # undef rawname
286: }
287:
288: /*
289: * Strip off the next token of the input.
290: */
291: char *
292: copynext(input, output)
293: char *input, *output;
294: {
295: register char *cp, *bp;
296: char quote;
297:
298: for (cp = input; *cp == ' ' || *cp == '\t'; cp++)
299: /* skip to argument */;
300: bp = output;
301: while (*cp != ' ' && *cp != '\t' && *cp != '\0') {
302: /*
303: * Handle back slashes.
304: */
305: if (*cp == '\\') {
306: if (*++cp == '\0') {
307: fprintf(stderr,
308: "command lines cannot be continued\n");
309: continue;
310: }
311: *bp++ = *cp++;
312: continue;
313: }
314: /*
315: * The usual unquoted case.
316: */
317: if (*cp != '\'' && *cp != '"') {
318: *bp++ = *cp++;
319: continue;
320: }
321: /*
322: * Handle single and double quotes.
323: */
324: quote = *cp++;
325: while (*cp != quote && *cp != '\0')
326: *bp++ = *cp++ | 0200;
327: if (*cp++ == '\0') {
328: fprintf(stderr, "missing %c\n", quote);
329: cp--;
330: continue;
331: }
332: }
333: *bp = '\0';
334: return (cp);
335: }
336:
337: /*
338: * Canonicalize file names to always start with ``./'' and
339: * remove any imbedded "." and ".." components.
340: */
341: canon(rawname, canonname)
342: char *rawname, *canonname;
343: {
344: register char *cp, *np;
345: int len;
346:
347: if (strcmp(rawname, ".") == 0 || strncmp(rawname, "./", 2) == 0)
348: (void) strcpy(canonname, "");
349: else if (rawname[0] == '/')
350: (void) strcpy(canonname, ".");
351: else
352: (void) strcpy(canonname, "./");
353: (void) strcat(canonname, rawname);
354: /*
355: * Eliminate multiple and trailing '/'s
356: */
357: for (cp = np = canonname; *np != '\0'; cp++) {
358: *cp = *np++;
359: while (*cp == '/' && *np == '/')
360: np++;
361: }
362: *cp = '\0';
363: if (*--cp == '/')
364: *cp = '\0';
365: /*
366: * Eliminate extraneous "." and ".." from pathnames.
367: */
368: for (np = canonname; *np != '\0'; ) {
369: np++;
370: cp = np;
371: while (*np != '/' && *np != '\0')
372: np++;
373: if (np - cp == 1 && *cp == '.') {
374: cp--;
375: (void) strcpy(cp, np);
376: np = cp;
377: }
378: if (np - cp == 2 && strncmp(cp, "..", 2) == 0) {
379: cp--;
380: while (cp > &canonname[1] && *--cp != '/')
381: /* find beginning of name */;
382: (void) strcpy(cp, np);
383: np = cp;
384: }
385: }
386: }
387:
388: /*
389: * globals (file name generation)
390: *
391: * "*" in params matches r.e ".*"
392: * "?" in params matches r.e. "."
393: * "[...]" in params matches character class
394: * "[...a-z...]" in params matches a through z.
395: */
396: expandarg(arg, ap)
397: char *arg;
398: register struct arglist *ap;
399: {
400: static struct afile single;
401: int size;
402:
403: ap->head = ap->last = (struct afile *)0;
404: size = expand(arg, 0, ap);
405: if (size == 0) {
406: single.fnum = lookupname(arg)->e_ino;
407: single.fname = savename(arg);
408: ap->head = &single;
409: ap->last = ap->head + 1;
410: return;
411: }
412: qsort((char *)ap->head, ap->last - ap->head, sizeof *ap->head, fcmp);
413: }
414:
415: /*
416: * Expand a file name
417: */
418: expand(as, rflg, ap)
419: char *as;
420: int rflg;
421: register struct arglist *ap;
422: {
423: int count, size;
424: char dir = 0;
425: char *rescan = 0;
426: DIR *dirp;
427: register char *s, *cs;
428: int sindex, rindex, lindex;
429: struct direct *dp;
430: register char slash;
431: register char *rs;
432: register char c;
433:
434: /*
435: * check for meta chars
436: */
437: s = cs = as;
438: slash = 0;
439: while (*cs != '*' && *cs != '?' && *cs != '[') {
440: if (*cs++ == 0) {
441: if (rflg && slash)
442: break;
443: else
444: return (0) ;
445: } else if (*cs == '/') {
446: slash++;
447: }
448: }
449: for (;;) {
450: if (cs == s) {
451: s = "";
452: break;
453: } else if (*--cs == '/') {
454: *cs = 0;
455: if (s == cs)
456: s = "/";
457: break;
458: }
459: }
460: if ((dirp = rst_opendir(s)) != NULL)
461: dir++;
462: count = 0;
463: if (*cs == 0)
464: *cs++ = 0200;
465: if (dir) {
466: /*
467: * check for rescan
468: */
469: rs = cs;
470: do {
471: if (*rs == '/') {
472: rescan = rs;
473: *rs = 0;
474: }
475: } while (*rs++);
476: sindex = ap->last - ap->head;
477: while ((dp = rst_readdir(dirp)) != NULL && dp->d_ino != 0) {
478: if (!dflag && BIT(dp->d_ino, dumpmap) == 0)
479: continue;
480: if ((*dp->d_name == '.' && *cs != '.'))
481: continue;
482: if (gmatch(dp->d_name, cs)) {
483: if (addg(dp, s, rescan, ap) < 0)
484: return (-1);
485: count++;
486: }
487: }
488: if (rescan) {
489: rindex = sindex;
490: lindex = ap->last - ap->head;
491: if (count) {
492: count = 0;
493: while (rindex < lindex) {
494: size = expand(ap->head[rindex].fname,
495: 1, ap);
496: if (size < 0)
497: return (size);
498: count += size;
499: rindex++;
500: }
501: }
502: bcopy((char *)&ap->head[lindex],
503: (char *)&ap->head[sindex],
504: (ap->last - &ap->head[rindex]) * sizeof *ap->head);
505: ap->last -= lindex - sindex;
506: *rescan = '/';
507: }
508: }
509: s = as;
510: while (c = *s)
511: *s++ = (c&0177 ? c : '/');
512: return (count);
513: }
514:
515: /*
516: * Check for a name match
517: */
518: gmatch(s, p)
519: register char *s, *p;
520: {
521: register int scc;
522: char c;
523: char ok;
524: int lc;
525:
526: if (scc = *s++)
527: if ((scc &= 0177) == 0)
528: scc = 0200;
529: switch (c = *p++) {
530:
531: case '[':
532: ok = 0;
533: lc = 077777;
534: while (c = *p++) {
535: if (c == ']') {
536: return (ok ? gmatch(s, p) : 0);
537: } else if (c == '-') {
538: if (lc <= scc && scc <= (*p++))
539: ok++ ;
540: } else {
541: if (scc == (lc = (c&0177)))
542: ok++ ;
543: }
544: }
545: return (0);
546:
547: default:
548: if ((c&0177) != scc)
549: return (0) ;
550: /* falls through */
551:
552: case '?':
553: return (scc ? gmatch(s, p) : 0);
554:
555: case '*':
556: if (*p == 0)
557: return (1) ;
558: s--;
559: while (*s) {
560: if (gmatch(s++, p))
561: return (1);
562: }
563: return (0);
564:
565: case 0:
566: return (scc == 0);
567: }
568: }
569:
570: /*
571: * Construct a matched name.
572: */
573: addg(dp, as1, as3, ap)
574: struct direct *dp;
575: char *as1, *as3;
576: struct arglist *ap;
577: {
578: register char *s1, *s2;
579: register int c;
580: char buf[BUFSIZ];
581:
582: s2 = buf;
583: s1 = as1;
584: while (c = *s1++) {
585: if ((c &= 0177) == 0) {
586: *s2++ = '/';
587: break;
588: }
589: *s2++ = c;
590: }
591: s1 = dp->d_name;
592: while (*s2 = *s1++)
593: s2++;
594: if (s1 = as3) {
595: *s2++ = '/';
596: while (*s2++ = *++s1)
597: /* void */;
598: }
599: if (mkentry(buf, dp->d_ino, ap) == FAIL)
600: return (-1);
601: }
602:
603: /*
604: * Do an "ls" style listing of a directory
605: */
606: printlist(name, ino, basename)
607: char *name;
608: ino_t ino;
609: char *basename;
610: {
611: register struct afile *fp;
612: register struct direct *dp;
613: static struct arglist alist = { 0, 0, 0, 0, "ls" };
614: struct afile single;
615: DIR *dirp;
616:
617: if ((dirp = rst_opendir(name)) == NULL) {
618: single.fnum = ino;
619: single.fname = savename(name + strlen(basename) + 1);
620: alist.head = &single;
621: alist.last = alist.head + 1;
622: } else {
623: alist.head = (struct afile *)0;
624: fprintf(stderr, "%s:\n", name);
625: while (dp = rst_readdir(dirp)) {
626: if (dp == NULL || dp->d_ino == 0)
627: break;
628: if (!dflag && BIT(dp->d_ino, dumpmap) == 0)
629: continue;
630: if (vflag == 0 &&
631: (strcmp(dp->d_name, ".") == 0 ||
632: strcmp(dp->d_name, "..") == 0))
633: continue;
634: if (!mkentry(dp->d_name, dp->d_ino, &alist))
635: return;
636: }
637: }
638: if (alist.head != 0) {
639: qsort((char *)alist.head, alist.last - alist.head,
640: sizeof *alist.head, fcmp);
641: formatf(&alist);
642: for (fp = alist.head; fp < alist.last; fp++)
643: freename(fp->fname);
644: }
645: if (dirp != NULL)
646: fprintf(stderr, "\n");
647: }
648:
649: /*
650: * Read the contents of a directory.
651: */
652: mkentry(name, ino, ap)
653: char *name;
654: ino_t ino;
655: register struct arglist *ap;
656: {
657: register struct afile *fp;
658:
659: if (ap->base == NULL) {
660: ap->nent = 20;
661: ap->base = (struct afile *)calloc((unsigned)ap->nent,
662: sizeof (struct afile));
663: if (ap->base == NULL) {
664: fprintf(stderr, "%s: out of memory\n", ap->cmd);
665: return (FAIL);
666: }
667: }
668: if (ap->head == 0)
669: ap->head = ap->last = ap->base;
670: fp = ap->last;
671: fp->fnum = ino;
672: fp->fname = savename(name);
673: fp++;
674: if (fp == ap->head + ap->nent) {
675: ap->base = (struct afile *)realloc((char *)ap->base,
676: (unsigned)(2 * ap->nent * sizeof (struct afile)));
677: if (ap->base == 0) {
678: fprintf(stderr, "%s: out of memory\n", ap->cmd);
679: return (FAIL);
680: }
681: ap->head = ap->base;
682: fp = ap->head + ap->nent;
683: ap->nent *= 2;
684: }
685: ap->last = fp;
686: return (GOOD);
687: }
688:
689: /*
690: * Print out a pretty listing of a directory
691: */
692: formatf(ap)
693: register struct arglist *ap;
694: {
695: register struct afile *fp;
696: struct entry *np;
697: int width = 0, w, nentry = ap->last - ap->head;
698: int i, j, len, columns, lines;
699: char *cp;
700:
701: if (ap->head == ap->last)
702: return;
703: for (fp = ap->head; fp < ap->last; fp++) {
704: fp->ftype = inodetype(fp->fnum);
705: np = lookupino(fp->fnum);
706: if (np != NIL)
707: fp->fflags = np->e_flags;
708: else
709: fp->fflags = 0;
710: len = strlen(fmtentry(fp));
711: if (len > width)
712: width = len;
713: }
714: width += 2;
715: columns = 80 / width;
716: if (columns == 0)
717: columns = 1;
718: lines = (nentry + columns - 1) / columns;
719: for (i = 0; i < lines; i++) {
720: for (j = 0; j < columns; j++) {
721: fp = ap->head + j * lines + i;
722: cp = fmtentry(fp);
723: fprintf(stderr, "%s", cp);
724: if (fp + lines >= ap->last) {
725: fprintf(stderr, "\n");
726: break;
727: }
728: w = strlen(cp);
729: while (w < width) {
730: w++;
731: fprintf(stderr, " ");
732: }
733: }
734: }
735: }
736:
737: /*
738: * Comparison routine for qsort.
739: */
740: fcmp(f1, f2)
741: register struct afile *f1, *f2;
742: {
743:
744: return (strcmp(f1->fname, f2->fname));
745: }
746:
747: /*
748: * Format a directory entry.
749: */
750: char *
751: fmtentry(fp)
752: register struct afile *fp;
753: {
754: static char fmtres[BUFSIZ];
755: static int precision = 0;
756: int i;
757: register char *cp, *dp;
758:
759: if (!vflag) {
760: fmtres[0] = '\0';
761: } else {
762: if (precision == 0)
763: for (i = maxino; i > 0; i /= 10)
764: precision++;
765: (void) sprintf(fmtres, "%*d ", precision, fp->fnum);
766: }
767: dp = &fmtres[strlen(fmtres)];
768: if (dflag && BIT(fp->fnum, dumpmap) == 0)
769: *dp++ = '^';
770: else if ((fp->fflags & NEW) != 0)
771: *dp++ = '*';
772: else
773: *dp++ = ' ';
774: for (cp = fp->fname; *cp; cp++)
775: if (!vflag && (*cp < ' ' || *cp >= 0177))
776: *dp++ = '?';
777: else
778: *dp++ = *cp;
779: if (fp->ftype == NODE)
780: *dp++ = '/';
781: *dp++ = 0;
782: return (fmtres);
783: }
784:
785: /*
786: * respond to interrupts
787: */
788: onintr()
789: {
790: if (command == 'i')
791: longjmp(reset, 1);
792: if (reply("restore interrupted, continue") == FAIL)
793: done(1);
794: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.