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