bin/pax/ar_io.c

   1 /*-
   2  * Copyright (c) 1992 Keith Muller.
   3  * Copyright (c) 1992, 1993
   4  *      The Regents of the University of California.  All rights reserved.
   5  *
   6  * This code is derived from software contributed to Berkeley by
   7  * Keith Muller of the University of California, San Diego.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #ifndef lint
  35 #if 0
  36 static char sccsid[] = "@(#)ar_io.c     8.2 (Berkeley) 4/18/94";
  37 #endif
  38 #endif /* not lint */
  39 #include <sys/cdefs.h>
  40 __FBSDID("$FreeBSD$");
  41
  42 #include <sys/types.h>
  43 #include <sys/ioctl.h>
  44 #include <sys/mtio.h>
  45 #include <sys/stat.h>
  46 #include <sys/wait.h>
  47 #include <err.h>
  48 #include <errno.h>
  49 #include <fcntl.h>
  50 #include <signal.h>
  51 #include <stdint.h>
  52 #include <stdio.h>
  53 #include <string.h>
  54 #include <stdlib.h>
  55 #include <unistd.h>
  56 #include "pax.h"
  57 #include "options.h"
  58 #include "extern.h"
  59
  60 /*
  61  * Routines which deal directly with the archive I/O device/file.
  62  */
  63
  64 #define DMOD            0666            /* default mode of created archives */
  65 #define EXT_MODE        O_RDONLY        /* open mode for list/extract */
  66 #define AR_MODE         (O_WRONLY | O_CREAT | O_TRUNC)  /* mode for archive */
  67 #define APP_MODE        O_RDWR          /* mode for append */
  68
  69 static char none[] = "<NONE>";          /* pseudo name for no file */
  70 static char stdo[] = "<STDOUT>";        /* pseudo name for stdout */
  71 static char stdn[] = "<STDIN>";         /* pseudo name for stdin */
  72 static int arfd = -1;                   /* archive file descriptor */
  73 static int artyp = ISREG;               /* archive type: file/FIFO/tape */
  74 static int arvol = 1;                   /* archive volume number */
  75 static int lstrval = -1;                /* return value from last i/o */
  76 static int io_ok;                       /* i/o worked on volume after resync */
  77 static int did_io;                      /* did i/o ever occur on volume? */
  78 static int done;                        /* set via tty termination */
  79 static struct stat arsb;                /* stat of archive device at open */
  80 static int invld_rec;                   /* tape has out of spec record size */
  81 static int wr_trail = 1;                /* trailer was rewritten in append */
  82 static int can_unlnk = 0;               /* do we unlink null archives?  */
  83 const char *arcname;                    /* printable name of archive */
  84 const char *gzip_program;               /* name of gzip program */
  85 static pid_t zpid = -1;                 /* pid of child process */
  86
  87 static int get_phys(void);
  88 extern sigset_t s_mask;
  89 static void ar_start_gzip(int, const char *, int);
  90
  91 /*
  92  * ar_open()
  93  *      Opens the next archive volume. Determines the type of the device and
  94  *      sets up block sizes as required by the archive device and the format.
  95  *      Note: we may be called with name == NULL on the first open only.
  96  * Return:
  97  *      -1 on failure, 0 otherwise
  98  */
  99
 100 int
 101 ar_open(const char *name)
 102 {
 103         struct mtget mb;
 104
 105         if (arfd != -1)
 106                 (void)close(arfd);
 107         arfd = -1;
 108         can_unlnk = did_io = io_ok = invld_rec = 0;
 109         artyp = ISREG;
 110         flcnt = 0;
 111
 112         /*
 113          * open based on overall operation mode
 114          */
 115         switch (act) {
 116         case LIST:
 117         case EXTRACT:
 118                 if (name == NULL) {
 119                         arfd = STDIN_FILENO;
 120                         arcname = stdn;
 121                 } else if ((arfd = open(name, EXT_MODE, DMOD)) < 0)
 122                         syswarn(0, errno, "Failed open to read on %s", name);
 123                 if (arfd != -1 && gzip_program != NULL)
 124                         ar_start_gzip(arfd, gzip_program, 0);
 125                 break;
 126         case ARCHIVE:
 127                 if (name == NULL) {
 128                         arfd = STDOUT_FILENO;
 129                         arcname = stdo;
 130                 } else if ((arfd = open(name, AR_MODE, DMOD)) < 0)
 131                         syswarn(0, errno, "Failed open to write on %s", name);
 132                 else
 133                         can_unlnk = 1;
 134                 if (arfd != -1 && gzip_program != NULL)
 135                         ar_start_gzip(arfd, gzip_program, 1);
 136                 break;
 137         case APPND:
 138                 if (name == NULL) {
 139                         arfd = STDOUT_FILENO;
 140                         arcname = stdo;
 141                 } else if ((arfd = open(name, APP_MODE, DMOD)) < 0)
 142                         syswarn(0, errno, "Failed open to read/write on %s",
 143                                 name);
 144                 break;
 145         case COPY:
 146                 /*
 147                  * arfd not used in COPY mode
 148                  */
 149                 arcname = none;
 150                 lstrval = 1;
 151                 return(0);
 152         }
 153         if (arfd < 0)
 154                 return(-1);
 155
 156         if (chdname != NULL)
 157                 if (chdir(chdname) != 0) {
 158                         syswarn(1, errno, "Failed chdir to %s", chdname);
 159                         return(-1);
 160                 }
 161         /*
 162          * set up is based on device type
 163          */
 164         if (fstat(arfd, &arsb) < 0) {
 165                 syswarn(0, errno, "Failed stat on %s", arcname);
 166                 (void)close(arfd);
 167                 arfd = -1;
 168                 can_unlnk = 0;
 169                 return(-1);
 170         }
 171         if (S_ISDIR(arsb.st_mode)) {
 172                 paxwarn(0, "Cannot write an archive on top of a directory %s",
 173                     arcname);
 174                 (void)close(arfd);
 175                 arfd = -1;
 176                 can_unlnk = 0;
 177                 return(-1);
 178         }
 179
 180         if (S_ISCHR(arsb.st_mode))
 181                 artyp = ioctl(arfd, MTIOCGET, &mb) ? ISCHR : ISTAPE;
 182         else if (S_ISBLK(arsb.st_mode))
 183                 artyp = ISBLK;
 184         else if ((lseek(arfd, (off_t)0L, SEEK_CUR) == -1) && (errno == ESPIPE))
 185                 artyp = ISPIPE;
 186         else
 187                 artyp = ISREG;
 188
 189         /*
 190          * make sure we beyond any doubt that we only can unlink regular files
 191          * we created
 192          */
 193         if (artyp != ISREG)
 194                 can_unlnk = 0;
 195         /*
 196          * if we are writing, we are done
 197          */
 198         if (act == ARCHIVE) {
 199                 blksz = rdblksz = wrblksz;
 200                 lstrval = 1;
 201                 return(0);
 202         }
 203
 204         /*
 205          * set default blksz on read. APPNDs writes rdblksz on the last volume
 206          * On all new archive volumes, we shift to wrblksz (if the user
 207          * specified one, otherwise we will continue to use rdblksz). We
 208          * must to set blocksize based on what kind of device the archive is
 209          * stored.
 210          */
 211         switch(artyp) {
 212         case ISTAPE:
 213                 /*
 214                  * Tape drives come in at least two flavors. Those that support
 215                  * variable sized records and those that have fixed sized
 216                  * records. They must be treated differently. For tape drives
 217                  * that support variable sized records, we must make large
 218                  * reads to make sure we get the entire record, otherwise we
 219                  * will just get the first part of the record (up to size we
 220                  * asked). Tapes with fixed sized records may or may not return
 221                  * multiple records in a single read. We really do not care
 222                  * what the physical record size is UNLESS we are going to
 223                  * append. (We will need the physical block size to rewrite
 224                  * the trailer). Only when we are appending do we go to the
 225                  * effort to figure out the true PHYSICAL record size.
 226                  */
 227                 blksz = rdblksz = MAXBLK;
 228                 break;
 229         case ISPIPE:
 230         case ISBLK:
 231         case ISCHR:
 232                 /*
 233                  * Blocksize is not a major issue with these devices (but must
 234                  * be kept a multiple of 512). If the user specified a write
 235                  * block size, we use that to read. Under append, we must
 236                  * always keep blksz == rdblksz. Otherwise we go ahead and use
 237                  * the device optimal blocksize as (and if) returned by stat
 238                  * and if it is within pax specs.
 239                  */
 240                 if ((act == APPND) && wrblksz) {
 241                         blksz = rdblksz = wrblksz;
 242                         break;
 243                 }
 244
 245                 if ((arsb.st_blksize > 0) && (arsb.st_blksize < MAXBLK) &&
 246                     ((arsb.st_blksize % BLKMULT) == 0))
 247                         rdblksz = arsb.st_blksize;
 248                 else
 249                         rdblksz = DEVBLK;
 250                 /*
 251                  * For performance go for large reads when we can without harm
 252                  */
 253                 if ((act == APPND) || (artyp == ISCHR))
 254                         blksz = rdblksz;
 255                 else
 256                         blksz = MAXBLK;
 257                 break;
 258         case ISREG:
 259                 /*
 260                  * if the user specified wrblksz works, use it. Under appends
 261                  * we must always keep blksz == rdblksz
 262                  */
 263                 if ((act == APPND) && wrblksz && ((arsb.st_size%wrblksz)==0)){
 264                         blksz = rdblksz = wrblksz;
 265                         break;
 266                 }
 267                 /*
 268                  * See if we can find the blocking factor from the file size
 269                  */
 270                 for (rdblksz = MAXBLK; rdblksz > 0; rdblksz -= BLKMULT)
 271                         if ((arsb.st_size % rdblksz) == 0)
 272                                 break;
 273                 /*
 274                  * When we cannot find a match, we may have a flawed archive.
 275                  */
 276                 if (rdblksz <= 0)
 277                         rdblksz = FILEBLK;
 278                 /*
 279                  * for performance go for large reads when we can
 280                  */
 281                 if (act == APPND)
 282                         blksz = rdblksz;
 283                 else
 284                         blksz = MAXBLK;
 285                 break;
 286         default:
 287                 /*
 288                  * should never happen, worse case, slow...
 289                  */
 290                 blksz = rdblksz = BLKMULT;
 291                 break;
 292         }
 293         lstrval = 1;
 294         return(0);
 295 }
 296
 297 /*
 298  * ar_close()
 299  *      closes archive device, increments volume number, and prints i/o summary
 300  */
 301 void
 302 ar_close(void)
 303 {
 304         int status;
 305
 306         if (arfd < 0) {
 307                 did_io = io_ok = flcnt = 0;
 308                 return;
 309         }
 310
 311         /*
 312          * Close archive file. This may take a LONG while on tapes (we may be
 313          * forced to wait for the rewind to complete) so tell the user what is
 314          * going on (this avoids the user hitting control-c thinking pax is
 315          * broken).
 316          */
 317         if (vflag && (artyp == ISTAPE)) {
 318                 if (vfpart)
 319                         (void)putc('\n', listf);
 320                 (void)fprintf(listf,
 321                         "%s: Waiting for tape drive close to complete...",
 322                         argv0);
 323                 (void)fflush(listf);
 324         }
 325
 326         /*
 327          * if nothing was written to the archive (and we created it), we remove
 328          * it
 329          */
 330         if (can_unlnk && (fstat(arfd, &arsb) == 0) && (S_ISREG(arsb.st_mode)) &&
 331             (arsb.st_size == 0)) {
 332                 (void)unlink(arcname);
 333                 can_unlnk = 0;
 334         }
 335
 336         /*
 337          * for a quick extract/list, pax frequently exits before the child
 338          * process is done
 339          */
 340         if ((act == LIST || act == EXTRACT) && nflag && zpid > 0)
 341                 kill(zpid, SIGINT);
 342
 343         (void)close(arfd);
 344
 345         /* Do not exit before child to ensure data integrity */
 346         if (zpid > 0)
 347                 waitpid(zpid, &status, 0);
 348
 349         if (vflag && (artyp == ISTAPE)) {
 350                 (void)fputs("done.\n", listf);
 351                 vfpart = 0;
 352                 (void)fflush(listf);
 353         }
 354         arfd = -1;
 355
 356         if (!io_ok && !did_io) {
 357                 flcnt = 0;
 358                 return;
 359         }
 360         did_io = io_ok = 0;
 361
 362         /*
 363          * The volume number is only increased when the last device has data
 364          * and we have already determined the archive format.
 365          */
 366         if (frmt != NULL)
 367                 ++arvol;
 368
 369         if (!vflag) {
 370                 flcnt = 0;
 371                 return;
 372         }
 373
 374         /*
 375          * Print out a summary of I/O for this archive volume.
 376          */
 377         if (vfpart) {
 378                 (void)putc('\n', listf);
 379                 vfpart = 0;
 380         }
 381
 382         /*
 383          * If we have not determined the format yet, we just say how many bytes
 384          * we have skipped over looking for a header to id. There is no way we
 385          * could have written anything yet.
 386          */
 387         if (frmt == NULL) {
 388 #       ifdef NET2_STAT
 389                 (void)fprintf(listf, "%s: unknown format, %lu bytes skipped.\n",
 390                     argv0, rdcnt);
 391 #       else
 392                 (void)fprintf(listf, "%s: unknown format, %ju bytes skipped.\n",
 393                     argv0, (uintmax_t)rdcnt);
 394 #       endif
 395                 (void)fflush(listf);
 396                 flcnt = 0;
 397                 return;
 398         }
 399
 400         if (strcmp(NM_CPIO, argv0) == 0)
 401                 (void)fprintf(listf, "%llu blocks\n",
 402                     (unsigned long long)((rdcnt ? rdcnt : wrcnt) / 5120));
 403         else if (strcmp(NM_TAR, argv0) != 0)
 404                 (void)fprintf(listf,
 405 #       ifdef NET2_STAT
 406                     "%s: %s vol %d, %lu files, %lu bytes read, %lu bytes written.\n",
 407                     argv0, frmt->name, arvol-1, flcnt, rdcnt, wrcnt);
 408 #       else
 409                     "%s: %s vol %d, %ju files, %ju bytes read, %ju bytes written.\n",
 410                     argv0, frmt->name, arvol-1, (uintmax_t)flcnt,
 411                     (uintmax_t)rdcnt, (uintmax_t)wrcnt);
 412 #       endif
 413         (void)fflush(listf);
 414         flcnt = 0;
 415 }
 416
 417 /*
 418  * ar_drain()
 419  *      drain any archive format independent padding from an archive read
 420  *      from a socket or a pipe. This is to prevent the process on the
 421  *      other side of the pipe from getting a SIGPIPE (pax will stop
 422  *      reading an archive once a format dependent trailer is detected).
 423  */
 424 void
 425 ar_drain(void)
 426 {
 427         int res;
 428         char drbuf[MAXBLK];
 429
 430         /*
 431          * we only drain from a pipe/socket. Other devices can be closed
 432          * without reading up to end of file. We sure hope that pipe is closed
 433          * on the other side so we will get an EOF.
 434          */
 435         if ((artyp != ISPIPE) || (lstrval <= 0))
 436                 return;
 437
 438         /*
 439          * keep reading until pipe is drained
 440          */
 441         while ((res = read(arfd, drbuf, sizeof(drbuf))) > 0)
 442                 ;
 443         lstrval = res;
 444 }
 445
 446 /*
 447  * ar_set_wr()
 448  *      Set up device right before switching from read to write in an append.
 449  *      device dependent code (if required) to do this should be added here.
 450  *      For all archive devices we are already positioned at the place we want
 451  *      to start writing when this routine is called.
 452  * Return:
 453  *      0 if all ready to write, -1 otherwise
 454  */
 455
 456 int
 457 ar_set_wr(void)
 458 {
 459         off_t cpos;
 460
 461         /*
 462          * we must make sure the trailer is rewritten on append, ar_next()
 463          * will stop us if the archive containing the trailer was not written
 464          */
 465         wr_trail = 0;
 466
 467         /*
 468          * Add any device dependent code as required here
 469          */
 470         if (artyp != ISREG)
 471                 return(0);
 472         /*
 473          * Ok we have an archive in a regular file. If we were rewriting a
 474          * file, we must get rid of all the stuff after the current offset
 475          * (it was not written by pax).
 476          */
 477         if (((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) < 0) ||
 478             (ftruncate(arfd, cpos) < 0)) {
 479                 syswarn(1, errno, "Unable to truncate archive file");
 480                 return(-1);
 481         }
 482         return(0);
 483 }
 484
 485 /*
 486  * ar_app_ok()
 487  *      check if the last volume in the archive allows appends. We cannot check
 488  *      this until we are ready to write since there is no spec that says all
 489  *      volumes in a single archive have to be of the same type...
 490  * Return:
 491  *      0 if we can append, -1 otherwise.
 492  */
 493
 494 int
 495 ar_app_ok(void)
 496 {
 497         if (artyp == ISPIPE) {
 498                 paxwarn(1, "Cannot append to an archive obtained from a pipe.");
 499                 return(-1);
 500         }
 501
 502         if (!invld_rec)
 503                 return(0);
 504         paxwarn(1,"Cannot append, device record size %d does not support %s spec",
 505                 rdblksz, argv0);
 506         return(-1);
 507 }
 508
 509 /*
 510  * ar_read()
 511  *      read up to a specified number of bytes from the archive into the
 512  *      supplied buffer. When dealing with tapes we may not always be able to
 513  *      read what we want.
 514  * Return:
 515  *      Number of bytes in buffer. 0 for end of file, -1 for a read error.
 516  */
 517
 518 int
 519 ar_read(char *buf, int cnt)
 520 {
 521         int res = 0;
 522
 523         /*
 524          * if last i/o was in error, no more reads until reset or new volume
 525          */
 526         if (lstrval <= 0)
 527                 return(lstrval);
 528
 529         /*
 530          * how we read must be based on device type
 531          */
 532         switch (artyp) {
 533         case ISTAPE:
 534                 if ((res = read(arfd, buf, cnt)) > 0) {
 535                         /*
 536                          * CAUTION: tape systems may not always return the same
 537                          * sized records so we leave blksz == MAXBLK. The
 538                          * physical record size that a tape drive supports is
 539                          * very hard to determine in a uniform and portable
 540                          * manner.
 541                          */
 542                         io_ok = 1;
 543                         if (res != rdblksz) {
 544                                 /*
 545                                  * Record size changed. If this is happens on
 546                                  * any record after the first, we probably have
 547                                  * a tape drive which has a fixed record size
 548                                  * we are getting multiple records in a single
 549                                  * read). Watch out for record blocking that
 550                                  * violates pax spec (must be a multiple of
 551                                  * BLKMULT).
 552                                  */
 553                                 rdblksz = res;
 554                                 if (rdblksz % BLKMULT)
 555                                         invld_rec = 1;
 556                         }
 557                         return(res);
 558                 }
 559                 break;
 560         case ISREG:
 561         case ISBLK:
 562         case ISCHR:
 563         case ISPIPE:
 564         default:
 565                 /*
 566                  * Files are so easy to deal with. These other things cannot
 567                  * be trusted at all. So when we are dealing with character
 568                  * devices and pipes we just take what they have ready for us
 569                  * and return. Trying to do anything else with them runs the
 570                  * risk of failure.
 571                  */
 572                 if ((res = read(arfd, buf, cnt)) > 0) {
 573                         io_ok = 1;
 574                         return(res);
 575                 }
 576                 break;
 577         }
 578
 579         /*
 580          * We are in trouble at this point, something is broken...
 581          */
 582         lstrval = res;
 583         if (res < 0)
 584                 syswarn(1, errno, "Failed read on archive volume %d", arvol);
 585         else
 586                 paxwarn(0, "End of archive volume %d reached", arvol);
 587         return(res);
 588 }
 589
 590 /*
 591  * ar_write()
 592  *      Write a specified number of bytes in supplied buffer to the archive
 593  *      device so it appears as a single "block". Deals with errors and tries
 594  *      to recover when faced with short writes.
 595  * Return:
 596  *      Number of bytes written. 0 indicates end of volume reached and with no
 597  *      flaws (as best that can be detected). A -1 indicates an unrecoverable
 598  *      error in the archive occurred.
 599  */
 600
 601 int
 602 ar_write(char *buf, int bsz)
 603 {
 604         int res;
 605         off_t cpos;
 606
 607         /*
 608          * do not allow pax to create a "bad" archive. Once a write fails on
 609          * an archive volume prevent further writes to it.
 610          */
 611         if (lstrval <= 0)
 612                 return(lstrval);
 613
 614         if ((res = write(arfd, buf, bsz)) == bsz) {
 615                 wr_trail = 1;
 616                 io_ok = 1;
 617                 return(bsz);
 618         }
 619         /*
 620          * write broke, see what we can do with it. We try to send any partial
 621          * writes that may violate pax spec to the next archive volume.
 622          */
 623         if (res < 0)
 624                 lstrval = res;
 625         else
 626                 lstrval = 0;
 627
 628         switch (artyp) {
 629         case ISREG:
 630                 if ((res > 0) && (res % BLKMULT)) {
 631                         /*
 632                          * try to fix up partial writes which are not BLKMULT
 633                          * in size by forcing the runt record to next archive
 634                          * volume
 635                          */
 636                         if ((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) < 0)
 637                                 break;
 638                         cpos -= (off_t)res;
 639                         if (ftruncate(arfd, cpos) < 0)
 640                                 break;
 641                         res = lstrval = 0;
 642                         break;
 643                 }
 644                 if (res >= 0)
 645                         break;
 646                 /*
 647                  * if file is out of space, handle it like a return of 0
 648                  */
 649                 if ((errno == ENOSPC) || (errno == EFBIG) || (errno == EDQUOT))
 650                         res = lstrval = 0;
 651                 break;
 652         case ISTAPE:
 653         case ISCHR:
 654         case ISBLK:
 655                 if (res >= 0)
 656                         break;
 657                 if (errno == EACCES) {
 658                         paxwarn(0, "Write failed, archive is write protected.");
 659                         res = lstrval = 0;
 660                         return(0);
 661                 }
 662                 /*
 663                  * see if we reached the end of media, if so force a change to
 664                  * the next volume
 665                  */
 666                 if ((errno == ENOSPC) || (errno == EIO) || (errno == ENXIO))
 667                         res = lstrval = 0;
 668                 break;
 669         case ISPIPE:
 670         default:
 671                 /*
 672                  * we cannot fix errors to these devices
 673                  */
 674                 break;
 675         }
 676
 677         /*
 678          * Better tell the user the bad news...
 679          * if this is a block aligned archive format, we may have a bad archive
 680          * if the format wants the header to start at a BLKMULT boundary. While
 681          * we can deal with the mis-aligned data, it violates spec and other
 682          * archive readers will likely fail. If the format is not block
 683          * aligned, the user may be lucky (and the archive is ok).
 684          */
 685         if (res >= 0) {
 686                 if (res > 0)
 687                         wr_trail = 1;
 688                 io_ok = 1;
 689         }
 690
 691         /*
 692          * If we were trying to rewrite the trailer and it didn't work, we
 693          * must quit right away.
 694          */
 695         if (!wr_trail && (res <= 0)) {
 696                 paxwarn(1,"Unable to append, trailer re-write failed. Quitting.");
 697                 return(res);
 698         }
 699
 700         if (res == 0)
 701                 paxwarn(0, "End of archive volume %d reached", arvol);
 702         else if (res < 0)
 703                 syswarn(1, errno, "Failed write to archive volume: %d", arvol);
 704         else if (!frmt->blkalgn || ((res % frmt->blkalgn) == 0))
 705                 paxwarn(0,"WARNING: partial archive write. Archive MAY BE FLAWED");
 706         else
 707                 paxwarn(1,"WARNING: partial archive write. Archive IS FLAWED");
 708         return(res);
 709 }
 710
 711 /*
 712  * ar_rdsync()
 713  *      Try to move past a bad spot on a flawed archive as needed to continue
 714  *      I/O. Clears error flags to allow I/O to continue.
 715  * Return:
 716  *      0 when ok to try i/o again, -1 otherwise.
 717  */
 718
 719 int
 720 ar_rdsync(void)
 721 {
 722         long fsbz;
 723         off_t cpos;
 724         off_t mpos;
 725         struct mtop mb;
 726
 727         /*
 728          * Fail resync attempts at user request (done) or this is going to be
 729          * an update/append to an existing archive. If last i/o hit media end,
 730          * we need to go to the next volume not try a resync.
 731          */
 732         if ((done > 0) || (lstrval == 0))
 733                 return(-1);
 734
 735         if ((act == APPND) || (act == ARCHIVE)) {
 736                 paxwarn(1, "Cannot allow updates to an archive with flaws.");
 737                 return(-1);
 738         }
 739         if (io_ok)
 740                 did_io = 1;
 741
 742         switch(artyp) {
 743         case ISTAPE:
 744                 /*
 745                  * if the last i/o was a successful data transfer, we assume
 746                  * the fault is just a bad record on the tape that we are now
 747                  * past. If we did not get any data since the last resync try
 748                  * to move the tape forward one PHYSICAL record past any
 749                  * damaged tape section. Some tape drives are stubborn and need
 750                  * to be pushed.
 751                  */
 752                 if (io_ok) {
 753                         io_ok = 0;
 754                         lstrval = 1;
 755                         break;
 756                 }
 757                 mb.mt_op = MTFSR;
 758                 mb.mt_count = 1;
 759                 if (ioctl(arfd, MTIOCTOP, &mb) < 0)
 760                         break;
 761                 lstrval = 1;
 762                 break;
 763         case ISREG:
 764         case ISCHR:
 765         case ISBLK:
 766                 /*
 767                  * try to step over the bad part of the device.
 768                  */
 769                 io_ok = 0;
 770                 if (((fsbz = arsb.st_blksize) <= 0) || (artyp != ISREG))
 771                         fsbz = BLKMULT;
 772                 if ((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) < 0)
 773                         break;
 774                 mpos = fsbz - (cpos % (off_t)fsbz);
 775                 if (lseek(arfd, mpos, SEEK_CUR) < 0)
 776                         break;
 777                 lstrval = 1;
 778                 break;
 779         case ISPIPE:
 780         default:
 781                 /*
 782                  * cannot recover on these archive device types
 783                  */
 784                 io_ok = 0;
 785                 break;
 786         }
 787         if (lstrval <= 0) {
 788                 paxwarn(1, "Unable to recover from an archive read failure.");
 789                 return(-1);
 790         }
 791         paxwarn(0, "Attempting to recover from an archive read failure.");
 792         return(0);
 793 }
 794
 795 /*
 796  * ar_fow()
 797  *      Move the I/O position within the archive forward the specified number of
 798  *      bytes as supported by the device. If we cannot move the requested
 799  *      number of bytes, return the actual number of bytes moved in skipped.
 800  * Return:
 801  *      0 if moved the requested distance, -1 on complete failure, 1 on
 802  *      partial move (the amount moved is in skipped)
 803  */
 804
 805 int
 806 ar_fow(off_t sksz, off_t *skipped)
 807 {
 808         off_t cpos;
 809         off_t mpos;
 810
 811         *skipped = 0;
 812         if (sksz <= 0)
 813                 return(0);
 814
 815         /*
 816          * we cannot move forward at EOF or error
 817          */
 818         if (lstrval <= 0)
 819                 return(lstrval);
 820
 821         /*
 822          * Safer to read forward on devices where it is hard to find the end of
 823          * the media without reading to it. With tapes we cannot be sure of the
 824          * number of physical blocks to skip (we do not know physical block
 825          * size at this point), so we must only read forward on tapes!
 826          */
 827         if (artyp != ISREG)
 828                 return(0);
 829
 830         /*
 831          * figure out where we are in the archive
 832          */
 833         if ((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) >= 0) {
 834                 /*
 835                  * we can be asked to move farther than there are bytes in this
 836                  * volume, if so, just go to file end and let normal buf_fill()
 837                  * deal with the end of file (it will go to next volume by
 838                  * itself)
 839                  */
 840                 if ((mpos = cpos + sksz) > arsb.st_size) {
 841                         *skipped = arsb.st_size - cpos;
 842                         mpos = arsb.st_size;
 843                 } else
 844                         *skipped = sksz;
 845                 if (lseek(arfd, mpos, SEEK_SET) >= 0)
 846                         return(0);
 847         }
 848         syswarn(1, errno, "Forward positioning operation on archive failed");
 849         lstrval = -1;
 850         return(-1);
 851 }
 852
 853 /*
 854  * ar_rev()
 855  *      move the i/o position within the archive backwards the specified byte
 856  *      count as supported by the device. With tapes drives we RESET rdblksz to
 857  *      the PHYSICAL blocksize.
 858  *      NOTE: We should only be called to move backwards so we can rewrite the
 859  *      last records (the trailer) of an archive (APPEND).
 860  * Return:
 861  *      0 if moved the requested distance, -1 on complete failure
 862  */
 863
 864 int
 865 ar_rev(off_t sksz)
 866 {
 867         off_t cpos;
 868         struct mtop mb;
 869         int phyblk;
 870
 871         /*
 872          * make sure we do not have try to reverse on a flawed archive
 873          */
 874         if (lstrval < 0)
 875                 return(lstrval);
 876
 877         switch(artyp) {
 878         case ISPIPE:
 879                 if (sksz <= 0)
 880                         break;
 881                 /*
 882                  * cannot go backwards on these critters
 883                  */
 884                 paxwarn(1, "Reverse positioning on pipes is not supported.");
 885                 lstrval = -1;
 886                 return(-1);
 887         case ISREG:
 888         case ISBLK:
 889         case ISCHR:
 890         default:
 891                 if (sksz <= 0)
 892                         break;
 893
 894                 /*
 895                  * For things other than files, backwards movement has a very
 896                  * high probability of failure as we really do not know the
 897                  * true attributes of the device we are talking to (the device
 898                  * may not even have the ability to lseek() in any direction).
 899                  * First we figure out where we are in the archive.
 900                  */
 901                 if ((cpos = lseek(arfd, (off_t)0L, SEEK_CUR)) < 0) {
 902                         syswarn(1, errno,
 903                            "Unable to obtain current archive byte offset");
 904                         lstrval = -1;
 905                         return(-1);
 906                 }
 907
 908                 /*
 909                  * we may try to go backwards past the start when the archive
 910                  * is only a single record. If this happens and we are on a
 911                  * multi volume archive, we need to go to the end of the
 912                  * previous volume and continue our movement backwards from
 913                  * there.
 914                  */
 915                 if ((cpos -= sksz) < (off_t)0L) {
 916                         if (arvol > 1) {
 917                                 /*
 918                                  * this should never happen
 919                                  */
 920                                 paxwarn(1,"Reverse position on previous volume.");
 921                                 lstrval = -1;
 922                                 return(-1);
 923                         }
 924                         cpos = (off_t)0L;
 925                 }
 926                 if (lseek(arfd, cpos, SEEK_SET) < 0) {
 927                         syswarn(1, errno, "Unable to seek archive backwards");
 928                         lstrval = -1;
 929                         return(-1);
 930                 }
 931                 break;
 932         case ISTAPE:
 933                 /*
 934                  * Calculate and move the proper number of PHYSICAL tape
 935                  * blocks. If the sksz is not an even multiple of the physical
 936                  * tape size, we cannot do the move (this should never happen).
 937                  * (We also cannot handler trailers spread over two vols).
 938                  * get_phys() also makes sure we are in front of the filemark.
 939                  */
 940                 if ((phyblk = get_phys()) <= 0) {
 941                         lstrval = -1;
 942                         return(-1);
 943                 }
 944
 945                 /*
 946                  * make sure future tape reads only go by physical tape block
 947                  * size (set rdblksz to the real size).
 948                  */
 949                 rdblksz = phyblk;
 950
 951                 /*
 952                  * if no movement is required, just return (we must be after
 953                  * get_phys() so the physical blocksize is properly set)
 954                  */
 955                 if (sksz <= 0)
 956                         break;
 957
 958                 /*
 959                  * ok we have to move. Make sure the tape drive can do it.
 960                  */
 961                 if (sksz % phyblk) {
 962                         paxwarn(1,
 963                             "Tape drive unable to backspace requested amount");
 964                         lstrval = -1;
 965                         return(-1);
 966                 }
 967
 968                 /*
 969                  * move backwards the requested number of bytes
 970                  */
 971                 mb.mt_op = MTBSR;
 972                 mb.mt_count = sksz/phyblk;
 973                 if (ioctl(arfd, MTIOCTOP, &mb) < 0) {
 974                         syswarn(1,errno, "Unable to backspace tape %d blocks.",
 975                             mb.mt_count);
 976                         lstrval = -1;
 977                         return(-1);
 978                 }
 979                 break;
 980         }
 981         lstrval = 1;
 982         return(0);
 983 }
 984
 985 /*
 986  * get_phys()
 987  *      Determine the physical block size on a tape drive. We need the physical
 988  *      block size so we know how many bytes we skip over when we move with
 989  *      mtio commands. We also make sure we are BEFORE THE TAPE FILEMARK when
 990  *      return.
 991  *      This is one really SLOW routine...
 992  * Return:
 993  *      physical block size if ok (ok > 0), -1 otherwise
 994  */
 995
 996 static int
 997 get_phys(void)
 998 {
 999         int padsz = 0;
1000         int res;
1001         int phyblk;
1002         struct mtop mb;
1003         char scbuf[MAXBLK];
1004
1005         /*
1006          * move to the file mark, and then back up one record and read it.
1007          * this should tell us the physical record size the tape is using.
1008          */
1009         if (lstrval == 1) {
1010                 /*
1011                  * we know we are at file mark when we get back a 0 from
1012                  * read()
1013                  */
1014                 while ((res = read(arfd, scbuf, sizeof(scbuf))) > 0)
1015                         padsz += res;
1016                 if (res < 0) {
1017                         syswarn(1, errno, "Unable to locate tape filemark.");
1018                         return(-1);
1019                 }
1020         }
1021
1022         /*
1023          * move backwards over the file mark so we are at the end of the
1024          * last record.
1025          */
1026         mb.mt_op = MTBSF;
1027         mb.mt_count = 1;
1028         if (ioctl(arfd, MTIOCTOP, &mb) < 0) {
1029                 syswarn(1, errno, "Unable to backspace over tape filemark.");
1030                 return(-1);
1031         }
1032
1033         /*
1034          * move backwards so we are in front of the last record and read it to
1035          * get physical tape blocksize.
1036          */
1037         mb.mt_op = MTBSR;
1038         mb.mt_count = 1;
1039         if (ioctl(arfd, MTIOCTOP, &mb) < 0) {
1040                 syswarn(1, errno, "Unable to backspace over last tape block.");
1041                 return(-1);
1042         }
1043         if ((phyblk = read(arfd, scbuf, sizeof(scbuf))) <= 0) {
1044                 syswarn(1, errno, "Cannot determine archive tape blocksize.");
1045                 return(-1);
1046         }
1047
1048         /*
1049          * read forward to the file mark, then back up in front of the filemark
1050          * (this is a bit paranoid, but should be safe to do).
1051          */
1052         while ((res = read(arfd, scbuf, sizeof(scbuf))) > 0)
1053                 ;
1054         if (res < 0) {
1055                 syswarn(1, errno, "Unable to locate tape filemark.");
1056                 return(-1);
1057         }
1058         mb.mt_op = MTBSF;
1059         mb.mt_count = 1;
1060         if (ioctl(arfd, MTIOCTOP, &mb) < 0) {
1061                 syswarn(1, errno, "Unable to backspace over tape filemark.");
1062                 return(-1);
1063         }
1064
1065         /*
1066          * set lstrval so we know that the filemark has not been seen
1067          */
1068         lstrval = 1;
1069
1070         /*
1071          * return if there was no padding
1072          */
1073         if (padsz == 0)
1074                 return(phyblk);
1075
1076         /*
1077          * make sure we can move backwards over the padding. (this should
1078          * never fail).
1079          */
1080         if (padsz % phyblk) {
1081                 paxwarn(1, "Tape drive unable to backspace requested amount");
1082                 return(-1);
1083         }
1084
1085         /*
1086          * move backwards over the padding so the head is where it was when
1087          * we were first called (if required).
1088          */
1089         mb.mt_op = MTBSR;
1090         mb.mt_count = padsz/phyblk;
1091         if (ioctl(arfd, MTIOCTOP, &mb) < 0) {
1092                 syswarn(1,errno,"Unable to backspace tape over %d pad blocks",
1093                     mb.mt_count);
1094                 return(-1);
1095         }
1096         return(phyblk);
1097 }
1098
1099 /*
1100  * ar_next()
1101  *      prompts the user for the next volume in this archive. For some devices
1102  *      we may allow the media to be changed. Otherwise a new archive is
1103  *      prompted for. By pax spec, if there is no controlling tty or an eof is
1104  *      read on tty input, we must quit pax.
1105  * Return:
1106  *      0 when ready to continue, -1 when all done
1107  */
1108
1109 int
1110 ar_next(void)
1111 {
1112         static char *arcbuf;
1113         char buf[PAXPATHLEN+2];
1114         sigset_t o_mask;
1115
1116         /*
1117          * WE MUST CLOSE THE DEVICE. A lot of devices must see last close, (so
1118          * things like writing EOF etc will be done) (Watch out ar_close() can
1119          * also be called via a signal handler, so we must prevent a race.
1120          */
1121         if (sigprocmask(SIG_BLOCK, &s_mask, &o_mask) < 0)
1122                 syswarn(0, errno, "Unable to set signal mask");
1123         ar_close();
1124         if (sigprocmask(SIG_SETMASK, &o_mask, NULL) < 0)
1125                 syswarn(0, errno, "Unable to restore signal mask");
1126
1127         if (done || !wr_trail || strcmp(NM_TAR, argv0) == 0)
1128                 return(-1);
1129
1130         tty_prnt("\nATTENTION! %s archive volume change required.\n", argv0);
1131
1132         /*
1133          * if i/o is on stdin or stdout, we cannot reopen it (we do not know
1134          * the name), the user will be forced to type it in.
1135          */
1136         if (strcmp(arcname, stdo) && strcmp(arcname, stdn) && (artyp != ISREG)
1137             && (artyp != ISPIPE)) {
1138                 if (artyp == ISTAPE) {
1139                         tty_prnt("%s ready for archive tape volume: %d\n",
1140                                 arcname, arvol);
1141                         tty_prnt("Load the NEXT TAPE on the tape drive");
1142                 } else {
1143                         tty_prnt("%s ready for archive volume: %d\n",
1144                                 arcname, arvol);
1145                         tty_prnt("Load the NEXT STORAGE MEDIA (if required)");
1146                 }
1147
1148                 if ((act == ARCHIVE) || (act == APPND))
1149                         tty_prnt(" and make sure it is WRITE ENABLED.\n");
1150                 else
1151                         tty_prnt("\n");
1152
1153                 for(;;) {
1154                         tty_prnt("Type \"y\" to continue, \".\" to quit %s,",
1155                                 argv0);
1156                         tty_prnt(" or \"s\" to switch to new device.\nIf you");
1157                         tty_prnt(" cannot change storage media, type \"s\"\n");
1158                         tty_prnt("Is the device ready and online? > ");
1159
1160                         if ((tty_read(buf,sizeof(buf))<0) || !strcmp(buf,".")){
1161                                 done = 1;
1162                                 lstrval = -1;
1163                                 tty_prnt("Quitting %s!\n", argv0);
1164                                 vfpart = 0;
1165                                 return(-1);
1166                         }
1167
1168                         if ((buf[0] == '\0') || (buf[1] != '\0')) {
1169                                 tty_prnt("%s unknown command, try again\n",buf);
1170                                 continue;
1171                         }
1172
1173                         switch (buf[0]) {
1174                         case 'y':
1175                         case 'Y':
1176                                 /*
1177                                  * we are to continue with the same device
1178                                  */
1179                                 if (ar_open(arcname) >= 0)
1180                                         return(0);
1181                                 tty_prnt("Cannot re-open %s, try again\n",
1182                                         arcname);
1183                                 continue;
1184                         case 's':
1185                         case 'S':
1186                                 /*
1187                                  * user wants to open a different device
1188                                  */
1189                                 tty_prnt("Switching to a different archive\n");
1190                                 break;
1191                         default:
1192                                 tty_prnt("%s unknown command, try again\n",buf);
1193                                 continue;
1194                         }
1195                         break;
1196                 }
1197         } else
1198                 tty_prnt("Ready for archive volume: %d\n", arvol);
1199
1200         /*
1201          * have to go to a different archive
1202          */
1203         for (;;) {
1204                 tty_prnt("Input archive name or \".\" to quit %s.\n", argv0);
1205                 tty_prnt("Archive name > ");
1206
1207                 if ((tty_read(buf, sizeof(buf)) < 0) || !strcmp(buf, ".")) {
1208                         done = 1;
1209                         lstrval = -1;
1210                         tty_prnt("Quitting %s!\n", argv0);
1211                         vfpart = 0;
1212                         return(-1);
1213                 }
1214                 if (buf[0] == '\0') {
1215                         tty_prnt("Empty file name, try again\n");
1216                         continue;
1217                 }
1218                 if (!strcmp(buf, "..")) {
1219                         tty_prnt("Illegal file name: .. try again\n");
1220                         continue;
1221                 }
1222                 if (strlen(buf) > PAXPATHLEN) {
1223                         tty_prnt("File name too long, try again\n");
1224                         continue;
1225                 }
1226
1227                 /*
1228                  * try to open new archive
1229                  */
1230                 if (ar_open(buf) >= 0) {
1231                         free(arcbuf);
1232                         if ((arcbuf = strdup(buf)) == NULL) {
1233                                 done = 1;
1234                                 lstrval = -1;
1235                                 paxwarn(0, "Cannot save archive name.");
1236                                 return(-1);
1237                         }
1238                         arcname = arcbuf;
1239                         break;
1240                 }
1241                 tty_prnt("Cannot open %s, try again\n", buf);
1242                 continue;
1243         }
1244         return(0);
1245 }
1246
1247 /*
1248  * ar_start_gzip()
1249  * starts the gzip compression/decompression process as a child, using magic
1250  * to keep the fd the same in the calling function (parent).
1251  */
1252 void
1253 ar_start_gzip(int fd, const char *gzip_prog, int wr)
1254 {
1255         int fds[2];
1256         const char *gzip_flags;
1257
1258         if (pipe(fds) < 0)
1259                 err(1, "could not pipe");
1260         zpid = fork();
1261         if (zpid < 0)
1262                 err(1, "could not fork");
1263
1264         /* parent */
1265         if (zpid) {
1266                 if (wr)
1267                         dup2(fds[1], fd);
1268                 else
1269                         dup2(fds[0], fd);
1270                 close(fds[0]);
1271                 close(fds[1]);
1272         } else {
1273                 if (wr) {
1274                         dup2(fds[0], STDIN_FILENO);
1275                         dup2(fd, STDOUT_FILENO);
1276                         gzip_flags = "-c";
1277                 } else {
1278                         dup2(fds[1], STDOUT_FILENO);
1279                         dup2(fd, STDIN_FILENO);
1280                         gzip_flags = "-dc";
1281                 }
1282                 close(fds[0]);
1283                 close(fds[1]);
1284                 if (execlp(gzip_prog, gzip_prog, gzip_flags,
1285                     (char *)NULL) < 0)
1286                         err(1, "could not exec");
1287                 /* NOTREACHED */
1288         }
1289 }