bin/pax/buf_subs.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  * 3. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed by the University of
  20  *      California, Berkeley and its contributors.
  21  * 4. Neither the name of the University nor the names of its contributors
  22  *    may be used to endorse or promote products derived from this software
  23  *    without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  *
  37  * @(#)buf_subs.c       8.2 (Berkeley) 4/18/94
  38  * $FreeBSD: src/bin/pax/buf_subs.c,v 1.12.2.1 2001/08/01 05:03:11 obrien Exp $
  39  * $DragonFly: src/bin/pax/buf_subs.c,v 1.6 2006/09/27 21:58:08 pavalos Exp $
  40  */
  41
  42 #include <sys/types.h>
  43 #include <sys/stat.h>
  44 #include <errno.h>
  45 #include <unistd.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include "pax.h"
  50 #include "extern.h"
  51
  52 /*
  53  * routines which implement archive and file buffering
  54  */
  55
  56 #define MINFBSZ         512             /* default block size for hole detect */
  57 #define MAXFLT          10              /* default media read error limit */
  58
  59 /*
  60  * Need to change bufmem to dynamic allocation when the upper
  61  * limit on blocking size is removed (though that will violate pax spec)
  62  * MAXBLK define and tests will also need to be updated.
  63  */
  64 static char bufmem[MAXBLK+BLKMULT];     /* i/o buffer + pushback id space */
  65 static char *buf;                       /* normal start of i/o buffer */
  66 static char *bufend;                    /* end or last char in i/o buffer */
  67 static char *bufpt;                     /* read/write point in i/o buffer */
  68 int blksz = MAXBLK;                     /* block input/output size in bytes */
  69 int wrblksz;                            /* user spec output size in bytes */
  70 int maxflt = MAXFLT;                    /* MAX consecutive media errors */
  71 int rdblksz;                            /* first read blksize (tapes only) */
  72 off_t wrlimit;                          /* # of bytes written per archive vol */
  73 off_t wrcnt;                            /* # of bytes written on current vol */
  74 off_t rdcnt;                            /* # of bytes read on current vol */
  75
  76 /*
  77  * wr_start()
  78  *      set up the buffering system to operate in a write mode
  79  * Return:
  80  *      0 if ok, -1 if the user specified write block size violates pax spec
  81  */
  82
  83 int
  84 wr_start(void)
  85 {
  86         buf = &(bufmem[BLKMULT]);
  87         /*
  88          * Check to make sure the write block size meets pax specs. If the user
  89          * does not specify a blocksize, we use the format default blocksize.
  90          * We must be picky on writes, so we do not allow the user to create an
  91          * archive that might be hard to read elsewhere. If all ok, we then
  92          * open the first archive volume
  93          */
  94         if (!wrblksz)
  95                 wrblksz = frmt->bsz;
  96         if (wrblksz > MAXBLK) {
  97                 paxwarn(1, "Write block size of %d too large, maximum is: %d",
  98                         wrblksz, MAXBLK);
  99                 return(-1);
 100         }
 101         if (wrblksz % BLKMULT) {
 102                 paxwarn(1, "Write block size of %d is not a %d byte multiple",
 103                     wrblksz, BLKMULT);
 104                 return(-1);
 105         }
 106         if (wrblksz > MAXBLK_POSIX) {
 107                 paxwarn(0, "Write block size of %d larger than POSIX max %d, archive may not be portable",
 108                         wrblksz, MAXBLK_POSIX);
 109                 return(-1);
 110         }
 111
 112         /*
 113          * we only allow wrblksz to be used with all archive operations
 114          */
 115         blksz = rdblksz = wrblksz;
 116         if ((ar_open(arcname) < 0) && (ar_next() < 0))
 117                 return(-1);
 118         wrcnt = 0;
 119         bufend = buf + wrblksz;
 120         bufpt = buf;
 121         return(0);
 122 }
 123
 124 /*
 125  * rd_start()
 126  *      set up buffering system to read an archive
 127  * Return:
 128  *      0 if ok, -1 otherwise
 129  */
 130
 131 int
 132 rd_start(void)
 133 {
 134         /*
 135          * leave space for the header pushback (see get_arc()). If we are
 136          * going to append and user specified a write block size, check it
 137          * right away
 138          */
 139         buf = &(bufmem[BLKMULT]);
 140         if ((act == APPND) && wrblksz) {
 141                 if (wrblksz > MAXBLK) {
 142                         paxwarn(1,"Write block size %d too large, maximum is: %d",
 143                                 wrblksz, MAXBLK);
 144                         return(-1);
 145                 }
 146                 if (wrblksz % BLKMULT) {
 147                         paxwarn(1, "Write block size %d is not a %d byte multiple",
 148                         wrblksz, BLKMULT);
 149                         return(-1);
 150                 }
 151         }
 152
 153         /*
 154          * open the archive
 155          */
 156         if ((ar_open(arcname) < 0) && (ar_next() < 0))
 157                 return(-1);
 158         bufend = buf + rdblksz;
 159         bufpt = bufend;
 160         rdcnt = 0;
 161         return(0);
 162 }
 163
 164 /*
 165  * cp_start()
 166  *      set up buffer system for copying within the file system
 167  */
 168
 169 void
 170 cp_start(void)
 171 {
 172         buf = &(bufmem[BLKMULT]);
 173         rdblksz = blksz = MAXBLK;
 174 }
 175
 176 /*
 177  * appnd_start()
 178  *      Set up the buffering system to append new members to an archive that
 179  *      was just read. The last block(s) of an archive may contain a format
 180  *      specific trailer. To append a new member, this trailer has to be
 181  *      removed from the archive. The first byte of the trailer is replaced by
 182  *      the start of the header of the first file added to the archive. The
 183  *      format specific end read function tells us how many bytes to move
 184  *      backwards in the archive to be positioned BEFORE the trailer. Two
 185  *      different positions have to be adjusted, the O.S. file offset (e.g. the
 186  *      position of the tape head) and the write point within the data we have
 187  *      stored in the read (soon to become write) buffer. We may have to move
 188  *      back several records (the number depends on the size of the archive
 189  *      record and the size of the format trailer) to read up the record where
 190  *      the first byte of the trailer is recorded. Trailers may span (and
 191  *      overlap) record boundaries.
 192  *      We first calculate which record has the first byte of the trailer. We
 193  *      move the OS file offset back to the start of this record and read it
 194  *      up. We set the buffer write pointer to be at this byte (the byte where
 195  *      the trailer starts). We then move the OS file pointer back to the
 196  *      start of this record so a flush of this buffer will replace the record
 197  *      in the archive.
 198  *      A major problem is rewriting this last record. For archives stored
 199  *      on disk files, this is trivial. However, many devices are really picky
 200  *      about the conditions under which they will allow a write to occur.
 201  *      Often devices restrict the conditions where writes can be made,
 202  *      so it may not be feasible to append archives stored on all types of
 203  *      devices.
 204  * Return:
 205  *      0 for success, -1 for failure
 206  */
 207
 208 int
 209 appnd_start(off_t skcnt)
 210 {
 211         int res;
 212         off_t cnt;
 213
 214         if (exit_val != 0) {
 215                 paxwarn(0, "Cannot append to an archive that may have flaws.");
 216                 return(-1);
 217         }
 218         /*
 219          * if the user did not specify a write blocksize, inherit the size used
 220          * in the last archive volume read. (If a is set we still use rdblksz
 221          * until next volume, cannot shift sizes within a single volume).
 222          */
 223         if (!wrblksz)
 224                 wrblksz = blksz = rdblksz;
 225         else
 226                 blksz = rdblksz;
 227
 228         /*
 229          * make sure that this volume allows appends
 230          */
 231         if (ar_app_ok() < 0)
 232                 return(-1);
 233
 234         /*
 235          * Calculate bytes to move back and move in front of record where we
 236          * need to start writing from. Remember we have to add in any padding
 237          * that might be in the buffer after the trailer in the last block. We
 238          * travel skcnt + padding ROUNDED UP to blksize.
 239          */
 240         skcnt += bufend - bufpt;
 241         if ((cnt = (skcnt/blksz) * blksz) < skcnt)
 242                 cnt += blksz;
 243         if (ar_rev((off_t)cnt) < 0)
 244                 goto out;
 245
 246         /*
 247          * We may have gone too far if there is valid data in the block we are
 248          * now in front of, read up the block and position the pointer after
 249          * the valid data.
 250          */
 251         if ((cnt -= skcnt) > 0) {
 252                 /*
 253                  * watch out for stupid tape drives. ar_rev() will set rdblksz
 254                  * to be real physical blocksize so we must loop until we get
 255                  * the old rdblksz (now in blksz). If ar_rev() fouls up the
 256                  * determination of the physical block size, we will fail.
 257                  */
 258                 bufpt = buf;
 259                 bufend = buf + blksz;
 260                 while (bufpt < bufend) {
 261                         if ((res = ar_read(bufpt, rdblksz)) <= 0)
 262                                 goto out;
 263                         bufpt += res;
 264                 }
 265                 if (ar_rev((off_t)(bufpt - buf)) < 0)
 266                         goto out;
 267                 bufpt = buf + cnt;
 268                 bufend = buf + blksz;
 269         } else {
 270                 /*
 271                  * buffer is empty
 272                  */
 273                 bufend = buf + blksz;
 274                 bufpt = buf;
 275         }
 276         rdblksz = blksz;
 277         rdcnt -= skcnt;
 278         wrcnt = 0;
 279
 280         /*
 281          * At this point we are ready to write. If the device requires special
 282          * handling to write at a point were previously recorded data resides,
 283          * that is handled in ar_set_wr(). From now on we operate under normal
 284          * ARCHIVE mode (write) conditions
 285          */
 286         if (ar_set_wr() < 0)
 287                 return(-1);
 288         act = ARCHIVE;
 289         return(0);
 290
 291     out:
 292         paxwarn(1, "Unable to rewrite archive trailer, cannot append.");
 293         return(-1);
 294 }
 295
 296 /*
 297  * rd_sync()
 298  *      A read error occurred on this archive volume. Resync the buffer and
 299  *      try to reset the device (if possible) so we can continue to read. Keep
 300  *      trying to do this until we get a valid read, or we reach the limit on
 301  *      consecutive read faults (at which point we give up). The user can
 302  *      adjust the read error limit through a command line option.
 303  * Returns:
 304  *      0 on success, and -1 on failure
 305  */
 306
 307 int
 308 rd_sync(void)
 309 {
 310         int errcnt = 0;
 311         int res;
 312
 313         /*
 314          * if the user says bail out on first fault, we are out of here...
 315          */
 316         if (maxflt == 0)
 317                 return(-1);
 318         if (act == APPND) {
 319                 paxwarn(1, "Unable to append when there are archive read errors.");
 320                 return(-1);
 321         }
 322
 323         /*
 324          * poke at device and try to get past media error
 325          */
 326         if (ar_rdsync() < 0) {
 327                 if (ar_next() < 0)
 328                         return(-1);
 329                 else
 330                         rdcnt = 0;
 331         }
 332
 333         for (;;) {
 334                 if ((res = ar_read(buf, blksz)) > 0) {
 335                         /*
 336                          * All right! got some data, fill that buffer
 337                          */
 338                         bufpt = buf;
 339                         bufend = buf + res;
 340                         rdcnt += res;
 341                         return(0);
 342                 }
 343
 344                 /*
 345                  * Oh well, yet another failed read...
 346                  * if error limit reached, ditch. o.w. poke device to move past
 347                  * bad media and try again. if media is badly damaged, we ask
 348                  * the poor (and upset user at this point) for the next archive
 349                  * volume. remember the goal on reads is to get the most we
 350                  * can extract out of the archive.
 351                  */
 352                 if ((maxflt > 0) && (++errcnt > maxflt))
 353                         paxwarn(0,"Archive read error limit (%d) reached",maxflt);
 354                 else if (ar_rdsync() == 0)
 355                         continue;
 356                 if (ar_next() < 0)
 357                         break;
 358                 rdcnt = 0;
 359                 errcnt = 0;
 360         }
 361         return(-1);
 362 }
 363
 364 /*
 365  * pback()
 366  *      push the data used during the archive id phase back into the I/O
 367  *      buffer. This is required as we cannot be sure that the header does NOT
 368  *      overlap a block boundary (as in the case we are trying to recover a
 369  *      flawed archived). This was not designed to be used for any other
 370  *      purpose. (What software engineering, HA!)
 371  *      WARNING: do not even THINK of pback greater than BLKMULT, unless the
 372  *      pback space is increased.
 373  */
 374
 375 void
 376 pback(char *pt, int cnt)
 377 {
 378         bufpt -= cnt;
 379         memcpy(bufpt, pt, cnt);
 380         return;
 381 }
 382
 383 /*
 384  * rd_skip()
 385  *      skip forward in the archive during a archive read. Used to get quickly
 386  *      past file data and padding for files the user did NOT select.
 387  * Return:
 388  *      0 if ok, -1 failure, and 1 when EOF on the archive volume was detected.
 389  */
 390
 391 int
 392 rd_skip(off_t skcnt)
 393 {
 394         off_t res;
 395         off_t cnt;
 396         off_t skipped = 0;
 397
 398         /*
 399          * consume what data we have in the buffer. If we have to move forward
 400          * whole records, we call the low level skip function to see if we can
 401          * move within the archive without doing the expensive reads on data we
 402          * do not want.
 403          */
 404         if (skcnt == 0)
 405                 return(0);
 406         res = MIN((bufend - bufpt), skcnt);
 407         bufpt += res;
 408         skcnt -= res;
 409
 410         /*
 411          * if skcnt is now 0, then no additional i/o is needed
 412          */
 413         if (skcnt == 0)
 414                 return(0);
 415
 416         /*
 417          * We have to read more, calculate complete and partial record reads
 418          * based on rdblksz. we skip over "cnt" complete records
 419          */
 420         res = skcnt%rdblksz;
 421         cnt = (skcnt/rdblksz) * rdblksz;
 422
 423         /*
 424          * if the skip fails, we will have to resync. ar_fow will tell us
 425          * how much it can skip over. We will have to read the rest.
 426          */
 427         if (ar_fow(cnt, &skipped) < 0)
 428                 return(-1);
 429         res += cnt - skipped;
 430         rdcnt += skipped;
 431
 432         /*
 433          * what is left we have to read (which may be the whole thing if
 434          * ar_fow() told us the device can only read to skip records);
 435          */
 436         while (res > 0L) {
 437                 cnt = bufend - bufpt;
 438                 /*
 439                  * if the read fails, we will have to resync
 440                  */
 441                 if ((cnt <= 0) && ((cnt = buf_fill()) < 0))
 442                         return(-1);
 443                 if (cnt == 0)
 444                         return(1);
 445                 cnt = MIN(cnt, res);
 446                 bufpt += cnt;
 447                 res -= cnt;
 448         }
 449         return(0);
 450 }
 451
 452 /*
 453  * wr_fin()
 454  *      flush out any data (and pad if required) the last block. We always pad
 455  *      with zero (even though we do not have to). Padding with 0 makes it a
 456  *      lot easier to recover if the archive is damaged. zero padding SHOULD
 457  *      BE a requirement....
 458  */
 459
 460 void
 461 wr_fin(void)
 462 {
 463         if (bufpt > buf) {
 464                 memset(bufpt, 0, bufend - bufpt);
 465                 bufpt = bufend;
 466                 buf_flush(blksz);
 467         }
 468 }
 469
 470 /*
 471  * wr_rdbuf()
 472  *      fill the write buffer from data passed to it in a buffer (usually used
 473  *      by format specific write routines to pass a file header). On failure we
 474  *      punt. We do not allow the user to continue to write flawed archives.
 475  *      We assume these headers are not very large (the memory copy we use is
 476  *      a bit expensive).
 477  * Return:
 478  *      0 if buffer was filled ok, -1 o.w. (buffer flush failure)
 479  */
 480
 481 int
 482 wr_rdbuf(char *out, int outcnt)
 483 {
 484         int cnt;
 485
 486         /*
 487          * while there is data to copy copy into the write buffer. when the
 488          * write buffer fills, flush it to the archive and continue
 489          */
 490         while (outcnt > 0) {
 491                 cnt = bufend - bufpt;
 492                 if ((cnt <= 0) && ((cnt = buf_flush(blksz)) < 0))
 493                         return(-1);
 494                 /*
 495                  * only move what we have space for
 496                  */
 497                 cnt = MIN(cnt, outcnt);
 498                 memcpy(bufpt, out, cnt);
 499                 bufpt += cnt;
 500                 out += cnt;
 501                 outcnt -= cnt;
 502         }
 503         return(0);
 504 }
 505
 506 /*
 507  * rd_wrbuf()
 508  *      copy from the read buffer into a supplied buffer a specified number of
 509  *      bytes. If the read buffer is empty fill it and continue to copy.
 510  *      usually used to obtain a file header for processing by a format
 511  *      specific read routine.
 512  * Return
 513  *      number of bytes copied to the buffer, 0 indicates EOF on archive volume,
 514  *      -1 is a read error
 515  */
 516
 517 int
 518 rd_wrbuf(char *in, int cpcnt)
 519 {
 520         int res;
 521         int cnt;
 522         int incnt = cpcnt;
 523
 524         /*
 525          * loop until we fill the buffer with the requested number of bytes
 526          */
 527         while (incnt > 0) {
 528                 cnt = bufend - bufpt;
 529                 if ((cnt <= 0) && ((cnt = buf_fill()) <= 0)) {
 530                         /*
 531                          * read error, return what we got (or the error if
 532                          * no data was copied). The caller must know that an
 533                          * error occurred and has the best knowledge what to
 534                          * do with it
 535                          */
 536                         if ((res = cpcnt - incnt) > 0)
 537                                 return(res);
 538                         return(cnt);
 539                 }
 540
 541                 /*
 542                  * calculate how much data to copy based on whats left and
 543                  * state of buffer
 544                  */
 545                 cnt = MIN(cnt, incnt);
 546                 memcpy(in, bufpt, cnt);
 547                 bufpt += cnt;
 548                 incnt -= cnt;
 549                 in += cnt;
 550         }
 551         return(cpcnt);
 552 }
 553
 554 /*
 555  * wr_skip()
 556  *      skip forward during a write. In other words add padding to the file.
 557  *      we add zero filled padding as it makes flawed archives much easier to
 558  *      recover from. the caller tells us how many bytes of padding to add
 559  *      This routine was not designed to add HUGE amount of padding, just small
 560  *      amounts (a few 512 byte blocks at most)
 561  * Return:
 562  *      0 if ok, -1 if there was a buf_flush failure
 563  */
 564
 565 int
 566 wr_skip(off_t skcnt)
 567 {
 568         int cnt;
 569
 570         /*
 571          * loop while there is more padding to add
 572          */
 573         while (skcnt > 0L) {
 574                 cnt = bufend - bufpt;
 575                 if ((cnt <= 0) && ((cnt = buf_flush(blksz)) < 0))
 576                         return(-1);
 577                 cnt = MIN(cnt, skcnt);
 578                 memset(bufpt, 0, cnt);
 579                 bufpt += cnt;
 580                 skcnt -= cnt;
 581         }
 582         return(0);
 583 }
 584
 585 /*
 586  * wr_rdfile()
 587  *      fill write buffer with the contents of a file. We are passed an open
 588  *      file descriptor to the file an the archive structure that describes the
 589  *      file we are storing. The variable "left" is modified to contain the
 590  *      number of bytes of the file we were NOT able to write to the archive.
 591  *      it is important that we always write EXACTLY the number of bytes that
 592  *      the format specific write routine told us to. The file can also get
 593  *      bigger, so reading to the end of file would create an improper archive,
 594  *      we just detect this case and warn the user. We never create a bad
 595  *      archive if we can avoid it. Of course trying to archive files that are
 596  *      active is asking for trouble. It we fail, we pass back how much we
 597  *      could NOT copy and let the caller deal with it.
 598  * Return:
 599  *      0 ok, -1 if archive write failure. a short read of the file returns a
 600  *      0, but "left" is set to be greater than zero.
 601  */
 602
 603 int
 604 wr_rdfile(ARCHD *arcn, int ifd, off_t *left)
 605 {
 606         int cnt;
 607         int res = 0;
 608         off_t size = arcn->sb.st_size;
 609         struct stat sb;
 610
 611         /*
 612          * while there are more bytes to write
 613          */
 614         while (size > 0L) {
 615                 cnt = bufend - bufpt;
 616                 if ((cnt <= 0) && ((cnt = buf_flush(blksz)) < 0)) {
 617                         *left = size;
 618                         return(-1);
 619                 }
 620                 cnt = MIN(cnt, size);
 621                 if ((res = read(ifd, bufpt, cnt)) <= 0)
 622                         break;
 623                 size -= res;
 624                 bufpt += res;
 625         }
 626
 627         /*
 628          * better check the file did not change during this operation
 629          * or the file read failed.
 630          */
 631         if (res < 0)
 632                 syswarn(1, errno, "Read fault on %s", arcn->org_name);
 633         else if (size != 0L)
 634                 paxwarn(1, "File changed size during read %s", arcn->org_name);
 635         else if (fstat(ifd, &sb) < 0)
 636                 syswarn(1, errno, "Failed stat on %s", arcn->org_name);
 637         else if (arcn->sb.st_mtime != sb.st_mtime)
 638                 paxwarn(1, "File %s was modified during copy to archive",
 639                         arcn->org_name);
 640         *left = size;
 641         return(0);
 642 }
 643
 644 /*
 645  * rd_wrfile()
 646  *      extract the contents of a file from the archive. If we are unable to
 647  *      extract the entire file (due to failure to write the file) we return
 648  *      the numbers of bytes we did NOT process. This way the caller knows how
 649  *      many bytes to skip past to find the next archive header. If the failure
 650  *      was due to an archive read, we will catch that when we try to skip. If
 651  *      the format supplies a file data crc value, we calculate the actual crc
 652  *      so that it can be compared to the value stored in the header
 653  * NOTE:
 654  *      We call a special function to write the file. This function attempts to
 655  *      restore file holes (blocks of zeros) into the file. When files are
 656  *      sparse this saves space, and is a LOT faster. For non sparse files
 657  *      the performance hit is small. As of this writing, no archive supports
 658  *      information on where the file holes are.
 659  * Return:
 660  *      0 ok, -1 if archive read failure. if we cannot write the entire file,
 661  *      we return a 0 but "left" is set to be the amount unwritten
 662  */
 663
 664 int
 665 rd_wrfile(ARCHD *arcn, int ofd, off_t *left)
 666 {
 667         int cnt = 0;
 668         off_t size = arcn->sb.st_size;
 669         int res = 0;
 670         char *fnm = arcn->name;
 671         int isem = 1;
 672         int rem;
 673         int sz = MINFBSZ;
 674         struct stat sb;
 675         u_long crc = 0L;
 676
 677         /*
 678          * pass the blocksize of the file being written to the write routine,
 679          * if the size is zero, use the default MINFBSZ
 680          */
 681         if (fstat(ofd, &sb) == 0) {
 682                 if (sb.st_blksize > 0)
 683                         sz = (int)sb.st_blksize;
 684         } else
 685                 syswarn(0,errno,"Unable to obtain block size for file %s",fnm);
 686         rem = sz;
 687         *left = 0L;
 688
 689         /*
 690          * Copy the archive to the file the number of bytes specified. We have
 691          * to assume that we want to recover file holes as none of the archive
 692          * formats can record the location of file holes.
 693          */
 694         while (size > 0L) {
 695                 cnt = bufend - bufpt;
 696                 /*
 697                  * if we get a read error, we do not want to skip, as we may
 698                  * miss a header, so we do not set left, but if we get a write
 699                  * error, we do want to skip over the unprocessed data.
 700                  */
 701                 if ((cnt <= 0) && ((cnt = buf_fill()) <= 0))
 702                         break;
 703                 cnt = MIN(cnt, size);
 704                 if ((res = file_write(ofd,bufpt,cnt,&rem,&isem,sz,fnm)) <= 0) {
 705                         *left = size;
 706                         break;
 707                 }
 708
 709                 if (docrc) {
 710                         /*
 711                          * update the actual crc value
 712                          */
 713                         cnt = res;
 714                         while (--cnt >= 0)
 715                                 crc += *bufpt++ & 0xff;
 716                 } else
 717                         bufpt += res;
 718                 size -= res;
 719         }
 720
 721         /*
 722          * if the last block has a file hole (all zero), we must make sure this
 723          * gets updated in the file. We force the last block of zeros to be
 724          * written. just closing with the file offset moved forward may not put
 725          * a hole at the end of the file.
 726          */
 727         if (isem && (arcn->sb.st_size > 0L))
 728                 file_flush(ofd, fnm, isem);
 729
 730         /*
 731          * if we failed from archive read, we do not want to skip
 732          */
 733         if ((size > 0L) && (*left == 0L))
 734                 return(-1);
 735
 736         /*
 737          * some formats record a crc on file data. If so, then we compare the
 738          * calculated crc to the crc stored in the archive
 739          */
 740         if (docrc && (size == 0L) && (arcn->crc != crc))
 741                 paxwarn(1,"Actual crc does not match expected crc %s",arcn->name);
 742         return(0);
 743 }
 744
 745 /*
 746  * cp_file()
 747  *      copy the contents of one file to another. used during -rw phase of pax
 748  *      just as in rd_wrfile() we use a special write function to write the
 749  *      destination file so we can properly copy files with holes.
 750  */
 751
 752 void
 753 cp_file(ARCHD *arcn, int fd1, int fd2)
 754 {
 755         int cnt;
 756         off_t cpcnt = 0L;
 757         int res = 0;
 758         char *fnm = arcn->name;
 759         int no_hole = 0;
 760         int isem = 1;
 761         int rem;
 762         int sz = MINFBSZ;
 763         struct stat sb;
 764
 765         /*
 766          * check for holes in the source file. If none, we will use regular
 767          * write instead of file write.
 768          */
 769          if (((off_t)(arcn->sb.st_blocks * BLKMULT)) >= arcn->sb.st_size)
 770                 ++no_hole;
 771
 772         /*
 773          * pass the blocksize of the file being written to the write routine,
 774          * if the size is zero, use the default MINFBSZ
 775          */
 776         if (fstat(fd2, &sb) == 0) {
 777                 if (sb.st_blksize > 0)
 778                         sz = sb.st_blksize;
 779         } else
 780                 syswarn(0,errno,"Unable to obtain block size for file %s",fnm);
 781         rem = sz;
 782
 783         /*
 784          * read the source file and copy to destination file until EOF
 785          */
 786         for(;;) {
 787                 if ((cnt = read(fd1, buf, blksz)) <= 0)
 788                         break;
 789                 if (no_hole)
 790                         res = write(fd2, buf, cnt);
 791                 else
 792                         res = file_write(fd2, buf, cnt, &rem, &isem, sz, fnm);
 793                 if (res != cnt)
 794                         break;
 795                 cpcnt += cnt;
 796         }
 797
 798         /*
 799          * check to make sure the copy is valid.
 800          */
 801         if (res < 0)
 802                 syswarn(1, errno, "Failed write during copy of %s to %s",
 803                         arcn->org_name, arcn->name);
 804         else if (cpcnt != arcn->sb.st_size)
 805                 paxwarn(1, "File %s changed size during copy to %s",
 806                         arcn->org_name, arcn->name);
 807         else if (fstat(fd1, &sb) < 0)
 808                 syswarn(1, errno, "Failed stat of %s", arcn->org_name);
 809         else if (arcn->sb.st_mtime != sb.st_mtime)
 810                 paxwarn(1, "File %s was modified during copy to %s",
 811                         arcn->org_name, arcn->name);
 812
 813         /*
 814          * if the last block has a file hole (all zero), we must make sure this
 815          * gets updated in the file. We force the last block of zeros to be
 816          * written. just closing with the file offset moved forward may not put
 817          * a hole at the end of the file.
 818          */
 819         if (!no_hole && isem && (arcn->sb.st_size > 0L))
 820                 file_flush(fd2, fnm, isem);
 821         return;
 822 }
 823
 824 /*
 825  * buf_fill()
 826  *      fill the read buffer with the next record (or what we can get) from
 827  *      the archive volume.
 828  * Return:
 829  *      Number of bytes of data in the read buffer, -1 for read error, and
 830  *      0 when finished (user specified termination in ar_next()).
 831  */
 832
 833 int
 834 buf_fill(void)
 835 {
 836         int cnt;
 837         static int fini = 0;
 838
 839         if (fini)
 840                 return(0);
 841
 842         for(;;) {
 843                 /*
 844                  * try to fill the buffer. on error the next archive volume is
 845                  * opened and we try again.
 846                  */
 847                 if ((cnt = ar_read(buf, blksz)) > 0) {
 848                         bufpt = buf;
 849                         bufend = buf + cnt;
 850                         rdcnt += cnt;
 851                         return(cnt);
 852                 }
 853
 854                 /*
 855                  * errors require resync, EOF goes to next archive
 856                  */
 857                 if (cnt < 0)
 858                         break;
 859                 if (ar_next() < 0) {
 860                         fini = 1;
 861                         return(0);
 862                 }
 863                 rdcnt = 0;
 864         }
 865         exit_val = 1;
 866         return(-1);
 867 }
 868
 869 /*
 870  * buf_flush()
 871  *      force the write buffer to the archive. We are passed the number of
 872  *      bytes in the buffer at the point of the flush. When we change archives
 873  *      the record size might change. (either larger or smaller).
 874  * Return:
 875  *      0 if all is ok, -1 when a write error occurs.
 876  */
 877
 878 int
 879 buf_flush(int bufcnt)
 880 {
 881         int cnt;
 882         int push = 0;
 883         int totcnt = 0;
 884
 885         /*
 886          * if we have reached the user specified byte count for each archive
 887          * volume, prompt for the next volume. (The non-standard -R flag).
 888          * NOTE: If the wrlimit is smaller than wrcnt, we will always write
 889          * at least one record. We always round limit UP to next blocksize.
 890          */
 891         if ((wrlimit > 0) && (wrcnt > wrlimit)) {
 892                 paxwarn(0, "User specified archive volume byte limit reached.");
 893                 if (ar_next() < 0) {
 894                         wrcnt = 0;
 895                         exit_val = 1;
 896                         return(-1);
 897                 }
 898                 wrcnt = 0;
 899
 900                 /*
 901                  * The new archive volume might have changed the size of the
 902                  * write blocksize. if so we figure out if we need to write
 903                  * (one or more times), or if there is now free space left in
 904                  * the buffer (it is no longer full). bufcnt has the number of
 905                  * bytes in the buffer, (the blocksize, at the point we were
 906                  * CALLED). Push has the amount of "extra" data in the buffer
 907                  * if the block size has shrunk from a volume change.
 908                  */
 909                 bufend = buf + blksz;
 910                 if (blksz > bufcnt)
 911                         return(0);
 912                 if (blksz < bufcnt)
 913                         push = bufcnt - blksz;
 914         }
 915
 916         /*
 917          * We have enough data to write at least one archive block
 918          */
 919         for (;;) {
 920                 /*
 921                  * write a block and check if it all went out ok
 922                  */
 923                 cnt = ar_write(buf, blksz);
 924                 if (cnt == blksz) {
 925                         /*
 926                          * the write went ok
 927                          */
 928                         wrcnt += cnt;
 929                         totcnt += cnt;
 930                         if (push > 0) {
 931                                 /* we have extra data to push to the front.
 932                                  * check for more than 1 block of push, and if
 933                                  * so we loop back to write again
 934                                  */
 935                                 memcpy(buf, bufend, push);
 936                                 bufpt = buf + push;
 937                                 if (push >= blksz) {
 938                                         push -= blksz;
 939                                         continue;
 940                                 }
 941                         } else
 942                                 bufpt = buf;
 943                         return(totcnt);
 944                 } else if (cnt > 0) {
 945                         /*
 946                          * Oh drat we got a partial write!
 947                          * if format doesnt care about alignment let it go,
 948                          * we warned the user in ar_write().... but this means
 949                          * the last record on this volume violates pax spec....
 950                          */
 951                         totcnt += cnt;
 952                         wrcnt += cnt;
 953                         bufpt = buf + cnt;
 954                         cnt = bufcnt - cnt;
 955                         memcpy(buf, bufpt, cnt);
 956                         bufpt = buf + cnt;
 957                         if (!frmt->blkalgn || ((cnt % frmt->blkalgn) == 0))
 958                                 return(totcnt);
 959                         break;
 960                 }
 961
 962                 /*
 963                  * All done, go to next archive
 964                  */
 965                 wrcnt = 0;
 966                 if (ar_next() < 0)
 967                         break;
 968
 969                 /*
 970                  * The new archive volume might also have changed the block
 971                  * size. if so, figure out if we have too much or too little
 972                  * data for using the new block size
 973                  */
 974                 bufend = buf + blksz;
 975                 if (blksz > bufcnt)
 976                         return(0);
 977                 if (blksz < bufcnt)
 978                         push = bufcnt - blksz;
 979         }
 980
 981         /*
 982          * write failed, stop pax. we must not create a bad archive!
 983          */
 984         exit_val = 1;
 985         return(-1);
 986 }