restore/tape.c

   1 /*
   2  *      Ported to Linux's Second Extended File System as part of the
   3  *      dump and restore backup suit
   4  *      Remy Card <card@Linux.EU.Org>, 1994-1997
   5  *      Stelian Pop <pop@noos.fr>, 1999-2000
   6  *      Stelian Pop <pop@noos.fr> - Alcôve <www.alcove.fr>, 2000
   7  */
   8
   9 /*
  10  * Copyright (c) 1983, 1993
  11  *      The Regents of the University of California.  All rights reserved.
  12  * (c) UNIX System Laboratories, Inc.
  13  * All or some portions of this file are derived from material licensed
  14  * to the University of California by American Telephone and Telegraph
  15  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  16  * the permission of UNIX System Laboratories, Inc.
  17  *
  18  * Redistribution and use in source and binary forms, with or without
  19  * modification, are permitted provided that the following conditions
  20  * are met:
  21  * 1. Redistributions of source code must retain the above copyright
  22  *    notice, this list of conditions and the following disclaimer.
  23  * 2. Redistributions in binary form must reproduce the above copyright
  24  *    notice, this list of conditions and the following disclaimer in the
  25  *    documentation and/or other materials provided with the distribution.
  26  * 3. All advertising materials mentioning features or use of this software
  27  *    must display the following acknowledgement:
  28  *      This product includes software developed by the University of
  29  *      California, Berkeley and its contributors.
  30  * 4. Neither the name of the University nor the names of its contributors
  31  *    may be used to endorse or promote products derived from this software
  32  *    without specific prior written permission.
  33  *
  34  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  35  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  36  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  37  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  38  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  39  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  40  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  41  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  42  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  43  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  44  * SUCH DAMAGE.
  45  */
  46
  47 #ifndef lint
  48 static const char rcsid[] =
  49         "$Id: tape.c,v 1.37 2001/04/27 15:22:47 stelian Exp $";
  50 #endif /* not lint */
  51
  52 #include <config.h>
  53 #include <compatlfs.h>
  54 #include <errno.h>
  55 #include <compaterr.h>
  56 #include <setjmp.h>
  57 #include <stdio.h>
  58 #include <stdlib.h>
  59 #include <string.h>
  60 #include <unistd.h>
  61
  62 #include <sys/param.h>
  63 #include <sys/file.h>
  64 #include <sys/mtio.h>
  65 #include <sys/stat.h>
  66
  67 #ifdef  __linux__
  68 #include <sys/time.h>
  69 #include <time.h>
  70 #include <linux/ext2_fs.h>
  71 #include <ext2fs/ext2fs.h>
  72 #include <bsdcompat.h>
  73 #else   /* __linux__ */
  74 #include <ufs/ufs/dinode.h>
  75 #endif  /* __linux__ */
  76 #include <protocols/dumprestore.h>
  77
  78 #ifdef HAVE_ZLIB
  79 #include <zlib.h>
  80 #endif /* HAVE_ZLIB */
  81
  82 #include "restore.h"
  83 #include "extern.h"
  84 #include "pathnames.h"
  85
  86 #ifdef USE_QFA
  87 int             noresyncmesg = 0;
  88 #endif /* USE_QFA */
  89 static long     fssize = MAXBSIZE;
  90 static int      mt = -1;
  91 static int      pipein = 0;
  92 static int      magtapein = 0;          /* input is from magtape */
  93 static char     magtape[MAXPATHLEN];
  94 static char     magtapeprefix[MAXPATHLEN];
  95 static int      blkcnt;
  96 static int      numtrec;
  97 static char     *tapebuf;               /* input buffer for read */
  98 static int      bufsize;                /* buffer size without prefix */
  99 static char     *tbufptr = NULL;        /* active tape buffer */
 100 #ifdef HAVE_ZLIB
 101 static char     *comprbuf;              /* uncompress work buf */
 102 static size_t   comprlen;               /* size including prefix */
 103 #endif
 104 static union    u_spcl endoftapemark;
 105 static long     blksread;               /* blocks read since last header */
 106 static long     tpblksread = 0;         /* TP_BSIZE blocks read */
 107 static long     tapesread;
 108 static sigjmp_buf       restart;
 109 static int      gettingfile = 0;        /* restart has a valid frame */
 110 static char     *host = NULL;
 111
 112 static int      ofile;
 113 static char     *map;
 114 static char     lnkbuf[MAXPATHLEN + 1];
 115 static int      pathlen;
 116
 117 int             oldinofmt;      /* old inode format conversion required */
 118 int             Bcvt;           /* Swap Bytes (for CCI or sun) */
 119 static int      Qcvt;           /* Swap quads (for sun) */
 120
 121 #define FLUSHTAPEBUF()  blkcnt = ntrec + 1
 122
 123 static void      accthdr __P((struct s_spcl *));
 124 static int       checksum __P((int *));
 125 static void      findinode __P((struct s_spcl *));
 126 static void      findtapeblksize __P((void));
 127 static int       gethead __P((struct s_spcl *));
 128 static void      readtape __P((char *));
 129 static void      setdumpnum __P((void));
 130 static u_int     swabi __P((u_int));
 131 #if 0
 132 static u_long    swabl __P((u_long));
 133 #endif
 134 static u_char   *swab64 __P((u_char *, int));
 135 static u_char   *swab32 __P((u_char *, int));
 136 static u_char   *swab16 __P((u_char *, int));
 137 static void      terminateinput __P((void));
 138 static void      xtrfile __P((char *, size_t));
 139 static void      xtrlnkfile __P((char *, size_t));
 140 static void      xtrlnkskip __P((char *, size_t));
 141 static void      xtrmap __P((char *, size_t));
 142 static void      xtrmapskip __P((char *, size_t));
 143 static void      xtrskip __P((char *, size_t));
 144
 145 #ifdef HAVE_ZLIB
 146 static void     newcomprbuf __P((long));
 147 static void     readtape_set __P((char *));
 148 static void     readtape_uncompr __P((char *));
 149 static void     readtape_comprfile __P((char *));
 150 static void     readtape_comprtape __P((char *));
 151 static char     *decompress_tapebuf __P((struct tapebuf *, int));
 152 static void     msg_read_error __P((char *));
 153 #endif
 154 static int      read_a_block __P((int, char *, size_t, long *));
 155 #define PREFIXSIZE      sizeof(struct tapebuf)
 156
 157 #define COMPARE_ONTHEFLY 1
 158
 159 #if COMPARE_ONTHEFLY
 160 static int      ifile;          /* input file for compare */
 161 static int      cmperror;       /* compare error */
 162 static void     xtrcmpfile __P((char *, size_t));
 163 static void     xtrcmpskip __P((char *, size_t));
 164 #endif
 165
 166 static int readmapflag;
 167
 168 /*
 169  * Set up an input source. This is called from main.c before setup() is.
 170  */
 171 void
 172 setinput(char *source)
 173 {
 174         FLUSHTAPEBUF();
 175         if (bflag)
 176                 newtapebuf(ntrec);
 177         else
 178                 newtapebuf(NTREC > HIGHDENSITYTREC ? NTREC : HIGHDENSITYTREC);
 179         terminal = stdin;
 180
 181 #ifdef RRESTORE
 182         if (strchr(source, ':')) {
 183                 host = source;
 184                 source = strchr(host, ':');
 185                 *source++ = '\0';
 186                 if (rmthost(host) == 0)
 187                         exit(1);
 188         } else
 189 #endif
 190         if (strcmp(source, "-") == 0) {
 191                 /*
 192                  * Since input is coming from a pipe we must establish
 193                  * our own connection to the terminal.
 194                  */
 195                 terminal = fopen(_PATH_TTY, "r");
 196                 if (terminal == NULL) {
 197                         warn("cannot open %s", _PATH_TTY);
 198                         terminal = fopen(_PATH_DEVNULL, "r");
 199                         if (terminal == NULL)
 200                                 err(1, "cannot open %s", _PATH_DEVNULL);
 201                 }
 202                 pipein++;
 203         }
 204         setuid(getuid());       /* no longer need or want root privileges */
 205         if (Mflag) {
 206                 strncpy(magtapeprefix, source, MAXPATHLEN);
 207                 magtapeprefix[MAXPATHLEN-1] = '\0';
 208                 snprintf(magtape, MAXPATHLEN, "%s%03d", source, 1);
 209         }
 210         else
 211                 strncpy(magtape, source, MAXPATHLEN);
 212         magtape[MAXPATHLEN - 1] = '\0';
 213 }
 214
 215 void
 216 newtapebuf(long size)
 217 {
 218         static int tapebufsize = -1;
 219
 220         ntrec = size;
 221         bufsize = ntrec * TP_BSIZE;
 222         if (size <= tapebufsize)
 223                 return;
 224         if (tapebuf != NULL)
 225                 free(tapebuf);
 226         tapebuf = malloc(size * TP_BSIZE + sizeof(struct tapebuf));
 227         if (tapebuf == NULL)
 228                 errx(1, "Cannot allocate space for tape buffer");
 229         tapebufsize = size;
 230 }
 231
 232 #ifdef HAVE_ZLIB
 233 static void
 234 newcomprbuf(long size)
 235 {
 236         if (size <= comprlen)
 237                 return;
 238         comprlen = size + sizeof(struct tapebuf);
 239         if (comprbuf != NULL)
 240                 free(comprbuf);
 241         comprbuf = malloc(comprlen);
 242         if (comprbuf == NULL)
 243                 errx(1, "Cannot allocate space for decompress buffer");
 244 }
 245 #endif /* HAVE_ZLIB */
 246
 247 /*
 248  * Verify that the tape drive can be accessed and
 249  * that it actually is a dump tape.
 250  */
 251 void
 252 setup(void)
 253 {
 254         int i, j, *ip;
 255         struct STAT stbuf;
 256         struct mtget mt_stat;
 257
 258         Vprintf(stdout, "Verify tape and initialize maps\n");
 259 #ifdef RRESTORE
 260         if (host)
 261                 mt = rmtopen(magtape, 0);
 262         else
 263 #endif
 264         if (pipein)
 265                 mt = 0;
 266         else
 267                 mt = OPEN(magtape, O_RDONLY, 0);
 268         if (mt < 0)
 269                 err(1, "%s", magtape);
 270         volno = 1;
 271         if (!pipein) {
 272                 /* need to know if input is really from a tape */
 273 #ifdef RRESTORE
 274                 if (host)
 275                         magtapein = rmtioctl(MTNOP, 1) != -1;
 276                 else
 277 #endif
 278                         if (ioctl(mt, MTIOCGET, (char *) &mt_stat) == 0) {
 279                                 if (mt_stat.mt_dsreg & 0xffff)
 280                                         magtapein = 1; /* fixed blocksize */
 281                                 else
 282                                         magtapein = 2; /* variable blocksize */
 283                         }
 284         }
 285
 286         Vprintf(stdout,"Input is from %s\n", magtapein? "tape": "file/pipe");
 287         setdumpnum();
 288         FLUSHTAPEBUF();
 289         findtapeblksize();
 290         if (gethead(&spcl) == FAIL) {
 291                 blkcnt--; /* push back this block */
 292                 blksread--;
 293                 tpblksread--;
 294                 cvtflag++;
 295                 if (gethead(&spcl) == FAIL)
 296                         errx(1, "Tape is not a dump tape");
 297                 fprintf(stderr, "Converting to new file system format.\n");
 298         }
 299
 300         if (zflag) {
 301                 fprintf(stderr, "Dump tape is compressed.\n");
 302 #ifdef HAVE_ZLIB
 303                 newcomprbuf(bufsize);
 304 #else
 305                 errx(1,"This restore version doesn't support decompression");
 306 #endif /* HAVE_ZLIB */
 307         }
 308         if (pipein) {
 309                 endoftapemark.s_spcl.c_magic = cvtflag ? OFS_MAGIC : NFS_MAGIC;
 310                 endoftapemark.s_spcl.c_type = TS_END;
 311                 ip = (int *)&endoftapemark;
 312                 j = sizeof(union u_spcl) / sizeof(int);
 313                 i = 0;
 314                 do
 315                         i += *ip++;
 316                 while (--j);
 317                 endoftapemark.s_spcl.c_checksum = CHECKSUM - i;
 318         }
 319         if (vflag || command == 't' || command == 'C')
 320                 printdumpinfo();
 321         if (filesys[0] == '\0') {
 322                 char *dirptr;
 323                 strncpy(filesys, spcl.c_filesys, NAMELEN);
 324                 filesys[NAMELEN - 1] = '\0';
 325                 dirptr = strstr(filesys, " (dir");
 326                 if (dirptr != NULL)
 327                         *dirptr = '\0';
 328         }
 329         dumptime = spcl.c_ddate;
 330         dumpdate = spcl.c_date;
 331         if (STAT(".", &stbuf) < 0)
 332                 err(1, "cannot stat .");
 333         if (stbuf.st_blksize > 0 && stbuf.st_blksize < TP_BSIZE )
 334                 fssize = TP_BSIZE;
 335         if (stbuf.st_blksize >= TP_BSIZE && stbuf.st_blksize <= MAXBSIZE)
 336                 fssize = stbuf.st_blksize;
 337         if (((fssize - 1) & fssize) != 0)
 338                 errx(1, "bad block size %ld", fssize);
 339         if (spcl.c_volume != 1)
 340                 errx(1, "Tape is not volume 1 of the dump");
 341         if (gethead(&spcl) == FAIL) {
 342                 Dprintf(stdout, "header read failed at %ld blocks\n", (long)blksread);
 343                 panic("no header after volume mark!\n");
 344         }
 345         findinode(&spcl);
 346         if (spcl.c_type != TS_CLRI)
 347                 errx(1, "Cannot find file removal list");
 348         maxino = (spcl.c_count * TP_BSIZE * NBBY) + 1;
 349         Dprintf(stdout, "maxino = %ld\n", (long)maxino);
 350         map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY));
 351         if (map == NULL)
 352                 errx(1, "no memory for active inode map");
 353         usedinomap = map;
 354         curfile.action = USING;
 355         getfile(xtrmap, xtrmapskip);
 356         if (spcl.c_type != TS_BITS)
 357                 errx(1, "Cannot find file dump list");
 358         map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY));
 359         if (map == (char *)NULL)
 360                 errx(1, "no memory for file dump list");
 361         dumpmap = map;
 362         curfile.action = USING;
 363         getfile(xtrmap, xtrmapskip);
 364         /*
 365          * If there may be whiteout entries on the tape, pretend that the
 366          * whiteout inode exists, so that the whiteout entries can be
 367          * extracted.
 368          */
 369         if (oldinofmt == 0)
 370                 SETINO(WINO, dumpmap);
 371 }
 372
 373 /*
 374  * Prompt user to load a new dump volume.
 375  * "Nextvol" is the next suggested volume to use.
 376  * This suggested volume is enforced when doing full
 377  * or incremental restores, but can be overridden by
 378  * the user when only extracting a subset of the files.
 379  */
 380 void
 381 getvol(long nextvol)
 382 {
 383         long newvol = 0, savecnt = 0, wantnext = 0, i;
 384         union u_spcl tmpspcl;
 385 #       define tmpbuf tmpspcl.s_spcl
 386         char buf[TP_BSIZE];
 387         int haderror = 0;
 388
 389         if (nextvol == 1) {
 390                 tapesread = 0;
 391                 gettingfile = 0;
 392         }
 393         if (pipein) {
 394                 if (nextvol != 1)
 395                         panic("Changing volumes on pipe input?\n");
 396                 if (volno == 1)
 397                         return;
 398                 goto gethdr;
 399         }
 400         savecnt = blksread;
 401 again:
 402         if (pipein)
 403                 exit(1); /* pipes do not get a second chance */
 404         if (command == 'R' || command == 'r' || curfile.action != SKIP) {
 405                 newvol = nextvol;
 406                 wantnext = 1;
 407         } else {
 408                 newvol = 0;
 409                 wantnext = 0;
 410         }
 411         while (newvol <= 0) {
 412                 if (tapesread == 0) {
 413                         fprintf(stderr, "%s%s%s%s%s",
 414                             "You have not read any tapes yet.\n",
 415                             "Unless you know which volume your",
 416                             " file(s) are on you should start\n",
 417                             "with the last volume and work",
 418                             " towards the first.\n");
 419                 } else {
 420                         fprintf(stderr, "You have read volumes");
 421                         strcpy(buf, ": ");
 422                         for (i = 1; i < 32; i++)
 423                                 if (tapesread & (1 << i)) {
 424                                         fprintf(stderr, "%s%ld", buf, (long)i);
 425                                         strcpy(buf, ", ");
 426                                 }
 427                         fprintf(stderr, "\n");
 428                 }
 429                 do      {
 430                         fprintf(stderr, "Specify next volume #: ");
 431                         (void) fflush(stderr);
 432                         (void) fgets(buf, TP_BSIZE, terminal);
 433                 } while (!feof(terminal) && buf[0] == '\n');
 434                 if (feof(terminal))
 435                         exit(1);
 436                 newvol = atoi(buf);
 437                 if (newvol <= 0) {
 438                         fprintf(stderr,
 439                             "Volume numbers are positive numerics\n");
 440                 }
 441         }
 442         if (newvol == volno) {
 443                 tapesread |= 1 << volno;
 444                 return;
 445         }
 446         closemt();
 447         if (Mflag) {
 448                 snprintf(magtape, MAXPATHLEN, "%s%03ld", magtapeprefix, newvol);
 449                 magtape[MAXPATHLEN - 1] = '\0';
 450         }
 451         if (!Mflag || haderror) {
 452                 haderror = 0;
 453                 fprintf(stderr, "Mount tape volume %ld\n", (long)newvol);
 454                 fprintf(stderr, "Enter ``none'' if there are no more tapes\n");
 455                 fprintf(stderr, "otherwise enter tape name (default: %s) ", magtape);
 456                 (void) fflush(stderr);
 457                 (void) fgets(buf, TP_BSIZE, terminal);
 458                 if (feof(terminal))
 459                         exit(1);
 460                 if (!strcmp(buf, "none\n")) {
 461                         terminateinput();
 462                         return;
 463                 }
 464                 if (buf[0] != '\n') {
 465                         (void) strcpy(magtape, buf);
 466                         magtape[strlen(magtape) - 1] = '\0';
 467                 }
 468         }
 469 #ifdef RRESTORE
 470         if (host)
 471                 mt = rmtopen(magtape, 0);
 472         else
 473 #endif
 474                 mt = OPEN(magtape, O_RDONLY, 0);
 475
 476         if (mt == -1) {
 477                 fprintf(stderr, "Cannot open %s\n", magtape);
 478                 volno = -1;
 479                 haderror = 1;
 480                 goto again;
 481         }
 482 gethdr:
 483         volno = newvol;
 484         setdumpnum();
 485         FLUSHTAPEBUF();
 486         if (gethead(&tmpbuf) == FAIL) {
 487                 Dprintf(stdout, "header read failed at %ld blocks\n", (long)blksread);
 488                 fprintf(stderr, "tape is not dump tape\n");
 489                 volno = 0;
 490                 haderror = 1;
 491                 goto again;
 492         }
 493         if (tmpbuf.c_volume != volno) {
 494                 fprintf(stderr, "Wrong volume (%d)\n", tmpbuf.c_volume);
 495                 volno = 0;
 496                 haderror = 1;
 497                 goto again;
 498         }
 499         if (tmpbuf.c_date != dumpdate || tmpbuf.c_ddate != dumptime) {
 500                 fprintf(stderr, "Wrong dump date\n\tgot: %s",
 501                         ctime4(&tmpbuf.c_date));
 502                 fprintf(stderr, "\twanted: %s", ctime(&dumpdate));
 503                 volno = 0;
 504                 haderror = 1;
 505                 goto again;
 506         }
 507         tapesread |= 1 << volno;
 508         blksread = savecnt;
 509         /*
 510          * If continuing from the previous volume, skip over any
 511          * blocks read already at the end of the previous volume.
 512          *
 513          * If coming to this volume at random, skip to the beginning
 514          * of the next record.
 515          */
 516         Dprintf(stdout, "read %ld recs, tape starts with %ld\n",
 517                 tpblksread, (long)tmpbuf.c_firstrec);
 518         if (tmpbuf.c_type == TS_TAPE && (tmpbuf.c_flags & DR_NEWHEADER)) {
 519                 if (!wantnext) {
 520                         tpblksread = tmpbuf.c_firstrec;
 521                         for (i = tmpbuf.c_count; i > 0; i--)
 522                                 readtape(buf);
 523                 } else if (tmpbuf.c_firstrec > 0 &&
 524                            tmpbuf.c_firstrec < tpblksread - 1) {
 525                         /*
 526                          * -1 since we've read the volume header
 527                          */
 528                         i = tpblksread - tmpbuf.c_firstrec - 1;
 529                         Dprintf(stderr, "Skipping %ld duplicate record%s.\n",
 530                                 (long)i, i > 1 ? "s" : "");
 531                         while (--i >= 0)
 532                                 readtape(buf);
 533                 }
 534         }
 535         if (curfile.action == USING) {
 536                 if (volno == 1)
 537                         panic("active file into volume 1\n");
 538                 return;
 539         }
 540         /*
 541          * Skip up to the beginning of the next record
 542          */
 543         if (tmpbuf.c_type == TS_TAPE && (tmpbuf.c_flags & DR_NEWHEADER))
 544                 for (i = tmpbuf.c_count; i > 0; i--)
 545                         readtape(buf);
 546         (void) gethead(&spcl);
 547         findinode(&spcl);
 548         if (gettingfile) {
 549                 gettingfile = 0;
 550                 siglongjmp(restart, 1);
 551         }
 552 }
 553
 554 /*
 555  * Handle unexpected EOF.
 556  */
 557 static void
 558 terminateinput(void)
 559 {
 560
 561         if (gettingfile && curfile.action == USING) {
 562                 printf("Warning: %s %s\n",
 563                     "End-of-input encountered while extracting", curfile.name);
 564         }
 565         curfile.name = "<name unknown>";
 566         curfile.action = UNKNOWN;
 567         curfile.dip = NULL;
 568         curfile.ino = maxino;
 569         if (gettingfile) {
 570                 gettingfile = 0;
 571                 siglongjmp(restart, 1);
 572         }
 573 }
 574
 575 /*
 576  * handle multiple dumps per tape by skipping forward to the
 577  * appropriate one.
 578  */
 579 static void
 580 setdumpnum(void)
 581 {
 582         struct mtop tcom;
 583
 584         if (dumpnum == 1 || volno != 1)
 585                 return;
 586         if (pipein)
 587                 errx(1, "Cannot have multiple dumps on pipe input");
 588         tcom.mt_op = MTFSF;
 589         tcom.mt_count = dumpnum - 1;
 590 #ifdef RRESTORE
 591         if (host)
 592                 rmtioctl(MTFSF, dumpnum - 1);
 593         else
 594 #endif
 595                 if (ioctl(mt, (int)MTIOCTOP, (char *)&tcom) < 0)
 596                         warn("ioctl MTFSF");
 597 }
 598
 599 void
 600 printdumpinfo(void)
 601 {
 602         fprintf(stdout, "Dump   date: %s", ctime4(&spcl.c_date));
 603         fprintf(stdout, "Dumped from: %s",
 604             (spcl.c_ddate == 0) ? "the epoch\n" : ctime4(&spcl.c_ddate));
 605         if (spcl.c_host[0] == '\0')
 606                 return;
 607         fprintf(stdout, "Level %d dump of %s on %s:%s\n",
 608                 spcl.c_level, spcl.c_filesys, spcl.c_host, spcl.c_dev);
 609         fprintf(stdout, "Label: %s\n", spcl.c_label);
 610 }
 611
 612 int
 613 extractfile(char *name)
 614 {
 615         unsigned int flags;
 616         mode_t mode;
 617         struct timeval timep[2];
 618         struct entry *ep;
 619
 620         curfile.name = name;
 621         curfile.action = USING;
 622 #ifdef  __linux__
 623         timep[0].tv_sec = curfile.dip->di_atime.tv_sec;
 624         timep[0].tv_usec = curfile.dip->di_atime.tv_usec;
 625         timep[1].tv_sec = curfile.dip->di_mtime.tv_sec;
 626         timep[1].tv_usec = curfile.dip->di_mtime.tv_usec;
 627 #else   /* __linux__ */
 628         timep[0].tv_sec = curfile.dip->di_atime;
 629         timep[0].tv_usec = curfile.dip->di_atimensec / 1000;
 630         timep[1].tv_sec = curfile.dip->di_mtime;
 631         timep[1].tv_usec = curfile.dip->di_mtimensec / 1000;
 632 #endif  /* __linux__ */
 633         mode = curfile.dip->di_mode;
 634         flags = curfile.dip->di_flags;
 635         switch (mode & IFMT) {
 636
 637         default:
 638                 fprintf(stderr, "%s: unknown file mode 0%o\n", name, mode);
 639                 skipfile();
 640                 return (FAIL);
 641
 642         case IFSOCK:
 643                 Vprintf(stdout, "skipped socket %s\n", name);
 644                 skipfile();
 645                 return (GOOD);
 646
 647         case IFDIR:
 648                 if (mflag) {
 649                         ep = lookupname(name);
 650                         if (ep == NULL || ep->e_flags & EXTRACT)
 651                                 panic("unextracted directory %s\n", name);
 652                         skipfile();
 653                         return (GOOD);
 654                 }
 655                 Vprintf(stdout, "extract file %s\n", name);
 656                 return (genliteraldir(name, curfile.ino));
 657
 658         case IFLNK:
 659         {
 660 #ifdef HAVE_LCHOWN
 661                 uid_t luid = curfile.dip->di_uid;
 662                 gid_t lgid = curfile.dip->di_gid;
 663 #endif
 664                 lnkbuf[0] = '\0';
 665                 pathlen = 0;
 666                 getfile(xtrlnkfile, xtrlnkskip);
 667                 if (pathlen == 0) {
 668                         Vprintf(stdout,
 669                             "%s: zero length symbolic link (ignored)\n", name);
 670                         return (GOOD);
 671                 }
 672                 if (linkit(lnkbuf, name, SYMLINK) == FAIL)
 673                         return (FAIL);
 674 #ifdef HAVE_LCHOWN
 675                 (void) lchown(name, luid, lgid);
 676 #endif
 677                 return (GOOD);
 678         }
 679
 680         case IFIFO:
 681                 Vprintf(stdout, "extract fifo %s\n", name);
 682                 if (Nflag) {
 683                         skipfile();
 684                         return (GOOD);
 685                 }
 686                 if (uflag && !Nflag)
 687                         (void)unlink(name);
 688                 if (mkfifo(name, mode) < 0) {
 689                         warn("%s: cannot create fifo", name);
 690                         skipfile();
 691                         return (FAIL);
 692                 }
 693                 (void) chown(name, curfile.dip->di_uid, curfile.dip->di_gid);
 694                 (void) chmod(name, mode);
 695                 if (flags)
 696 #ifdef  __linux__
 697                         (void) fsetflags(name, flags);
 698 #else
 699                         (void) chflags(name, flags);
 700 #endif
 701                 skipfile();
 702                 utimes(name, timep);
 703                 return (GOOD);
 704
 705         case IFCHR:
 706         case IFBLK:
 707                 Vprintf(stdout, "extract special file %s\n", name);
 708                 if (Nflag) {
 709                         skipfile();
 710                         return (GOOD);
 711                 }
 712                 if (uflag)
 713                         (void)unlink(name);
 714                 if (mknod(name, mode, (int)curfile.dip->di_rdev) < 0) {
 715                         warn("%s: cannot create special file", name);
 716                         skipfile();
 717                         return (FAIL);
 718                 }
 719                 (void) chown(name, curfile.dip->di_uid, curfile.dip->di_gid);
 720                 (void) chmod(name, mode);
 721                 if (flags)
 722 #ifdef  __linux__
 723                         {
 724                         warn("%s: fsetflags called on a special file", name);
 725                         (void) fsetflags(name, flags);
 726                         }
 727 #else
 728                         (void) chflags(name, flags);
 729 #endif
 730                 skipfile();
 731                 utimes(name, timep);
 732                 return (GOOD);
 733
 734         case IFREG:
 735                 Vprintf(stdout, "extract file %s\n", name);
 736                 if (Nflag) {
 737                         skipfile();
 738                         return (GOOD);
 739                 }
 740                 if (uflag)
 741                         (void)unlink(name);
 742                 if ((ofile = OPEN(name, O_WRONLY | O_CREAT | O_TRUNC,
 743                     0666)) < 0) {
 744                         warn("%s: cannot create file", name);
 745                         skipfile();
 746                         return (FAIL);
 747                 }
 748                 (void) fchown(ofile, curfile.dip->di_uid, curfile.dip->di_gid);
 749                 (void) fchmod(ofile, mode);
 750                 if (flags)
 751 #ifdef  __linux__
 752                         (void) setflags(ofile, flags);
 753 #else
 754                         (void) fchflags(ofile, flags);
 755 #endif
 756                 getfile(xtrfile, xtrskip);
 757                 (void) close(ofile);
 758                 utimes(name, timep);
 759                 return (GOOD);
 760         }
 761         /* NOTREACHED */
 762 }
 763
 764 /*
 765  * skip over bit maps on the tape
 766  */
 767 void
 768 skipmaps(void)
 769 {
 770
 771         while (spcl.c_type == TS_BITS || spcl.c_type == TS_CLRI)
 772                 skipfile();
 773 }
 774
 775 /*
 776  * skip over a file on the tape
 777  */
 778 void
 779 skipfile(void)
 780 {
 781
 782         curfile.action = SKIP;
 783         getfile(xtrnull, xtrnull);
 784 }
 785
 786 /*
 787  * Extract a file from the tape.
 788  * When an allocated block is found it is passed to the fill function;
 789  * when an unallocated block (hole) is found, a zeroed buffer is passed
 790  * to the skip function.
 791  */
 792 void
 793 getfile(void (*fill) __P((char *, size_t)), void (*skip) __P((char *, size_t)))
 794 {
 795         register int i;
 796         volatile int curblk = 0;
 797         volatile quad_t size = spcl.c_dinode.di_size;
 798         volatile int last_write_was_hole = 0;
 799         quad_t origsize = size;
 800         static char clearedbuf[MAXBSIZE];
 801         char buf[MAXBSIZE / TP_BSIZE][TP_BSIZE];
 802         char junk[TP_BSIZE];
 803
 804         if (spcl.c_type == TS_END)
 805                 panic("ran off end of tape\n");
 806         if (spcl.c_magic != NFS_MAGIC)
 807                 panic("not at beginning of a file\n");
 808         if (!gettingfile && setjmp(restart) != 0)
 809                 return;
 810         gettingfile++;
 811 loop:
 812         for (i = 0; i < spcl.c_count; i++) {
 813                 if (readmapflag || spcl.c_addr[i]) {
 814                         readtape(&buf[curblk++][0]);
 815                         if (curblk == fssize / TP_BSIZE) {
 816                                 (*fill)((char *)buf, (size_t)(size > TP_BSIZE ?
 817                                      fssize : (curblk - 1) * TP_BSIZE + size));
 818                                 curblk = 0;
 819                                 last_write_was_hole = 0;
 820                         }
 821                 } else {
 822                         if (curblk > 0) {
 823                                 (*fill)((char *)buf, (size_t)(size > TP_BSIZE ?
 824                                      curblk * TP_BSIZE :
 825                                      (curblk - 1) * TP_BSIZE + size));
 826                                 curblk = 0;
 827                         }
 828                         (*skip)(clearedbuf, (long)(size > TP_BSIZE ?
 829                                 TP_BSIZE : size));
 830                         last_write_was_hole = 1;
 831                 }
 832                 if ((size -= TP_BSIZE) <= 0) {
 833                         for (i++; i < spcl.c_count; i++)
 834                                 if (readmapflag || spcl.c_addr[i])
 835                                         readtape(junk);
 836                         break;
 837                 }
 838         }
 839         if (gethead(&spcl) == GOOD && size > 0) {
 840                 if (spcl.c_type == TS_ADDR)
 841                         goto loop;
 842                 Dprintf(stdout,
 843                         "Missing address (header) block for %s at %ld blocks\n",
 844                         curfile.name, (long)blksread);
 845         }
 846         if (curblk > 0) {
 847                 (*fill)((char *)buf, (size_t)(curblk * TP_BSIZE) + size);
 848                 last_write_was_hole = 0;
 849         }
 850         if (size > 0) {
 851                 fprintf(stderr, "Missing blocks at the end of %s, assuming hole\n", curfile.name);
 852                 while (size > 0) {
 853                         size_t skp = size > TP_BSIZE ? TP_BSIZE : size;
 854                         (*skip)(clearedbuf, skp);
 855                         size -= skp;
 856                 }
 857                 last_write_was_hole = 1;
 858         }
 859         if (last_write_was_hole) {
 860                 FTRUNCATE(ofile, origsize);
 861         }
 862         findinode(&spcl);
 863         gettingfile = 0;
 864 }
 865
 866 /*
 867  * Write out the next block of a file.
 868  */
 869 static void
 870 xtrfile(char *buf, size_t size)
 871 {
 872
 873         if (Nflag)
 874                 return;
 875         if (write(ofile, buf, (int) size) == -1)
 876                 err(1, "write error extracting inode %lu, name %s\nwrite",
 877                         (unsigned long)curfile.ino, curfile.name);
 878 }
 879
 880 /*
 881  * Skip over a hole in a file.
 882  */
 883 /* ARGSUSED */
 884 static void
 885 xtrskip(char *buf, size_t size)
 886 {
 887
 888         if (LSEEK(ofile, (off_t)size, SEEK_CUR) == -1)
 889                 err(1, "seek error extracting inode %lu, name %s\nlseek",
 890                         (unsigned long)curfile.ino, curfile.name);
 891 }
 892
 893 /*
 894  * Collect the next block of a symbolic link.
 895  */
 896 static void
 897 xtrlnkfile(char *buf, size_t size)
 898 {
 899
 900         pathlen += size;
 901         if (pathlen > MAXPATHLEN)
 902                 errx(1, "symbolic link name: %s->%s%s; too long %d",
 903                     curfile.name, lnkbuf, buf, pathlen);
 904         (void) strcat(lnkbuf, buf);
 905 }
 906
 907 /*
 908  * Skip over a hole in a symbolic link (should never happen).
 909  */
 910 /* ARGSUSED */
 911 static void
 912 xtrlnkskip(char *buf, size_t size)
 913 {
 914
 915         errx(1, "unallocated block in symbolic link %s", curfile.name);
 916 }
 917
 918 /*
 919  * Collect the next block of a bit map.
 920  */
 921 static void
 922 xtrmap(char *buf, size_t size)
 923 {
 924
 925         memmove(map, buf, size);
 926         map += size;
 927 }
 928
 929 /*
 930  * Skip over a hole in a bit map (should never happen).
 931  */
 932 /* ARGSUSED */
 933 static void
 934 xtrmapskip(char *buf, size_t size)
 935 {
 936
 937         panic("hole in map\n");
 938         map += size;
 939 }
 940
 941 /*
 942  * Noop, when an extraction function is not needed.
 943  */
 944 /* ARGSUSED */
 945 void
 946 xtrnull(char *buf, size_t size)
 947 {
 948
 949         return;
 950 }
 951
 952 #if COMPARE_ONTHEFLY
 953 /*
 954  * Compare the next block of a file.
 955  */
 956 static void
 957 xtrcmpfile(char *buf, size_t size)
 958 {
 959         static char cmpbuf[MAXBSIZE];
 960
 961         if (cmperror)
 962                 return;
 963
 964         if (read(ifile, cmpbuf, size) != size) {
 965                 fprintf(stderr, "%s: size has changed.\n",
 966                         curfile.name);
 967                 cmperror = 1;
 968                 return;
 969         }
 970
 971         if (memcmp(buf, cmpbuf, size) != 0) {
 972                 fprintf(stderr, "%s: tape and disk copies are different\n",
 973                         curfile.name);
 974                 cmperror = 1;
 975                 return;
 976         }
 977 }
 978
 979 /*
 980  * Skip over a hole in a file.
 981  */
 982 static void
 983 xtrcmpskip(char *buf, size_t size)
 984 {
 985         static char cmpbuf[MAXBSIZE];
 986         int i;
 987
 988         if (cmperror)
 989                 return;
 990
 991         if (read(ifile, cmpbuf, size) != size) {
 992                 fprintf(stderr, "%s: size has changed.\n",
 993                         curfile.name);
 994                 cmperror = 1;
 995                 return;
 996         }
 997
 998         for (i = 0; i < size; ++i)
 999                 if (cmpbuf[i] != '\0') {
1000                         fprintf(stderr, "%s: tape and disk copies are different\n",
1001                                 curfile.name);
1002                         cmperror = 1;
1003                         return;
1004                 }
1005 }
1006 #endif /* COMPARE_ONTHEFLY */
1007
1008 #if !COMPARE_ONTHEFLY
1009 static int
1010 do_cmpfiles(int fd_tape, int fd_disk, long size)
1011 {
1012         static char buf_tape[BUFSIZ];
1013         static char buf_disk[BUFSIZ];
1014         ssize_t n_tape;
1015         ssize_t n_disk;
1016
1017         while (size > 0) {
1018                 if ((n_tape = read(fd_tape, buf_tape, sizeof(buf_tape))) < 1) {
1019                         close(fd_tape), close(fd_disk);
1020                         panic("do_cmpfiles: unexpected EOF[1]");
1021                 }
1022                 if ((n_disk = read(fd_disk, buf_disk, sizeof(buf_tape))) < 1) {
1023                         close(fd_tape), close(fd_disk);
1024                         panic("do_cmpfiles: unexpected EOF[2]");
1025                 }
1026                 if (n_tape != n_disk) {
1027                         close(fd_tape), close(fd_disk);
1028                         panic("do_cmpfiles: sizes different!");
1029                 }
1030                 if (memcmp(buf_tape, buf_disk, (size_t)n_tape) != 0) return (1);
1031                 size -= n_tape;
1032         }
1033         return (0);
1034 }
1035
1036 /* for debugging compare problems */
1037 #undef COMPARE_FAIL_KEEP_FILE
1038
1039 static
1040 #ifdef COMPARE_FAIL_KEEP_FILE
1041 /* return true if tapefile should be unlinked after compare */
1042 int
1043 #else
1044 void
1045 #endif
1046 cmpfiles(char *tapefile, char *diskfile, struct STAT *sbuf_disk)
1047 {
1048         struct STAT sbuf_tape;
1049         int fd_tape, fd_disk;
1050
1051         if (STAT(tapefile, &sbuf_tape) != 0) {
1052                 panic("Can't lstat tmp file %s: %s\n", tapefile,
1053                       strerror(errno));
1054                 compare_errors = 1;
1055         }
1056
1057         if (sbuf_disk->st_size != sbuf_tape.st_size) {
1058                 fprintf(stderr,
1059                         "%s: size changed from %ld to %ld.\n",
1060                         diskfile, (long)sbuf_tape.st_size, (long)sbuf_disk->st_size);
1061                 compare_errors = 1;
1062 #ifdef COMPARE_FAIL_KEEP_FILE
1063                 return (0);
1064 #else
1065                 return;
1066 #endif
1067         }
1068
1069         if ((fd_tape = OPEN(tapefile, O_RDONLY)) < 0) {
1070                 panic("Can't open %s: %s\n", tapefile, strerror(errno));
1071                 compare_errors = 1;
1072         }
1073         if ((fd_disk = OPEN(diskfile, O_RDONLY)) < 0) {
1074                 close(fd_tape);
1075                 panic("Can't open %s: %s\n", diskfile, strerror(errno));
1076                 compare_errors = 1;
1077         }
1078
1079         if (do_cmpfiles(fd_tape, fd_disk, sbuf_tape.st_size)) {
1080                 fprintf(stderr, "%s: tape and disk copies are different\n",
1081                         diskfile);
1082                 close(fd_tape);
1083                 close(fd_disk);
1084                 compare_errors = 1;
1085 #ifdef COMPARE_FAIL_KEEP_FILE
1086                 /* rename the file to live in /tmp */
1087                 /* rename `tapefile' to /tmp/<basename of diskfile> */
1088                 {
1089                         char *p = strrchr(diskfile, '/');
1090                         char newname[MAXPATHLEN];
1091                         if (!p) {
1092                                 panic("can't find / in %s\n", diskfile);
1093                         }
1094                         snprintf(newname, sizeof(newname), "%s/debug/%s", tmpdir, p + 1);
1095                         if (rename(tapefile, newname)) {
1096                                 panic("rename from %s to %s failed: %s\n",
1097                                       tapefile, newname,
1098                                       strerror(errno));
1099                         } else {
1100                                 fprintf(stderr, "*** %s saved to %s\n",
1101                                         tapefile, newname);
1102                         }
1103                 }
1104
1105                 /* don't unlink the file (it's not there anymore */
1106                 /* anyway) */
1107                 return (0);
1108 #else
1109                 return;
1110 #endif
1111         }
1112         close(fd_tape);
1113         close(fd_disk);
1114 #ifdef COMPARE_FAIL_KEEP_FILE
1115         return (1);
1116 #endif
1117 }
1118 #endif /* !COMPARE_ONTHEFLY */
1119
1120 #if !COMPARE_ONTHEFLY
1121 static char tmpfilename[MAXPATHLEN];
1122 #endif
1123
1124 void
1125 comparefile(char *name)
1126 {
1127         int mode;
1128         struct STAT sb;
1129         int r;
1130 #if !COMPARE_ONTHEFLY
1131         static char *tmpfile = NULL;
1132         struct STAT stemp;
1133 #endif
1134
1135         if ((r = LSTAT(name, &sb)) != 0) {
1136                 warn("%s: does not exist (%d)", name, r);
1137                 compare_errors = 1;
1138                 skipfile();
1139                 return;
1140         }
1141
1142         curfile.name = name;
1143         curfile.action = USING;
1144         mode = curfile.dip->di_mode;
1145
1146         Vprintf(stdout, "comparing %s (size: %ld, mode: 0%o)\n", name,
1147                 (long)sb.st_size, mode);
1148
1149         if (sb.st_mode != mode) {
1150                 fprintf(stderr, "%s: mode changed from 0%o to 0%o.\n",
1151                         name, mode & 07777, sb.st_mode & 07777);
1152                 compare_errors = 1;
1153         }
1154         switch (mode & IFMT) {
1155         default:
1156                 skipfile();
1157                 return;
1158
1159         case IFSOCK:
1160                 skipfile();
1161                 return;
1162
1163         case IFDIR:
1164                 skipfile();
1165                 return;
1166
1167         case IFLNK: {
1168                 char lbuf[MAXPATHLEN + 1];
1169                 int lsize;
1170
1171                 if (!(sb.st_mode & S_IFLNK)) {
1172                         fprintf(stderr, "%s: is no longer a symbolic link\n",
1173                                 name);
1174                         compare_errors = 1;
1175                         return;
1176                 }
1177                 lnkbuf[0] = '\0';
1178                 pathlen = 0;
1179                 getfile(xtrlnkfile, xtrlnkskip);
1180                 if (pathlen == 0) {
1181                         fprintf(stderr,
1182                                 "%s: zero length symbolic link (ignored)\n",
1183                                 name);
1184                         compare_errors = 1;
1185                         return;
1186                 }
1187                 if ((lsize = readlink(name, lbuf, MAXPATHLEN)) < 0) {
1188                         panic("readlink of %s failed: %s", name,
1189                               strerror(errno));
1190                         compare_errors = 1;
1191                 }
1192                 lbuf[lsize] = 0;
1193                 if (strcmp(lbuf, lnkbuf) != 0) {
1194                         fprintf(stderr,
1195                                 "%s: symbolic link changed from %s to %s.\n",
1196                                 name, lnkbuf, lbuf);
1197                         compare_errors = 1;
1198                         return;
1199                 }
1200                 return;
1201         }
1202
1203         case IFCHR:
1204         case IFBLK:
1205                 if (!(sb.st_mode & (S_IFCHR|S_IFBLK))) {
1206                         fprintf(stderr, "%s: no longer a special file\n",
1207                                 name);
1208                         compare_errors = 1;
1209                         skipfile();
1210                         return;
1211                 }
1212
1213                 if (sb.st_rdev != (int)curfile.dip->di_rdev) {
1214                         fprintf(stderr,
1215                                 "%s: device changed from %d,%d to %d,%d.\n",
1216                                 name,
1217                                 ((int)curfile.dip->di_rdev >> 8) & 0xff,
1218                                 (int)curfile.dip->di_rdev & 0xff,
1219                                 ((int)sb.st_rdev >> 8) & 0xff,
1220                                 (int)sb.st_rdev & 0xff);
1221                         compare_errors = 1;
1222                 }
1223                 skipfile();
1224                 return;
1225
1226         case IFREG:
1227 #if COMPARE_ONTHEFLY
1228                 if ((ifile = OPEN(name, O_RDONLY)) < 0) {
1229                         panic("Can't open %s: %s\n", name, strerror(errno));
1230                         skipfile();
1231                         compare_errors = 1;
1232                 }
1233                 else {
1234                         cmperror = 0;
1235                         getfile(xtrcmpfile, xtrcmpskip);
1236                         if (!cmperror) {
1237                                 char c;
1238                                 if (read(ifile, &c, 1) != 0) {
1239                                         fprintf(stderr, "%s: size has changed.\n",
1240                                                 name);
1241                                         cmperror = 1;
1242                                 }
1243                         }
1244                         if (cmperror)
1245                                 compare_errors = 1;
1246                         close(ifile);
1247                 }
1248 #else
1249                 if (tmpfile == NULL) {
1250                         /* argument to mktemp() must not be in RO space: */
1251                         snprintf(tmpfilename, sizeof(tmpfilename), "%s/restoreCXXXXXX", tmpdir);
1252                         tmpfile = mktemp(&tmpfilename[0]);
1253                 }
1254                 if ((STAT(tmpfile, &stemp) == 0) && (unlink(tmpfile) != 0)) {
1255                         panic("cannot delete tmp file %s: %s\n",
1256                               tmpfile, strerror(errno));
1257                 }
1258                 if ((ofile = OPEN(tmpfile, O_WRONLY | O_CREAT | O_TRUNC, 0600)) < 0) {
1259                         panic("cannot create file temp file %s: %s\n",
1260                               name, strerror(errno));
1261                 }
1262                 getfile(xtrfile, xtrskip);
1263                 (void) close(ofile);
1264 #ifdef COMPARE_FAIL_KEEP_FILE
1265                 if (cmpfiles(tmpfile, name, &sb))
1266                         unlink(tmpfile);
1267 #else
1268                 cmpfiles(tmpfile, name, &sb);
1269                 unlink(tmpfile);
1270 #endif
1271 #endif /* COMPARE_ONTHEFLY */
1272                 return;
1273         }
1274         /* NOTREACHED */
1275 }
1276
1277 #ifdef HAVE_ZLIB
1278 static void (*readtape_func)(char *) = readtape_set;
1279
1280 /*
1281  * Read TP_BSIZE blocks from the input.
1282  * Handle read errors, and end of media.
1283  * Decompress compressed blocks.
1284  */
1285 static void
1286 readtape(char *buf)
1287 {
1288         (*readtape_func)(buf);  /* call the actual processing routine */
1289 }
1290
1291 /*
1292  * Set function pointer for readtape() routine. zflag and magtapein must
1293  * be correctly set before the first call to readtape().
1294  */
1295 static void
1296 readtape_set(char *buf)
1297 {
1298         if (!zflag)
1299                 readtape_func = readtape_uncompr;
1300         else {
1301                 if (magtapein)
1302                         readtape_func = readtape_comprtape;
1303                 else
1304                         readtape_func = readtape_comprfile;
1305         }
1306         readtape(buf);
1307 }
1308
1309 #endif /* HAVE_ZLIB */
1310
1311 /*
1312  * This is the original readtape(), it's used for reading uncompressed input.
1313  * Read TP_BSIZE blocks from the input.
1314  * Handle read errors, and end of media.
1315  */
1316 static void
1317 #ifdef HAVE_ZLIB
1318 readtape_uncompr(char *buf)
1319 #else
1320 readtape(char *buf)
1321 #endif
1322 {
1323         ssize_t rd, newvol, i;
1324         int cnt, seek_failed;
1325
1326         if (blkcnt < numtrec) {
1327                 memmove(buf, &tbufptr[(blkcnt++ * TP_BSIZE)], TP_BSIZE);
1328                 blksread++;
1329                 tpblksread++;
1330                 return;
1331         }
1332         tbufptr = tapebuf;
1333         for (i = 0; i < ntrec; i++)
1334                 ((struct s_spcl *)&tapebuf[i * TP_BSIZE])->c_magic = 0;
1335         if (numtrec == 0)
1336                 numtrec = ntrec;
1337         cnt = ntrec * TP_BSIZE;
1338         rd = 0;
1339 getmore:
1340 #ifdef RRESTORE
1341         if (host)
1342                 i = rmtread(&tapebuf[rd], cnt);
1343         else
1344 #endif
1345                 i = read(mt, &tapebuf[rd], cnt);
1346
1347         /*
1348          * Check for mid-tape short read error.
1349          * If found, skip rest of buffer and start with the next.
1350          */
1351         if (!pipein && numtrec < ntrec && i > 0) {
1352                 Dprintf(stdout, "mid-media short read error.\n");
1353                 numtrec = ntrec;
1354         }
1355         /*
1356          * Handle partial block read.
1357          */
1358         if (pipein && i == 0 && rd > 0)
1359                 i = rd;
1360         else if (i > 0 && i != ntrec * TP_BSIZE) {
1361                 if (pipein) {
1362                         rd += i;
1363                         cnt -= i;
1364                         if (cnt > 0)
1365                                 goto getmore;
1366                         i = rd;
1367                 } else {
1368                         /*
1369                          * Short read. Process the blocks read.
1370                          */
1371                         if (i % TP_BSIZE != 0)
1372                                 Vprintf(stdout,
1373                                     "partial block read: %ld should be %ld\n",
1374                                     (long)i, ntrec * TP_BSIZE);
1375                         numtrec = i / TP_BSIZE;
1376                 }
1377         }
1378         /*
1379          * Handle read error.
1380          */
1381         if (i < 0) {
1382                 fprintf(stderr, "Tape read error while ");
1383                 switch (curfile.action) {
1384                 default:
1385                         fprintf(stderr, "trying to set up tape\n");
1386                         break;
1387                 case UNKNOWN:
1388                         fprintf(stderr, "trying to resynchronize\n");
1389                         break;
1390                 case USING:
1391                         fprintf(stderr, "restoring %s\n", curfile.name);
1392                         break;
1393                 case SKIP:
1394                         fprintf(stderr, "skipping over inode %lu\n",
1395                                 (unsigned long)curfile.ino);
1396                         break;
1397                 }
1398                 if (!yflag && !reply("continue"))
1399                         exit(1);
1400                 i = ntrec * TP_BSIZE;
1401                 memset(tapebuf, 0, (size_t)i);
1402 #ifdef RRESTORE
1403                 if (host)
1404                         seek_failed = (rmtseek(i, 1) < 0);
1405                 else
1406 #endif
1407                         seek_failed = (LSEEK(mt, i, SEEK_CUR) == (off_t)-1);
1408
1409                 if (seek_failed) {
1410                         warn("continuation failed");
1411                         if (!yflag && !reply("assume end-of-tape and continue"))
1412                                 exit(1);
1413                         i = 0;
1414                 }
1415         }
1416         /*
1417          * Handle end of tape.
1418          */
1419         if (i == 0) {
1420                 Vprintf(stdout, "End-of-tape encountered\n");
1421                 if (!pipein) {
1422                         newvol = volno + 1;
1423                         volno = 0;
1424                         numtrec = 0;
1425                         getvol(newvol);
1426                         readtape(buf);
1427                         return;
1428                 }
1429                 if (rd % TP_BSIZE != 0)
1430                         panic("partial block read: %d should be %d\n",
1431                                 rd, ntrec * TP_BSIZE);
1432                 terminateinput();
1433                 memmove(&tapebuf[rd], &endoftapemark, TP_BSIZE);
1434         }
1435         blkcnt = 0;
1436         memmove(buf, &tbufptr[(blkcnt++ * TP_BSIZE)], TP_BSIZE);
1437         blksread++;
1438         tpblksread++;
1439 }
1440
1441 #ifdef HAVE_ZLIB
1442
1443 /*
1444  * Read a compressed format block from a file or pipe and uncompress it.
1445  * Attempt to handle read errors, and end of file.
1446  */
1447 static void
1448 readtape_comprfile(char *buf)
1449 {
1450         long rl, size, i, ret;
1451         int newvol;
1452         struct tapebuf *tpb;
1453
1454         if (blkcnt < numtrec) {
1455                 memmove(buf, &tbufptr[(blkcnt++ * TP_BSIZE)], TP_BSIZE);
1456                 blksread++;
1457                 tpblksread++;
1458                 return;
1459         }
1460         /* need to read the next block */
1461         tbufptr = tapebuf;
1462         for (i = 0; i < ntrec; i++)
1463                 ((struct s_spcl *)&tapebuf[i * TP_BSIZE])->c_magic = 0;
1464         numtrec = ntrec;
1465         tpb = (struct tapebuf *) tapebuf;
1466
1467         /* read the block prefix */
1468         ret = read_a_block(mt, tapebuf, PREFIXSIZE, &rl);
1469         if (ret <= 0)
1470                 goto readerr;
1471
1472         /* read the data */
1473         size = tpb->length;
1474         if (size > bufsize)  {
1475                 /* something's wrong */
1476                 Vprintf(stdout, "Prefix size error, max size %d, got %ld\n",
1477                         bufsize, size);
1478                 size = bufsize;
1479                 tpb->length = bufsize;
1480         }
1481         ret = read_a_block(mt, tpb->buf, size, &rl);
1482         if (ret <= 0)
1483                 goto readerr;
1484
1485         tbufptr = decompress_tapebuf(tpb, rl + PREFIXSIZE);
1486         if (tbufptr == NULL) {
1487                 msg_read_error("File decompression error while");
1488                 if (!yflag && !reply("continue"))
1489                         exit(1);
1490                 memset(tapebuf, 0, bufsize);
1491                 tbufptr = tapebuf;
1492         }
1493
1494         blkcnt = 0;
1495         memmove(buf, &tbufptr[(blkcnt++ * TP_BSIZE)], TP_BSIZE);
1496         blksread++;
1497         tpblksread++;
1498         return;
1499
1500 readerr:
1501         /* Errors while reading from a file or pipe are catastrophic. Since
1502          * there are no block boundaries, it's impossible to bypass the
1503          * block in error and find the start of the next block.
1504          */
1505         if (ret == 0) {
1506                 /* It's possible to have multiple input files using -M
1507                  * and -f file1,file2...
1508                  */
1509                 Vprintf(stdout, "End-of-File encountered\n");
1510                 if (!pipein) {
1511                         newvol = volno + 1;
1512                         volno = 0;
1513                         numtrec = 0;
1514                         getvol(newvol);
1515                         readtape(buf);
1516                         return;
1517                 }
1518         }
1519         msg_read_error("Read error while");
1520         /* if (!yflag && !reply("continue")) */
1521                 exit(1);
1522 }
1523
1524 /*
1525  * Read compressed data from a tape and uncompress it.
1526  * Handle read errors, and end of media.
1527  * Since a tape consists of separate physical blocks, we try
1528  * to recover from errors by repositioning the tape to the next
1529  * block.
1530  */
1531 static void
1532 readtape_comprtape(char *buf)
1533 {
1534         long rl, size, i;
1535         int ret, newvol;
1536         struct tapebuf *tpb;
1537         struct mtop tcom;
1538
1539         if (blkcnt < numtrec) {
1540                 memmove(buf, &tbufptr[(blkcnt++ * TP_BSIZE)], TP_BSIZE);
1541                 blksread++;
1542                 tpblksread++;
1543                 return;
1544         }
1545         /* need to read the next block */
1546         tbufptr = tapebuf;
1547         for (i = 0; i < ntrec; i++)
1548                 ((struct s_spcl *)&tapebuf[i * TP_BSIZE])->c_magic = 0;
1549         numtrec = ntrec;
1550         tpb = (struct tapebuf *) tapebuf;
1551
1552         /* read the block */
1553         size = bufsize + PREFIXSIZE;
1554         ret = read_a_block(mt, tapebuf, size, &rl);
1555         if (ret <= 0)
1556                 goto readerr;
1557
1558         tbufptr = decompress_tapebuf(tpb, rl);
1559         if (tbufptr == NULL) {
1560                 msg_read_error("Tape decompression error while");
1561                 if (!yflag && !reply("continue"))
1562                         exit(1);
1563                 memset(tapebuf, 0, PREFIXSIZE + bufsize);
1564                 tbufptr = tapebuf;
1565         }
1566         goto moverecord;
1567
1568 readerr:
1569         /* Handle errors: EOT switches to the next volume, other errors
1570          * attempt to position the tape to the next block.
1571          */
1572         if (ret == 0) {
1573                 Vprintf(stdout, "End-of-tape encountered\n");
1574                 newvol = volno + 1;
1575                 volno = 0;
1576                 numtrec = 0;
1577                 getvol(newvol);
1578                 readtape(buf);
1579                 return;
1580         }
1581
1582         msg_read_error("Tape read error while");
1583         if (!yflag && !reply("continue"))
1584                 exit(1);
1585         memset(tapebuf, 0, PREFIXSIZE + bufsize);
1586         tbufptr = tapebuf;
1587
1588 #ifdef RRESTORE
1589         if (host)
1590                 rl = rmtioctl(MTFSR, 1);
1591         else
1592 #endif
1593         {
1594                 tcom.mt_op = MTFSR;
1595                 tcom.mt_count = 1;
1596                 rl = ioctl(mt, MTIOCTOP, &tcom);
1597         }
1598
1599         if (rl < 0) {
1600                 warn("continuation failed");
1601                 if (!yflag && !reply("assume end-of-tape and continue"))
1602                         exit(1);
1603                 ret = 0;         /* end of tape */
1604                 goto readerr;
1605         }
1606
1607 moverecord:
1608         blkcnt = 0;
1609         memmove(buf, &tbufptr[(blkcnt++ * TP_BSIZE)], TP_BSIZE);
1610         blksread++;
1611         tpblksread++;
1612 }
1613
1614 /*
1615  *  Decompress a struct tapebuf into a buffer. readsize is the size read
1616  *  from the tape/file and is used for error messages. Returns a pointer
1617  *  to the location of the uncompressed buffer or NULL on errors.
1618  *  Adjust numtrec and complain for a short block.
1619  */
1620 static char *
1621 decompress_tapebuf(struct tapebuf *tpbin, int readsize)
1622 {
1623         /* If zflag is on, all blocks have a struct tapebuf prefix */
1624         /* zflag gets set in setup() from the dump header          */
1625         int cresult, blocklen;
1626         unsigned long worklen;
1627         char *output = NULL,*reason = NULL, *lengtherr = NULL;
1628
1629         /* build a length error message */
1630         blocklen = tpbin->length;
1631         if (readsize < blocklen + PREFIXSIZE)
1632                 lengtherr = "short";
1633         else
1634                 if (readsize > blocklen + PREFIXSIZE)
1635                         lengtherr = "long";
1636
1637         worklen = comprlen;
1638         cresult = Z_OK;
1639         if (tpbin->compressed) {
1640                 /* uncompress whatever we read, if it fails, complain later */
1641                 cresult = uncompress(comprbuf, &worklen, tpbin->buf, blocklen);
1642                 output = comprbuf;
1643         }
1644         else {
1645                 output = tpbin->buf;
1646                 worklen = blocklen;
1647         }
1648         switch (cresult) {
1649                 case Z_OK:
1650                         numtrec = worklen / TP_BSIZE;
1651                         if (worklen % TP_BSIZE != 0)
1652                                 reason = "length mismatch";
1653                         break;
1654                 case Z_MEM_ERROR:
1655                         reason = "not enough memory";
1656                         break;
1657                 case Z_BUF_ERROR:
1658                         reason = "buffer too small";
1659                         break;
1660                 case Z_DATA_ERROR:
1661                         reason = "data error";
1662                         break;
1663                 default:
1664                         reason = "unknown";
1665         } /*switch */
1666         if (reason) {
1667                 if (lengtherr)
1668                         fprintf(stderr, "%s compressed block: %d expected: %d\n",
1669                                 lengtherr, readsize, tpbin->length + PREFIXSIZE);
1670                 fprintf(stderr, "decompression error, block %ld: %s\n",
1671                         tpblksread+1, reason);
1672                 if (cresult != Z_OK)   output = NULL;
1673         }
1674         return output;
1675 }
1676
1677 /*
1678  * Print an error message for a read error.
1679  * This was exteracted from the original readtape().
1680  */
1681 static void
1682 msg_read_error(char *m)
1683 {
1684         switch (curfile.action) {
1685                 default:
1686                         fprintf(stderr, "%s trying to set up tape\n", m);
1687                         break;
1688                 case UNKNOWN:
1689                         fprintf(stderr, "%s trying to resynchronize\n", m);
1690                         break;
1691                 case USING:
1692                         fprintf(stderr, "%s restoring %s\n", m, curfile.name);
1693                         break;
1694                 case SKIP:
1695                         fprintf(stderr, "%s skipping over inode %lu\n", m,
1696                                 (unsigned long)curfile.ino);
1697                         break;
1698         }
1699 }
1700 #endif /* HAVE_ZLIB */
1701
1702 /*
1703  * Read the first block and set the blocksize from its length. Test
1704  * if the block looks like a compressed dump tape. setup() will make
1705  * the final determination by checking the compressed flag if gethead()
1706  * finds a valid header. The test here is necessary to offset the buffer
1707  * by the size of the compressed prefix. zflag is set here so that
1708  * readtape_set can set the correct function pointer for readtape().
1709  * Note that the first block of each tape/file will not be compressed.
1710  */
1711 static void
1712 findtapeblksize(void)
1713 {
1714         long i;
1715         size_t len;
1716         struct tapebuf *tpb = (struct tapebuf *) tapebuf;
1717         struct s_spcl *spclpt = (struct s_spcl *) tpb->buf;
1718
1719         for (i = 0; i < ntrec; i++)
1720                 ((struct s_spcl *)&tapebuf[i * TP_BSIZE])->c_magic = 0;
1721         blkcnt = 0;
1722         tbufptr = tapebuf;
1723         /*
1724          * For a pipe or file, read in the first record. For a tape, read
1725          * the first block.
1726          */
1727         if (magtapein == 1)     /* fixed blocksize tape, not compressed */
1728                 len = ntrec * TP_BSIZE;
1729         else if (magtapein == 2)/* variable blocksize tape */
1730                 len = bufsize + PREFIXSIZE;
1731         else                    /* not mag tape */
1732                 len = TP_BSIZE;
1733
1734         if (read_a_block(mt, tapebuf, len, &i) <= 0)
1735                 errx(1, "Tape read error on first record");
1736
1737         /*
1738          * If the input is from a file or a pipe, we read TP_BSIZE
1739          * bytes looking for a compressed dump header, we then
1740          * need to read in the rest of the record, as determined by
1741          * tpb->length or bufsize. The first block of the dump is
1742          * guaranteed to not be compressed so we look at the header.
1743          */
1744         if (!magtapein) {
1745                 if (tpb->length % TP_BSIZE == 0
1746                     && tpb->length <= bufsize
1747                     && tpb->compressed == 0
1748                     && spclpt->c_type == TS_TAPE
1749                     && spclpt->c_flags & DR_COMPRESSED) {
1750                         /* Looks like it's a compressed dump block prefix, */
1751                         /* read in the rest of the block based on tpb->length. */
1752                         len = tpb->length - TP_BSIZE + PREFIXSIZE;
1753                         if (read_a_block(mt, tapebuf+TP_BSIZE, len, &i) <= 0
1754                             || i != len)
1755                                 errx(1,"Error reading dump file header");
1756                         tbufptr = tpb->buf;
1757                         numtrec = ntrec = tpb->length / TP_BSIZE;
1758                         zflag = 1;
1759                 }
1760                 else {
1761                         /* read in the rest of the block based on bufsize */
1762                         len = bufsize - TP_BSIZE;
1763                         if (read_a_block(mt, tapebuf+TP_BSIZE, len, &i) < 0
1764                             || (i != len && i % TP_BSIZE != 0))
1765                                 errx(1,"Error reading dump file header");
1766                         tbufptr = tapebuf;
1767                         numtrec = ntrec;
1768                 }
1769                 Vprintf(stdout, "Input block size is %ld\n", ntrec);
1770                 return;
1771         }
1772
1773         /*
1774          * If the input is a variable block size tape, we tried to
1775          * read PREFIXSIZE + ntrec * TP_BSIZE bytes.
1776          * If it's not a compressed dump tape or the value of ntrec is
1777          * too large, we have read less than * what we asked for;
1778          * adjust the value of ntrec and test for * a compressed dump
1779          * tape prefix.
1780          */
1781
1782         if (i % TP_BSIZE != 0) {
1783                 if (i % TP_BSIZE == PREFIXSIZE
1784                     && tpb->compressed == 0
1785                     && spclpt->c_type == TS_TAPE
1786                     && spclpt->c_flags & DR_COMPRESSED) {
1787
1788                         zflag = 1;
1789                         tbufptr = tpb->buf;
1790                         if (tpb->length > bufsize)
1791                                 errx(1, "Tape blocksize is too large, use "
1792                                         "\'-b %d\' ", tpb->length / TP_BSIZE);
1793                 }
1794                 else
1795                         errx(1, "Tape block size (%ld) is not a multiple of dump block size (%d)",
1796                                 i, TP_BSIZE);
1797         }
1798         ntrec = i / TP_BSIZE;
1799         numtrec = ntrec;
1800         Vprintf(stdout, "Tape block size is %ld\n", ntrec);
1801 }
1802
1803 /*
1804  * Read a block of data handling all of the messy details.
1805  */
1806 static int read_a_block(int fd, char *buf, size_t len, long *lengthread)
1807 {
1808         long i = 1, size;
1809
1810         size = len;
1811         while (size > 0) {
1812 #ifdef RRESTORE
1813                 if (host)
1814                         i = rmtread(buf, size);
1815                 else
1816 #endif
1817                         i = read(fd, buf, size);
1818
1819                 if (i <= 0)
1820                         break; /* EOD or error */
1821                 size -= i;
1822                 if (magtapein)
1823                         break; /* block at a time for mt */
1824                 buf += i;
1825         }
1826         *lengthread = len - size;
1827         return i;
1828 }
1829
1830 void
1831 closemt(void)
1832 {
1833
1834         if (mt < 0)
1835                 return;
1836 #ifdef RRESTORE
1837         if (host)
1838                 rmtclose();
1839         else
1840 #endif
1841                 (void) close(mt);
1842 }
1843
1844 /*
1845  * Read the next block from the tape.
1846  * Check to see if it is one of several vintage headers.
1847  * If it is an old style header, convert it to a new style header.
1848  * If it is not any valid header, return an error.
1849  */
1850 static int
1851 gethead(struct s_spcl *buf)
1852 {
1853         int32_t i;
1854         union {
1855                 quad_t  qval;
1856                 int32_t val[2];
1857         } qcvt;
1858         union u_ospcl {
1859                 char dummy[TP_BSIZE];
1860                 struct  s_ospcl {
1861                         int32_t c_type;
1862                         int32_t c_date;
1863                         int32_t c_ddate;
1864                         int32_t c_volume;
1865                         int32_t c_tapea;
1866                         u_int16_t c_inumber;
1867                         int32_t c_magic;
1868                         int32_t c_checksum;
1869                         struct odinode {
1870                                 u_int16_t odi_mode;
1871                                 u_int16_t odi_nlink;
1872                                 u_int16_t odi_uid;
1873                                 u_int16_t odi_gid;
1874                                 int32_t odi_size;
1875                                 int32_t odi_rdev;
1876                                 char    odi_addr[36];
1877                                 int32_t odi_atime;
1878                                 int32_t odi_mtime;
1879                                 int32_t odi_ctime;
1880                         } c_dinode;
1881                         int32_t c_count;
1882                         char    c_addr[256];
1883                 } s_ospcl;
1884         } u_ospcl;
1885
1886         if (!cvtflag) {
1887                 readtape((char *)buf);
1888                 if (buf->c_magic != NFS_MAGIC) {
1889                         if (swabi(buf->c_magic) != NFS_MAGIC)
1890                                 return (FAIL);
1891                         if (!Bcvt) {
1892                                 Vprintf(stdout, "Note: Doing Byte swapping\n");
1893                                 Bcvt = 1;
1894                         }
1895                 }
1896                 if (checksum((int *)buf) == FAIL)
1897                         return (FAIL);
1898                 if (Bcvt)
1899                         swabst((u_char *)"8i4s31i528bi192b2i", (u_char *)buf);
1900                 goto good;
1901         }
1902         readtape((char *)(&u_ospcl.s_ospcl));
1903         memset((char *)buf, 0, (long)TP_BSIZE);
1904         buf->c_type = u_ospcl.s_ospcl.c_type;
1905         buf->c_date = u_ospcl.s_ospcl.c_date;
1906         buf->c_ddate = u_ospcl.s_ospcl.c_ddate;
1907         buf->c_volume = u_ospcl.s_ospcl.c_volume;
1908         buf->c_tapea = u_ospcl.s_ospcl.c_tapea;
1909         buf->c_inumber = u_ospcl.s_ospcl.c_inumber;
1910         buf->c_checksum = u_ospcl.s_ospcl.c_checksum;
1911         buf->c_magic = u_ospcl.s_ospcl.c_magic;
1912         buf->c_dinode.di_mode = u_ospcl.s_ospcl.c_dinode.odi_mode;
1913         buf->c_dinode.di_nlink = u_ospcl.s_ospcl.c_dinode.odi_nlink;
1914         buf->c_dinode.di_uid = u_ospcl.s_ospcl.c_dinode.odi_uid;
1915         buf->c_dinode.di_gid = u_ospcl.s_ospcl.c_dinode.odi_gid;
1916         buf->c_dinode.di_size = u_ospcl.s_ospcl.c_dinode.odi_size;
1917         buf->c_dinode.di_rdev = u_ospcl.s_ospcl.c_dinode.odi_rdev;
1918 #ifdef  __linux__
1919         buf->c_dinode.di_atime.tv_sec = u_ospcl.s_ospcl.c_dinode.odi_atime;
1920         buf->c_dinode.di_mtime.tv_sec = u_ospcl.s_ospcl.c_dinode.odi_mtime;
1921         buf->c_dinode.di_ctime.tv_sec = u_ospcl.s_ospcl.c_dinode.odi_ctime;
1922 #else   /* __linux__ */
1923         buf->c_dinode.di_atime = u_ospcl.s_ospcl.c_dinode.odi_atime;
1924         buf->c_dinode.di_mtime = u_ospcl.s_ospcl.c_dinode.odi_mtime;
1925         buf->c_dinode.di_ctime = u_ospcl.s_ospcl.c_dinode.odi_ctime;
1926 #endif  /* __linux__ */
1927         buf->c_count = u_ospcl.s_ospcl.c_count;
1928         memmove(buf->c_addr, u_ospcl.s_ospcl.c_addr, (long)256);
1929         if (u_ospcl.s_ospcl.c_magic != OFS_MAGIC ||
1930             checksum((int *)(&u_ospcl.s_ospcl)) == FAIL)
1931                 return(FAIL);
1932         buf->c_magic = NFS_MAGIC;
1933
1934 good:
1935         if ((buf->c_dinode.di_size == 0 || buf->c_dinode.di_size > 0xfffffff) &&
1936             (buf->c_dinode.di_mode & IFMT) == IFDIR && Qcvt == 0) {
1937                 qcvt.qval = buf->c_dinode.di_size;
1938                 if (qcvt.val[0] || qcvt.val[1]) {
1939                         printf("Note: Doing Quad swapping\n");
1940                         Qcvt = 1;
1941                 }
1942         }
1943         if (Qcvt) {
1944                 qcvt.qval = buf->c_dinode.di_size;
1945                 i = qcvt.val[1];
1946                 qcvt.val[1] = qcvt.val[0];
1947                 qcvt.val[0] = i;
1948                 buf->c_dinode.di_size = qcvt.qval;
1949         }
1950         readmapflag = 0;
1951
1952         switch (buf->c_type) {
1953
1954         case TS_CLRI:
1955         case TS_BITS:
1956                 /*
1957                  * Have to patch up missing information in bit map headers
1958                  */
1959                 buf->c_inumber = 0;
1960                 buf->c_dinode.di_size = buf->c_count * TP_BSIZE;
1961                 if (buf->c_count > TP_NINDIR)
1962                         readmapflag = 1;
1963                 else
1964                         for (i = 0; i < buf->c_count; i++)
1965                                 buf->c_addr[i]++;
1966                 break;
1967
1968         case TS_TAPE:
1969                 if ((buf->c_flags & DR_NEWINODEFMT) == 0)
1970                         oldinofmt = 1;
1971                 /* fall through */
1972         case TS_END:
1973                 buf->c_inumber = 0;
1974                 break;
1975
1976         case TS_INODE:
1977         case TS_ADDR:
1978                 break;
1979
1980         default:
1981                 panic("gethead: unknown inode type %d\n", buf->c_type);
1982                 break;
1983         }
1984         /*
1985          * If we are restoring a filesystem with old format inodes,
1986          * copy the uid/gid to the new location.
1987          */
1988         if (oldinofmt) {
1989                 buf->c_dinode.di_uid = buf->c_dinode.di_ouid;
1990                 buf->c_dinode.di_gid = buf->c_dinode.di_ogid;
1991         }
1992         if (dflag)
1993                 accthdr(buf);
1994         return(GOOD);
1995 }
1996
1997 /*
1998  * Check that a header is where it belongs and predict the next header
1999  */
2000 static void
2001 accthdr(struct s_spcl *header)
2002 {
2003         static dump_ino_t previno = 0x7fffffff;
2004         static int prevtype;
2005         static long predict;
2006         long blks, i;
2007
2008         if (header->c_type == TS_TAPE) {
2009                 fprintf(stderr, "Volume header (%s inode format) ",
2010                     oldinofmt ? "old" : "new");
2011                 if (header->c_firstrec)
2012                         fprintf(stderr, "begins with record %d",
2013                                 header->c_firstrec);
2014                 fprintf(stderr, "\n");
2015                 previno = 0x7fffffff;
2016                 return;
2017         }
2018         if (previno == 0x7fffffff)
2019                 goto newcalc;
2020         switch (prevtype) {
2021         case TS_BITS:
2022                 fprintf(stderr, "Dumped inodes map header");
2023                 break;
2024         case TS_CLRI:
2025                 fprintf(stderr, "Used inodes map header");
2026                 break;
2027         case TS_INODE:
2028                 fprintf(stderr, "File header, ino %lu", (unsigned long)previno);
2029                 break;
2030         case TS_ADDR:
2031                 fprintf(stderr, "File continuation header, ino %ld", (long)previno);
2032                 break;
2033         case TS_END:
2034                 fprintf(stderr, "End of tape header");
2035                 break;
2036         }
2037         if (predict != blksread - 1)
2038                 fprintf(stderr, "; predicted %ld blocks, got %ld blocks",
2039                         predict, blksread - 1);
2040         fprintf(stderr, "\n");
2041 newcalc:
2042         blks = 0;
2043         if (header->c_type != TS_END)
2044                 for (i = 0; i < header->c_count; i++)
2045                         if (readmapflag || header->c_addr[i] != 0)
2046                                 blks++;
2047         predict = blks;
2048         blksread = 0;
2049         prevtype = header->c_type;
2050         previno = header->c_inumber;
2051 }
2052
2053 /*
2054  * Find an inode header.
2055  * Complain if had to skip, and complain is set.
2056  */
2057 static void
2058 findinode(struct s_spcl *header)
2059 {
2060         static long skipcnt = 0;
2061         long i;
2062         char buf[TP_BSIZE];
2063
2064         curfile.name = "<name unknown>";
2065         curfile.action = UNKNOWN;
2066         curfile.dip = NULL;
2067         curfile.ino = 0;
2068         do {
2069                 if (header->c_magic != NFS_MAGIC) {
2070                         skipcnt++;
2071                         while (gethead(header) == FAIL ||
2072                             header->c_date != dumpdate)
2073                                 skipcnt++;
2074                 }
2075                 switch (header->c_type) {
2076
2077                 case TS_ADDR:
2078                         /*
2079                          * Skip up to the beginning of the next record
2080                          */
2081                         for (i = 0; i < header->c_count; i++)
2082                                 if (header->c_addr[i])
2083                                         readtape(buf);
2084                         while (gethead(header) == FAIL ||
2085                             header->c_date != dumpdate)
2086                                 skipcnt++;
2087                         break;
2088
2089                 case TS_INODE:
2090                         curfile.dip = &header->c_dinode;
2091                         curfile.ino = header->c_inumber;
2092                         break;
2093
2094                 case TS_END:
2095                         curfile.ino = maxino;
2096                         break;
2097
2098                 case TS_CLRI:
2099                         curfile.name = "<file removal list>";
2100                         break;
2101
2102                 case TS_BITS:
2103                         curfile.name = "<file dump list>";
2104                         break;
2105
2106                 case TS_TAPE:
2107                         panic("unexpected tape header\n");
2108                         /* NOTREACHED */
2109
2110                 default:
2111                         panic("unknown tape header type %d\n", spcl.c_type);
2112                         /* NOTREACHED */
2113
2114                 }
2115         } while (header->c_type == TS_ADDR);
2116         if (skipcnt > 0)
2117 #ifdef USE_QFA
2118                 if (!noresyncmesg)
2119 #endif
2120                         fprintf(stderr, "resync restore, skipped %ld blocks\n",
2121                                 skipcnt);
2122         skipcnt = 0;
2123 }
2124
2125 static int
2126 checksum(int *buf)
2127 {
2128         register int i, j;
2129
2130         j = sizeof(union u_spcl) / sizeof(int);
2131         i = 0;
2132         if(!Bcvt) {
2133                 do
2134                         i += *buf++;
2135                 while (--j);
2136         } else {
2137                 /* What happens if we want to read restore tapes
2138                         for a 16bit int machine??? */
2139                 do
2140                         i += swabi(*buf++);
2141                 while (--j);
2142         }
2143
2144         if (i != CHECKSUM) {
2145                 fprintf(stderr, "Checksum error %o, inode %lu file %s\n", i,
2146                         (unsigned long)curfile.ino, curfile.name);
2147                 return(FAIL);
2148         }
2149         return(GOOD);
2150 }
2151
2152 #ifdef RRESTORE
2153 #ifdef __STDC__
2154 #include <stdarg.h>
2155 #else
2156 #include <varargs.h>
2157 #endif
2158
2159 void
2160 #ifdef __STDC__
2161 msg(const char *fmt, ...)
2162 #else
2163 msg(fmt, va_alist)
2164         char *fmt;
2165         va_dcl
2166 #endif
2167 {
2168         va_list ap;
2169 #ifdef __STDC__
2170         va_start(ap, fmt);
2171 #else
2172         va_start(ap);
2173 #endif
2174         (void)vfprintf(stderr, fmt, ap);
2175         va_end(ap);
2176 }
2177 #endif /* RRESTORE */
2178
2179 static u_char *
2180 swab16(u_char *sp, int n)
2181 {
2182         char c;
2183
2184         while (--n >= 0) {
2185                 c = sp[0]; sp[0] = sp[1]; sp[1] = c;
2186                 sp += 2;
2187         }
2188         return (sp);
2189 }
2190
2191 static u_char *
2192 swab32(u_char *sp, int n)
2193 {
2194         char c;
2195
2196         while (--n >= 0) {
2197                 c = sp[0]; sp[0] = sp[3]; sp[3] = c;
2198                 c = sp[1]; sp[1] = sp[2]; sp[2] = c;
2199                 sp += 4;
2200         }
2201         return (sp);
2202 }
2203
2204 static u_char *
2205 swab64(u_char *sp, int n)
2206 {
2207         char c;
2208
2209         while (--n >= 0) {
2210                 c = sp[0]; sp[0] = sp[7]; sp[7] = c;
2211                 c = sp[1]; sp[1] = sp[6]; sp[6] = c;
2212                 c = sp[2]; sp[2] = sp[5]; sp[5] = c;
2213                 c = sp[3]; sp[3] = sp[4]; sp[4] = c;
2214                 sp += 8;
2215         }
2216         return (sp);
2217 }
2218
2219 void
2220 swabst(u_char *cp, u_char *sp)
2221 {
2222         int n = 0;
2223
2224         while (*cp) {
2225                 switch (*cp) {
2226                 case '0': case '1': case '2': case '3': case '4':
2227                 case '5': case '6': case '7': case '8': case '9':
2228                         n = (n * 10) + (*cp++ - '0');
2229                         continue;
2230
2231                 case 's': case 'w': case 'h':
2232                         if (n == 0)
2233                                 n = 1;
2234                         sp = swab16(sp, n);
2235                         break;
2236
2237                 case 'i':
2238                         if (n == 0)
2239                                 n = 1;
2240                         sp = swab32(sp, n);
2241                         break;
2242
2243                 case 'l':
2244                         if (n == 0)
2245                                 n = 1;
2246                         sp = swab64(sp, n);
2247                         break;
2248
2249                 default: /* Any other character, like 'b' counts as byte. */
2250                         if (n == 0)
2251                                 n = 1;
2252                         sp += n;
2253                         break;
2254                 }
2255                 cp++;
2256                 n = 0;
2257         }
2258 }
2259
2260 static u_int
2261 swabi(u_int x)
2262 {
2263         swabst((u_char *)"i", (u_char *)&x);
2264         return (x);
2265 }
2266
2267 #if 0
2268 static u_long
2269 swabl(u_long x)
2270 {
2271         swabst((u_char *)"l", (u_char *)&x);
2272         return (x);
2273 }
2274 #endif
2275
2276 #ifdef USE_QFA
2277 /*
2278  * get the current position of the tape
2279  */
2280 int
2281 GetTapePos(long *pos)
2282 {
2283         int err = 0;
2284
2285         *pos = 0;
2286         if (ioctl(mt, MTIOCPOS, pos) == -1) {
2287                 err = errno;
2288                 fprintf(stdout, "[%ld] error: %d (getting tapepos: %ld)\n",
2289                         (unsigned long)getpid(), err, *pos);
2290                 return err;
2291         }
2292         return err;
2293 }
2294
2295 typedef struct mt_pos {
2296         short    mt_op;
2297         int      mt_count;
2298 } MTPosRec, *MTPosPtr;
2299
2300 /*
2301  * go to specified position on tape
2302  */
2303 int
2304 GotoTapePos(long pos)
2305 {
2306         int err = 0;
2307         struct mt_pos buf;
2308
2309         buf.mt_op = MTSEEK;
2310         buf.mt_count = pos;
2311         if (ioctl(mt, MTIOCTOP, &buf) == -1) {
2312                 err = errno;
2313                 fprintf(stdout, "[%ld] error: %d (setting tapepos: %ld)\n",
2314                         (unsigned long)getpid(), err, pos);
2315                 return err;
2316         }
2317         return err;
2318 }
2319
2320 /*
2321  * read next data from tape to re-sync
2322  */
2323 void
2324 ReReadFromTape(void)
2325 {
2326         FLUSHTAPEBUF();
2327         noresyncmesg = 1;
2328         if (gethead(&spcl) == FAIL) {
2329 #ifdef DEBUG_QFA
2330                 fprintf(stdout, "DEBUG 1 gethead failed\n");
2331 #endif
2332         }
2333         findinode(&spcl);
2334         noresyncmesg = 0;
2335 }
2336
2337 void
2338 RequestVol(long tnum)
2339 {
2340         FLUSHTAPEBUF();
2341         getvol(tnum);
2342 }
2343 #endif /* USE_QFA */