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