restore/tape.c

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