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