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