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