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