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