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