![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tape.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 tape.c CVS log | Up to [CSRG BSD Unix] / 43BSD / etc / restore |
1.1 root 1: /*
2: * Copyright (c) 1983 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[] = "@(#)tape.c 5.6 (Berkeley) 5/2/86";
9: #endif not lint
10:
11: #include "restore.h"
12: #include <protocols/dumprestore.h>
13: #include <sys/ioctl.h>
14: #include <sys/mtio.h>
15: #include <sys/file.h>
16: #include <setjmp.h>
17: #include <sys/stat.h>
18:
19: static long fssize = MAXBSIZE;
20: static int mt = -1;
21: static int pipein = 0;
22: static char magtape[BUFSIZ];
23: static int bct;
24: static char *tbf;
25: static union u_spcl endoftapemark;
26: static long blksread;
27: static long tapesread;
28: static jmp_buf restart;
29: static int gettingfile = 0; /* restart has a valid frame */
30:
31: static int ofile;
32: static char *map;
33: static char lnkbuf[MAXPATHLEN + 1];
34: static int pathlen;
35:
36: int Bcvt; /* Swap Bytes (for CCI or sun) */
37: static int Qcvt; /* Swap quads (for sun) */
38: /*
39: * Set up an input source
40: */
41: setinput(source)
42: char *source;
43: {
44: #ifdef RRESTORE
45: char *host, *tape;
46: #endif RRESTORE
47:
48: flsht();
49: if (bflag)
50: newtapebuf(ntrec);
51: else
52: newtapebuf(NTREC > HIGHDENSITYTREC ? NTREC : HIGHDENSITYTREC);
53: terminal = stdin;
54: #ifdef RRESTORE
55: host = source;
56: tape = index(host, ':');
57: if (tape == 0) {
58: nohost:
59: msg("need keyletter ``f'' and device ``host:tape''\n");
60: done(1);
61: }
62: *tape++ = '\0';
63: (void) strcpy(magtape, tape);
64: if (rmthost(host) == 0)
65: done(1);
66: setuid(getuid()); /* no longer need or want root privileges */
67: #else
68: if (strcmp(source, "-") == 0) {
69: /*
70: * Since input is coming from a pipe we must establish
71: * our own connection to the terminal.
72: */
73: terminal = fopen("/dev/tty", "r");
74: if (terminal == NULL) {
75: perror("Cannot open(\"/dev/tty\")");
76: terminal = fopen("/dev/null", "r");
77: if (terminal == NULL) {
78: perror("Cannot open(\"/dev/null\")");
79: done(1);
80: }
81: }
82: pipein++;
83: }
84: (void) strcpy(magtape, source);
85: #endif RRESTORE
86: }
87:
88: newtapebuf(size)
89: long size;
90: {
91: static tbfsize = -1;
92:
93: ntrec = size;
94: if (size <= tbfsize)
95: return;
96: if (tbf != NULL)
97: free(tbf);
98: tbf = (char *)malloc(size * TP_BSIZE);
99: if (tbf == NULL) {
100: fprintf(stderr, "Cannot allocate space for tape buffer\n");
101: done(1);
102: }
103: tbfsize = size;
104: }
105:
106: /*
107: * Verify that the tape drive can be accessed and
108: * that it actually is a dump tape.
109: */
110: setup()
111: {
112: int i, j, *ip;
113: struct stat stbuf;
114: extern char *ctime();
115: extern int xtrmap(), xtrmapskip();
116:
117: vprintf(stdout, "Verify tape and initialize maps\n");
118: #ifdef RRESTORE
119: if ((mt = rmtopen(magtape, 0)) < 0)
120: #else
121: if (pipein)
122: mt = 0;
123: else if ((mt = open(magtape, 0)) < 0)
124: #endif
125: {
126: perror(magtape);
127: done(1);
128: }
129: volno = 1;
130: setdumpnum();
131: flsht();
132: if (!pipein && !bflag)
133: findtapeblksize();
134: if (gethead(&spcl) == FAIL) {
135: bct--; /* push back this block */
136: cvtflag++;
137: if (gethead(&spcl) == FAIL) {
138: fprintf(stderr, "Tape is not a dump tape\n");
139: done(1);
140: }
141: fprintf(stderr, "Converting to new file system format.\n");
142: }
143: if (pipein) {
144: endoftapemark.s_spcl.c_magic = cvtflag ? OFS_MAGIC : NFS_MAGIC;
145: endoftapemark.s_spcl.c_type = TS_END;
146: ip = (int *)&endoftapemark;
147: j = sizeof(union u_spcl) / sizeof(int);
148: i = 0;
149: do
150: i += *ip++;
151: while (--j);
152: endoftapemark.s_spcl.c_checksum = CHECKSUM - i;
153: }
154: if (vflag || command == 't') {
155: fprintf(stdout, "Dump date: %s", ctime(&spcl.c_date));
156: fprintf(stdout, "Dumped from: %s", ctime(&spcl.c_ddate));
157: }
158: dumptime = spcl.c_ddate;
159: dumpdate = spcl.c_date;
160: if (stat(".", &stbuf) < 0) {
161: perror("cannot stat .");
162: done(1);
163: }
164: if (stbuf.st_blksize > 0 && stbuf.st_blksize <= MAXBSIZE)
165: fssize = stbuf.st_blksize;
166: if (((fssize - 1) & fssize) != 0) {
167: fprintf(stderr, "bad block size %d\n", fssize);
168: done(1);
169: }
170: if (checkvol(&spcl, (long)1) == FAIL) {
171: fprintf(stderr, "Tape is not volume 1 of the dump\n");
172: done(1);
173: }
174: if (readhdr(&spcl) == FAIL)
175: panic("no header after volume mark!\n");
176: findinode(&spcl, 1);
177: if (checktype(&spcl, TS_CLRI) == FAIL) {
178: fprintf(stderr, "Cannot find file removal list\n");
179: done(1);
180: }
181: maxino = (spcl.c_count * TP_BSIZE * NBBY) + 1;
182: dprintf(stdout, "maxino = %d\n", maxino);
183: map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY));
184: if (map == (char *)NIL)
185: panic("no memory for file removal list\n");
186: clrimap = map;
187: curfile.action = USING;
188: getfile(xtrmap, xtrmapskip);
189: if (checktype(&spcl, TS_BITS) == FAIL) {
190: fprintf(stderr, "Cannot find file dump list\n");
191: done(1);
192: }
193: map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY));
194: if (map == (char *)NULL)
195: panic("no memory for file dump list\n");
196: dumpmap = map;
197: curfile.action = USING;
198: getfile(xtrmap, xtrmapskip);
199: }
200:
201: /*
202: * Prompt user to load a new dump volume.
203: * "Nextvol" is the next suggested volume to use.
204: * This suggested volume is enforced when doing full
205: * or incremental restores, but can be overrridden by
206: * the user when only extracting a subset of the files.
207: */
208: getvol(nextvol)
209: long nextvol;
210: {
211: long newvol;
212: long savecnt, i;
213: union u_spcl tmpspcl;
214: # define tmpbuf tmpspcl.s_spcl
215:
216: if (nextvol == 1) {
217: tapesread = 0;
218: gettingfile = 0;
219: }
220: if (pipein) {
221: if (nextvol != 1)
222: panic("Changing volumes on pipe input?\n");
223: if (volno == 1)
224: return;
225: goto gethdr;
226: }
227: savecnt = blksread;
228: again:
229: if (pipein)
230: done(1); /* pipes do not get a second chance */
231: if (command == 'R' || command == 'r' || curfile.action != SKIP)
232: newvol = nextvol;
233: else
234: newvol = 0;
235: while (newvol <= 0) {
236: if (tapesread == 0) {
237: fprintf(stderr, "%s%s%s%s%s",
238: "You have not read any tapes yet.\n",
239: "Unless you know which volume your",
240: " file(s) are on you should start\n",
241: "with the last volume and work",
242: " towards towards the first.\n");
243: } else {
244: fprintf(stderr, "You have read volumes");
245: strcpy(tbf, ": ");
246: for (i = 1; i < 32; i++)
247: if (tapesread & (1 << i)) {
248: fprintf(stderr, "%s%d", tbf, i);
249: strcpy(tbf, ", ");
250: }
251: fprintf(stderr, "\n");
252: }
253: do {
254: fprintf(stderr, "Specify next volume #: ");
255: (void) fflush(stderr);
256: (void) fgets(tbf, BUFSIZ, terminal);
257: } while (!feof(terminal) && tbf[0] == '\n');
258: if (feof(terminal))
259: done(1);
260: newvol = atoi(tbf);
261: if (newvol <= 0) {
262: fprintf(stderr,
263: "Volume numbers are positive numerics\n");
264: }
265: }
266: if (newvol == volno) {
267: tapesread |= 1 << volno;
268: return;
269: }
270: closemt();
271: fprintf(stderr, "Mount tape volume %d\n", newvol);
272: fprintf(stderr, "then enter tape name (default: %s) ", magtape);
273: (void) fflush(stderr);
274: (void) fgets(tbf, BUFSIZ, terminal);
275: if (feof(terminal))
276: done(1);
277: if (tbf[0] != '\n') {
278: (void) strcpy(magtape, tbf);
279: magtape[strlen(magtape) - 1] = '\0';
280: }
281: #ifdef RRESTORE
282: if ((mt = rmtopen(magtape, 0)) == -1)
283: #else
284: if ((mt = open(magtape, 0)) == -1)
285: #endif
286: {
287: fprintf(stderr, "Cannot open %s\n", magtape);
288: volno = -1;
289: goto again;
290: }
291: gethdr:
292: volno = newvol;
293: setdumpnum();
294: flsht();
295: if (readhdr(&tmpbuf) == FAIL) {
296: fprintf(stderr, "tape is not dump tape\n");
297: volno = 0;
298: goto again;
299: }
300: if (checkvol(&tmpbuf, volno) == FAIL) {
301: fprintf(stderr, "Wrong volume (%d)\n", tmpbuf.c_volume);
302: volno = 0;
303: goto again;
304: }
305: if (tmpbuf.c_date != dumpdate || tmpbuf.c_ddate != dumptime) {
306: fprintf(stderr, "Wrong dump date\n\tgot: %s",
307: ctime(&tmpbuf.c_date));
308: fprintf(stderr, "\twanted: %s", ctime(&dumpdate));
309: volno = 0;
310: goto again;
311: }
312: tapesread |= 1 << volno;
313: blksread = savecnt;
314: if (curfile.action == USING) {
315: if (volno == 1)
316: panic("active file into volume 1\n");
317: return;
318: }
319: (void) gethead(&spcl);
320: findinode(&spcl, curfile.action == UNKNOWN ? 1 : 0);
321: if (gettingfile) {
322: gettingfile = 0;
323: longjmp(restart, 1);
324: }
325: }
326:
327: /*
328: * handle multiple dumps per tape by skipping forward to the
329: * appropriate one.
330: */
331: setdumpnum()
332: {
333: struct mtop tcom;
334:
335: if (dumpnum == 1 || volno != 1)
336: return;
337: if (pipein) {
338: fprintf(stderr, "Cannot have multiple dumps on pipe input\n");
339: done(1);
340: }
341: tcom.mt_op = MTFSF;
342: tcom.mt_count = dumpnum - 1;
343: #ifdef RRESTORE
344: rmtioctl(MTFSF, dumpnum - 1);
345: #else
346: if (ioctl(mt, (int)MTIOCTOP, (char *)&tcom) < 0)
347: perror("ioctl MTFSF");
348: #endif
349: }
350:
351: extractfile(name)
352: char *name;
353: {
354: int mode;
355: time_t timep[2];
356: struct entry *ep;
357: extern int xtrlnkfile(), xtrlnkskip();
358: extern int xtrfile(), xtrskip();
359:
360: curfile.name = name;
361: curfile.action = USING;
362: timep[0] = curfile.dip->di_atime;
363: timep[1] = curfile.dip->di_mtime;
364: mode = curfile.dip->di_mode;
365: switch (mode & IFMT) {
366:
367: default:
368: fprintf(stderr, "%s: unknown file mode 0%o\n", name, mode);
369: skipfile();
370: return (FAIL);
371:
372: case IFSOCK:
373: vprintf(stdout, "skipped socket %s\n", name);
374: skipfile();
375: return (GOOD);
376:
377: case IFDIR:
378: if (mflag) {
379: ep = lookupname(name);
380: if (ep == NIL || ep->e_flags & EXTRACT)
381: panic("unextracted directory %s\n", name);
382: skipfile();
383: return (GOOD);
384: }
385: vprintf(stdout, "extract file %s\n", name);
386: return (genliteraldir(name, curfile.ino));
387:
388: case IFLNK:
389: lnkbuf[0] = '\0';
390: pathlen = 0;
391: getfile(xtrlnkfile, xtrlnkskip);
392: if (pathlen == 0) {
393: vprintf(stdout,
394: "%s: zero length symbolic link (ignored)\n", name);
395: return (GOOD);
396: }
397: return (linkit(lnkbuf, name, SYMLINK));
398:
399: case IFCHR:
400: case IFBLK:
401: vprintf(stdout, "extract special file %s\n", name);
402: if (mknod(name, mode, (int)curfile.dip->di_rdev) < 0) {
403: fprintf(stderr, "%s: ", name);
404: (void) fflush(stderr);
405: perror("cannot create special file");
406: skipfile();
407: return (FAIL);
408: }
409: (void) chown(name, curfile.dip->di_uid, curfile.dip->di_gid);
410: (void) chmod(name, mode);
411: skipfile();
412: utime(name, timep);
413: return (GOOD);
414:
415: case IFREG:
416: vprintf(stdout, "extract file %s\n", name);
417: if ((ofile = creat(name, 0666)) < 0) {
418: fprintf(stderr, "%s: ", name);
419: (void) fflush(stderr);
420: perror("cannot create file");
421: skipfile();
422: return (FAIL);
423: }
424: (void) fchown(ofile, curfile.dip->di_uid, curfile.dip->di_gid);
425: (void) fchmod(ofile, mode);
426: getfile(xtrfile, xtrskip);
427: (void) close(ofile);
428: utime(name, timep);
429: return (GOOD);
430: }
431: /* NOTREACHED */
432: }
433:
434: /*
435: * skip over bit maps on the tape
436: */
437: skipmaps()
438: {
439:
440: while (checktype(&spcl, TS_CLRI) == GOOD ||
441: checktype(&spcl, TS_BITS) == GOOD)
442: skipfile();
443: }
444:
445: /*
446: * skip over a file on the tape
447: */
448: skipfile()
449: {
450: extern int null();
451:
452: curfile.action = SKIP;
453: getfile(null, null);
454: }
455:
456: /*
457: * Do the file extraction, calling the supplied functions
458: * with the blocks
459: */
460: getfile(f1, f2)
461: int (*f2)(), (*f1)();
462: {
463: register int i;
464: int curblk = 0;
465: off_t size = spcl.c_dinode.di_size;
466: static char clearedbuf[MAXBSIZE];
467: char buf[MAXBSIZE / TP_BSIZE][TP_BSIZE];
468: char junk[TP_BSIZE];
469:
470: if (checktype(&spcl, TS_END) == GOOD)
471: panic("ran off end of tape\n");
472: if (ishead(&spcl) == FAIL)
473: panic("not at beginning of a file\n");
474: if (!gettingfile && setjmp(restart) != 0)
475: return;
476: gettingfile++;
477: loop:
478: for (i = 0; i < spcl.c_count; i++) {
479: if (spcl.c_addr[i]) {
480: readtape(&buf[curblk++][0]);
481: if (curblk == fssize / TP_BSIZE) {
482: (*f1)(buf, size > TP_BSIZE ?
483: (long) (fssize) :
484: (curblk - 1) * TP_BSIZE + size);
485: curblk = 0;
486: }
487: } else {
488: if (curblk > 0) {
489: (*f1)(buf, size > TP_BSIZE ?
490: (long) (curblk * TP_BSIZE) :
491: (curblk - 1) * TP_BSIZE + size);
492: curblk = 0;
493: }
494: (*f2)(clearedbuf, size > TP_BSIZE ?
495: (long) TP_BSIZE : size);
496: }
497: if ((size -= TP_BSIZE) <= 0) {
498: for (i++; i < spcl.c_count; i++)
499: if (spcl.c_addr[i])
500: readtape(junk);
501: break;
502: }
503: }
504: if (readhdr(&spcl) == GOOD && size > 0) {
505: if (checktype(&spcl, TS_ADDR) == GOOD)
506: goto loop;
507: dprintf(stdout, "Missing address (header) block for %s\n",
508: curfile.name);
509: }
510: if (curblk > 0)
511: (*f1)(buf, (curblk * TP_BSIZE) + size);
512: findinode(&spcl, 1);
513: gettingfile = 0;
514: }
515:
516: /*
517: * The next routines are called during file extraction to
518: * put the data into the right form and place.
519: */
520: xtrfile(buf, size)
521: char *buf;
522: long size;
523: {
524:
525: if (write(ofile, buf, (int) size) == -1) {
526: fprintf(stderr, "write error extracting inode %d, name %s\n",
527: curfile.ino, curfile.name);
528: perror("write");
529: done(1);
530: }
531: }
532:
533: xtrskip(buf, size)
534: char *buf;
535: long size;
536: {
537:
538: #ifdef lint
539: buf = buf;
540: #endif
541: if (lseek(ofile, size, 1) == (long)-1) {
542: fprintf(stderr, "seek error extracting inode %d, name %s\n",
543: curfile.ino, curfile.name);
544: perror("lseek");
545: done(1);
546: }
547: }
548:
549: xtrlnkfile(buf, size)
550: char *buf;
551: long size;
552: {
553:
554: pathlen += size;
555: if (pathlen > MAXPATHLEN) {
556: fprintf(stderr, "symbolic link name: %s->%s%s; too long %d\n",
557: curfile.name, lnkbuf, buf, pathlen);
558: done(1);
559: }
560: (void) strcat(lnkbuf, buf);
561: }
562:
563: xtrlnkskip(buf, size)
564: char *buf;
565: long size;
566: {
567:
568: #ifdef lint
569: buf = buf, size = size;
570: #endif
571: fprintf(stderr, "unallocated block in symbolic link %s\n",
572: curfile.name);
573: done(1);
574: }
575:
576: xtrmap(buf, size)
577: char *buf;
578: long size;
579: {
580:
581: bcopy(buf, map, size);
582: map += size;
583: }
584:
585: xtrmapskip(buf, size)
586: char *buf;
587: long size;
588: {
589:
590: #ifdef lint
591: buf = buf;
592: #endif
593: panic("hole in map\n");
594: map += size;
595: }
596:
597: null() {;}
598:
599: /*
600: * Do the tape i/o, dealing with volume changes
601: * etc..
602: */
603: readtape(b)
604: char *b;
605: {
606: register long i;
607: long rd, newvol;
608: int cnt;
609:
610: if (bct < ntrec) {
611: bcopy(&tbf[(bct++*TP_BSIZE)], b, (long)TP_BSIZE);
612: blksread++;
613: return;
614: }
615: for (i = 0; i < ntrec; i++)
616: ((struct s_spcl *)&tbf[i*TP_BSIZE])->c_magic = 0;
617: bct = 0;
618: cnt = ntrec*TP_BSIZE;
619: rd = 0;
620: getmore:
621: #ifdef RRESTORE
622: i = rmtread(&tbf[rd], cnt);
623: #else
624: i = read(mt, &tbf[rd], cnt);
625: #endif
626: if (i > 0 && i != ntrec*TP_BSIZE) {
627: if (pipein) {
628: rd += i;
629: cnt -= i;
630: if (cnt > 0)
631: goto getmore;
632: i = rd;
633: } else {
634: if (i % TP_BSIZE != 0)
635: panic("partial block read: %d should be %d\n",
636: i, ntrec * TP_BSIZE);
637: bcopy((char *)&endoftapemark, &tbf[i],
638: (long)TP_BSIZE);
639: }
640: }
641: if (i < 0) {
642: fprintf(stderr, "Tape read error while ");
643: switch (curfile.action) {
644: default:
645: fprintf(stderr, "trying to set up tape\n");
646: break;
647: case UNKNOWN:
648: fprintf(stderr, "trying to resyncronize\n");
649: break;
650: case USING:
651: fprintf(stderr, "restoring %s\n", curfile.name);
652: break;
653: case SKIP:
654: fprintf(stderr, "skipping over inode %d\n",
655: curfile.ino);
656: break;
657: }
658: if (!yflag && !reply("continue"))
659: done(1);
660: i = ntrec*TP_BSIZE;
661: bzero(tbf, i);
662: #ifdef RRESTORE
663: if (rmtseek(i, 1) < 0)
664: #else
665: if (lseek(mt, i, 1) == (long)-1)
666: #endif
667: {
668: perror("continuation failed");
669: done(1);
670: }
671: }
672: if (i == 0) {
673: if (!pipein) {
674: newvol = volno + 1;
675: volno = 0;
676: getvol(newvol);
677: readtape(b);
678: return;
679: }
680: if (rd % TP_BSIZE != 0)
681: panic("partial block read: %d should be %d\n",
682: rd, ntrec * TP_BSIZE);
683: bcopy((char *)&endoftapemark, &tbf[rd], (long)TP_BSIZE);
684: }
685: bcopy(&tbf[(bct++*TP_BSIZE)], b, (long)TP_BSIZE);
686: blksread++;
687: }
688:
689: findtapeblksize()
690: {
691: register long i;
692:
693: for (i = 0; i < ntrec; i++)
694: ((struct s_spcl *)&tbf[i * TP_BSIZE])->c_magic = 0;
695: bct = 0;
696: #ifdef RRESTORE
697: i = rmtread(tbf, ntrec * TP_BSIZE);
698: #else
699: i = read(mt, tbf, ntrec * TP_BSIZE);
700: #endif
701: if (i <= 0) {
702: perror("Tape read error");
703: done(1);
704: }
705: if (i % TP_BSIZE != 0) {
706: fprintf(stderr, "Tape block size (%d) %s (%d)\n",
707: i, "is not a multiple of dump block size", TP_BSIZE);
708: done(1);
709: }
710: ntrec = i / TP_BSIZE;
711: vprintf(stdout, "Tape block size is %d\n", ntrec);
712: }
713:
714: flsht()
715: {
716:
717: bct = ntrec+1;
718: }
719:
720: closemt()
721: {
722: if (mt < 0)
723: return;
724: #ifdef RRESTORE
725: rmtclose();
726: #else
727: (void) close(mt);
728: #endif
729: }
730:
731: checkvol(b, t)
732: struct s_spcl *b;
733: long t;
734: {
735:
736: if (b->c_volume != t)
737: return(FAIL);
738: return(GOOD);
739: }
740:
741: readhdr(b)
742: struct s_spcl *b;
743: {
744:
745: if (gethead(b) == FAIL) {
746: dprintf(stdout, "readhdr fails at %d blocks\n", blksread);
747: return(FAIL);
748: }
749: return(GOOD);
750: }
751:
752: /*
753: * read the tape into buf, then return whether or
754: * or not it is a header block.
755: */
756: gethead(buf)
757: struct s_spcl *buf;
758: {
759: long i, *j;
760: union u_ospcl {
761: char dummy[TP_BSIZE];
762: struct s_ospcl {
763: long c_type;
764: long c_date;
765: long c_ddate;
766: long c_volume;
767: long c_tapea;
768: u_short c_inumber;
769: long c_magic;
770: long c_checksum;
771: struct odinode {
772: unsigned short odi_mode;
773: u_short odi_nlink;
774: u_short odi_uid;
775: u_short odi_gid;
776: long odi_size;
777: long odi_rdev;
778: char odi_addr[36];
779: long odi_atime;
780: long odi_mtime;
781: long odi_ctime;
782: } c_dinode;
783: long c_count;
784: char c_addr[256];
785: } s_ospcl;
786: } u_ospcl;
787:
788: if (!cvtflag) {
789: readtape((char *)buf);
790: if (buf->c_magic != NFS_MAGIC) {
791: if (swabl(buf->c_magic) != NFS_MAGIC)
792: return (FAIL);
793: if (!Bcvt) {
794: vprintf(stdout, "Note: Doing Byte swapping\n");
795: Bcvt = 1;
796: }
797: }
798: if (checksum((int *)buf) == FAIL)
799: return (FAIL);
800: if (Bcvt)
801: swabst("8l4s31l", (char *)buf);
802: goto good;
803: }
804: readtape((char *)(&u_ospcl.s_ospcl));
805: bzero((char *)buf, (long)TP_BSIZE);
806: buf->c_type = u_ospcl.s_ospcl.c_type;
807: buf->c_date = u_ospcl.s_ospcl.c_date;
808: buf->c_ddate = u_ospcl.s_ospcl.c_ddate;
809: buf->c_volume = u_ospcl.s_ospcl.c_volume;
810: buf->c_tapea = u_ospcl.s_ospcl.c_tapea;
811: buf->c_inumber = u_ospcl.s_ospcl.c_inumber;
812: buf->c_checksum = u_ospcl.s_ospcl.c_checksum;
813: buf->c_magic = u_ospcl.s_ospcl.c_magic;
814: buf->c_dinode.di_mode = u_ospcl.s_ospcl.c_dinode.odi_mode;
815: buf->c_dinode.di_nlink = u_ospcl.s_ospcl.c_dinode.odi_nlink;
816: buf->c_dinode.di_uid = u_ospcl.s_ospcl.c_dinode.odi_uid;
817: buf->c_dinode.di_gid = u_ospcl.s_ospcl.c_dinode.odi_gid;
818: buf->c_dinode.di_size = u_ospcl.s_ospcl.c_dinode.odi_size;
819: buf->c_dinode.di_rdev = u_ospcl.s_ospcl.c_dinode.odi_rdev;
820: buf->c_dinode.di_atime = u_ospcl.s_ospcl.c_dinode.odi_atime;
821: buf->c_dinode.di_mtime = u_ospcl.s_ospcl.c_dinode.odi_mtime;
822: buf->c_dinode.di_ctime = u_ospcl.s_ospcl.c_dinode.odi_ctime;
823: buf->c_count = u_ospcl.s_ospcl.c_count;
824: bcopy(u_ospcl.s_ospcl.c_addr, buf->c_addr, (long)256);
825: if (u_ospcl.s_ospcl.c_magic != OFS_MAGIC ||
826: checksum((int *)(&u_ospcl.s_ospcl)) == FAIL)
827: return(FAIL);
828: buf->c_magic = NFS_MAGIC;
829:
830: good:
831: j = buf->c_dinode.di_ic.ic_size.val;
832: i = j[1];
833: if (buf->c_dinode.di_size == 0 &&
834: (buf->c_dinode.di_mode & IFMT) == IFDIR && Qcvt==0) {
835: if (*j || i) {
836: printf("Note: Doing Quad swapping\n");
837: Qcvt = 1;
838: }
839: }
840: if (Qcvt) {
841: j[1] = *j; *j = i;
842: }
843: switch (buf->c_type) {
844:
845: case TS_CLRI:
846: case TS_BITS:
847: /*
848: * Have to patch up missing information in bit map headers
849: */
850: buf->c_inumber = 0;
851: buf->c_dinode.di_size = buf->c_count * TP_BSIZE;
852: for (i = 0; i < buf->c_count; i++)
853: buf->c_addr[i]++;
854: break;
855:
856: case TS_TAPE:
857: case TS_END:
858: buf->c_inumber = 0;
859: break;
860:
861: case TS_INODE:
862: case TS_ADDR:
863: break;
864:
865: default:
866: panic("gethead: unknown inode type %d\n", buf->c_type);
867: break;
868: }
869: if (dflag)
870: accthdr(buf);
871: return(GOOD);
872: }
873:
874: /*
875: * Check that a header is where it belongs and predict the next header
876: */
877: accthdr(header)
878: struct s_spcl *header;
879: {
880: static ino_t previno = 0x7fffffff;
881: static int prevtype;
882: static long predict;
883: long blks, i;
884:
885: if (header->c_type == TS_TAPE) {
886: fprintf(stderr, "Volume header\n");
887: return;
888: }
889: if (previno == 0x7fffffff)
890: goto newcalc;
891: switch (prevtype) {
892: case TS_BITS:
893: fprintf(stderr, "Dump mask header");
894: break;
895: case TS_CLRI:
896: fprintf(stderr, "Remove mask header");
897: break;
898: case TS_INODE:
899: fprintf(stderr, "File header, ino %d", previno);
900: break;
901: case TS_ADDR:
902: fprintf(stderr, "File continuation header, ino %d", previno);
903: break;
904: case TS_END:
905: fprintf(stderr, "End of tape header");
906: break;
907: }
908: if (predict != blksread - 1)
909: fprintf(stderr, "; predicted %d blocks, got %d blocks",
910: predict, blksread - 1);
911: fprintf(stderr, "\n");
912: newcalc:
913: blks = 0;
914: if (header->c_type != TS_END)
915: for (i = 0; i < header->c_count; i++)
916: if (header->c_addr[i] != 0)
917: blks++;
918: predict = blks;
919: blksread = 0;
920: prevtype = header->c_type;
921: previno = header->c_inumber;
922: }
923:
924: /*
925: * Find an inode header.
926: * Complain if had to skip, and complain is set.
927: */
928: findinode(header, complain)
929: struct s_spcl *header;
930: int complain;
931: {
932: static long skipcnt = 0;
933:
934: curfile.name = "<name unknown>";
935: curfile.action = UNKNOWN;
936: curfile.dip = (struct dinode *)NIL;
937: curfile.ino = 0;
938: if (ishead(header) == FAIL) {
939: skipcnt++;
940: while (gethead(header) == FAIL)
941: skipcnt++;
942: }
943: for (;;) {
944: if (checktype(header, TS_INODE) == GOOD) {
945: curfile.dip = &header->c_dinode;
946: curfile.ino = header->c_inumber;
947: break;
948: }
949: if (checktype(header, TS_END) == GOOD) {
950: curfile.ino = maxino;
951: break;
952: }
953: if (checktype(header, TS_CLRI) == GOOD) {
954: curfile.name = "<file removal list>";
955: break;
956: }
957: if (checktype(header, TS_BITS) == GOOD) {
958: curfile.name = "<file dump list>";
959: break;
960: }
961: while (gethead(header) == FAIL)
962: skipcnt++;
963: }
964: if (skipcnt > 0 && complain)
965: fprintf(stderr, "resync restore, skipped %d blocks\n", skipcnt);
966: skipcnt = 0;
967: }
968:
969: /*
970: * return whether or not the buffer contains a header block
971: */
972: ishead(buf)
973: struct s_spcl *buf;
974: {
975:
976: if (buf->c_magic != NFS_MAGIC)
977: return(FAIL);
978: return(GOOD);
979: }
980:
981: checktype(b, t)
982: struct s_spcl *b;
983: int t;
984: {
985:
986: if (b->c_type != t)
987: return(FAIL);
988: return(GOOD);
989: }
990:
991: checksum(b)
992: register int *b;
993: {
994: register int i, j;
995:
996: j = sizeof(union u_spcl) / sizeof(int);
997: i = 0;
998: if(!Bcvt) {
999: do
1000: i += *b++;
1001: while (--j);
1002: } else {
1003: /* What happens if we want to read restore tapes
1004: for a 16bit int machine??? */
1005: do
1006: i += swabl(*b++);
1007: while (--j);
1008: }
1009:
1010: if (i != CHECKSUM) {
1011: fprintf(stderr, "Checksum error %o, inode %d file %s\n", i,
1012: curfile.ino, curfile.name);
1013: return(FAIL);
1014: }
1015: return(GOOD);
1016: }
1017:
1018: #ifdef RRESTORE
1019: /* VARARGS1 */
1020: msg(cp, a1, a2, a3)
1021: char *cp;
1022: {
1023:
1024: fprintf(stderr, cp, a1, a2, a3);
1025: }
1026: #endif RRESTORE
1027:
1028: swabst(cp, sp)
1029: register char *cp, *sp;
1030: {
1031: int n = 0;
1032: char c;
1033: while(*cp) {
1034: switch (*cp) {
1035: case '0': case '1': case '2': case '3': case '4':
1036: case '5': case '6': case '7': case '8': case '9':
1037: n = (n * 10) + (*cp++ - '0');
1038: continue;
1039:
1040: case 's': case 'w': case 'h':
1041: c = sp[0]; sp[0] = sp[1]; sp[1] = c;
1042: sp++;
1043: break;
1044:
1045: case 'l':
1046: c = sp[0]; sp[0] = sp[3]; sp[3] = c;
1047: c = sp[2]; sp[2] = sp[1]; sp[1] = c;
1048: sp += 3;
1049: }
1050: sp++; /* Any other character, like 'b' counts as byte. */
1051: if (n <= 1) {
1052: n = 0; cp++;
1053: } else
1054: n--;
1055: }
1056: }
1057: swabl(x) { unsigned long l = x; swabst("l", (char *)&l); return l; }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.