?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dmake: do not set MAKEFLAGS=k
[unleashed/tickless.git] / bin / pax / ar_subs.c
blob51dd6e0859b6754d7cf78d2e941992afe97fcdf4
1 /* $OpenBSD: ar_subs.c,v 1.48 2016/08/26 05:06:14 guenther Exp $ */
2 /* $NetBSD: ar_subs.c,v 1.5 1995/03/21 09:07:06 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/types.h>
38 #include <sys/stat.h>
39 #include <errno.h>
40 #include <fcntl.h>
41 #include <signal.h>
42 #include <stdio.h>
43 #include <string.h>
44 #include <time.h>
45 #include <unistd.h>
46
47 #include "pax.h"
48 #include "extern.h"
49
50 static void wr_archive(ARCHD *, int is_app);
51 static int get_arc(void);
52 static int next_head(ARCHD *);
53 extern sigset_t s_mask;
54
55 /*
56 * Routines which control the overall operation modes of pax as specified by
57 * the user: list, append, read ...
58 */
59
60 static char hdbuf[BLKMULT]; /* space for archive header on read */
61 u_long flcnt; /* number of files processed */
62
63 /*
64 * list()
65 * list the contents of an archive which match user supplied pattern(s)
66 * (no pattern matches all).
67 */
68
69 void
70 list(void)
71 {
72 ARCHD *arcn;
73 int res;
74 ARCHD archd;
75 time_t now;
76
77 arcn = &archd;
78 /*
79 * figure out archive type; pass any format specific options to the
80 * archive option processing routine; call the format init routine. We
81 * also save current time for ls_list() so we do not make a system
82 * call for each file we need to print. If verbose (vflag) start up
83 * the name and group caches.
84 */
85 if ((get_arc() < 0) || ((*frmt->options)() < 0) ||
86 ((*frmt->st_rd)() < 0))
87 return;
88
89 now = time(NULL);
90
91 /*
92 * step through the archive until the format says it is done
93 */
94 while (next_head(arcn) == 0) {
95 if (arcn->type == PAX_GLL || arcn->type == PAX_GLF) {
96 /*
97 * we need to read, to get the real filename
98 */
99 off_t cnt;
100 if (!rd_wrfile(arcn, arcn->type == PAX_GLF
101 ? -1 : -2, &cnt))
102 (void)rd_skip(cnt + arcn->pad);
103 continue;
104 }
105
106 /*
107 * check for pattern, and user specified options match.
108 * When all patterns are matched we are done.
109 */
110 if ((res = pat_match(arcn)) < 0)
111 break;
112
113 if ((res == 0) && (sel_chk(arcn) == 0)) {
114 /*
115 * pattern resulted in a selected file
116 */
117 if (pat_sel(arcn) < 0)
118 break;
119
120 /*
121 * modify the name as requested by the user if name
122 * survives modification, do a listing of the file
123 */
124 if ((res = mod_name(arcn)) < 0)
125 break;
126 if (res == 0)
127 ls_list(arcn, now, stdout);
128 }
129
130 /*
131 * skip to next archive format header using values calculated
132 * by the format header read routine
133 */
134 if (rd_skip(arcn->skip + arcn->pad) == 1)
135 break;
136 }
137
138 /*
139 * all done, let format have a chance to cleanup, and make sure that
140 * the patterns supplied by the user were all matched
141 */
142 (void)(*frmt->end_rd)();
143 (void)sigprocmask(SIG_BLOCK, &s_mask, NULL);
144 ar_close(0);
145 pat_chk();
146 }
147
148 static int
149 cmp_file_times(int mtime_flag, int ctime_flag, ARCHD *arcn, struct stat *sbp)
150 {
151 struct stat sb;
152
153 if (sbp == NULL) {
154 if (lstat(arcn->name, &sb) != 0)
155 return (0);
156 sbp = &sb;
157 }
158
159 if (ctime_flag && mtime_flag)
160 return (timespeccmp(&arcn->sb.st_mtim, &sbp->st_mtim, <=) &&
161 timespeccmp(&arcn->sb.st_ctim, &sbp->st_ctim, <=));
162 else if (ctime_flag)
163 return (timespeccmp(&arcn->sb.st_ctim, &sbp->st_ctim, <=));
164 else
165 return (timespeccmp(&arcn->sb.st_mtim, &sbp->st_mtim, <=));
166 }
167
168 /*
169 * extract()
170 * extract the member(s) of an archive as specified by user supplied
171 * pattern(s) (no patterns extracts all members)
172 */
173
174 void
175 extract(void)
176 {
177 ARCHD *arcn;
178 int res;
179 off_t cnt;
180 ARCHD archd;
181 int fd;
182 time_t now;
183
184 sltab_start();
185
186 arcn = &archd;
187 /*
188 * figure out archive type; pass any format specific options to the
189 * archive option processing routine; call the format init routine;
190 * start up the directory modification time and access mode database
191 */
192 if ((get_arc() < 0) || ((*frmt->options)() < 0) ||
193 ((*frmt->st_rd)() < 0) || (dir_start() < 0))
194 return;
195
196 /*
197 * When we are doing interactive rename, we store the mapping of names
198 * so we can fix up hard links files later in the archive.
199 */
200 if (iflag && (name_start() < 0))
201 return;
202
203 now = time(NULL);
204
205 /*
206 * step through each entry on the archive until the format read routine
207 * says it is done
208 */
209 while (next_head(arcn) == 0) {
210 if (arcn->type == PAX_GLL || arcn->type == PAX_GLF) {
211 /*
212 * we need to read, to get the real filename
213 */
214 if (!rd_wrfile(arcn, arcn->type == PAX_GLF
215 ? -1 : -2, &cnt))
216 (void)rd_skip(cnt + arcn->pad);
217 continue;
218 }
219
220 /*
221 * check for pattern, and user specified options match. When
222 * all the patterns are matched we are done
223 */
224 if ((res = pat_match(arcn)) < 0)
225 break;
226
227 if ((res > 0) || (sel_chk(arcn) != 0)) {
228 /*
229 * file is not selected. skip past any file data and
230 * padding and go back for the next archive member
231 */
232 (void)rd_skip(arcn->skip + arcn->pad);
233 continue;
234 }
235
236 /*
237 * with -u or -D only extract when the archive member is newer
238 * than the file with the same name in the file system (no
239 * test of being the same type is required).
240 * NOTE: this test is done BEFORE name modifications as
241 * specified by pax. this operation can be confusing to the
242 * user who might expect the test to be done on an existing
243 * file AFTER the name mod. In honesty the pax spec is probably
244 * flawed in this respect.
245 */
246 if ((uflag || Dflag) &&
247 cmp_file_times(uflag, Dflag, arcn, NULL)) {
248 (void)rd_skip(arcn->skip + arcn->pad);
249 continue;
250 }
251
252 /*
253 * this archive member is now been selected. modify the name.
254 */
255 if ((pat_sel(arcn) < 0) || ((res = mod_name(arcn)) < 0))
256 break;
257 if (res > 0) {
258 /*
259 * a bad name mod, skip and purge name from link table
260 */
261 purg_lnk(arcn);
262 (void)rd_skip(arcn->skip + arcn->pad);
263 continue;
264 }
265
266 /*
267 * Non standard -Y and -Z flag. When the existing file is
268 * same age or newer skip
269 */
270 if ((Yflag || Zflag) &&
271 cmp_file_times(Yflag, Zflag, arcn, NULL)) {
272 (void)rd_skip(arcn->skip + arcn->pad);
273 continue;
274 }
275
276 if (vflag) {
277 if (vflag > 1)
278 ls_list(arcn, now, listf);
279 else {
280 (void)safe_print(arcn->name, listf);
281 vfpart = 1;
282 }
283 }
284
285 /*
286 * if required, chdir around.
287 */
288 if ((arcn->pat != NULL) && (arcn->pat->chdname != NULL))
289 if (chdir(arcn->pat->chdname) != 0)
290 syswarn(1, errno, "Cannot chdir to %s",
291 arcn->pat->chdname);
292
293 /*
294 * all ok, extract this member based on type
295 */
296 if (!PAX_IS_REG(arcn->type)) {
297 /*
298 * process archive members that are not regular files.
299 * throw out padding and any data that might follow the
300 * header (as determined by the format).
301 */
302 if (PAX_IS_HARDLINK(arcn->type))
303 res = lnk_creat(arcn);
304 else
305 res = node_creat(arcn);
306
307 (void)rd_skip(arcn->skip + arcn->pad);
308 if (res < 0)
309 purg_lnk(arcn);
310
311 if (vflag && vfpart) {
312 (void)putc('\n', listf);
313 vfpart = 0;
314 }
315 goto popd;
316 }
317 /*
318 * we have a file with data here. If we can not create it, skip
319 * over the data and purge the name from hard link table
320 */
321 if ((fd = file_creat(arcn)) < 0) {
322 (void)rd_skip(arcn->skip + arcn->pad);
323 purg_lnk(arcn);
324 goto popd;
325 }
326 /*
327 * extract the file from the archive and skip over padding and
328 * any unprocessed data
329 */
330 res = rd_wrfile(arcn, fd, &cnt);
331 file_close(arcn, fd);
332 if (vflag && vfpart) {
333 (void)putc('\n', listf);
334 vfpart = 0;
335 }
336 if (!res)
337 (void)rd_skip(cnt + arcn->pad);
338
339 popd:
340 /*
341 * if required, chdir around.
342 */
343 if ((arcn->pat != NULL) && (arcn->pat->chdname != NULL))
344 if (fchdir(cwdfd) != 0)
345 syswarn(1, errno,
346 "Can't fchdir to starting directory");
347 }
348
349 /*
350 * all done, restore directory modes and times as required; make sure
351 * all patterns supplied by the user were matched; block off signals
352 * to avoid chance for multiple entry into the cleanup code.
353 */
354 (void)(*frmt->end_rd)();
355 (void)sigprocmask(SIG_BLOCK, &s_mask, NULL);
356 ar_close(0);
357 sltab_process(0);
358 proc_dir(0);
359 pat_chk();
360 }
361
362 /*
363 * wr_archive()
364 * Write an archive. used in both creating a new archive and appends on
365 * previously written archive.
366 */
367
368 static void
369 wr_archive(ARCHD *arcn, int is_app)
370 {
371 int res;
372 int hlk;
373 int wr_one;
374 off_t cnt;
375 int (*wrf)(ARCHD *);
376 int fd = -1;
377 time_t now;
378
379 /*
380 * if this format supports hard link storage, start up the database
381 * that detects them.
382 */
383 if (((hlk = frmt->hlk) == 1) && (lnk_start() < 0))
384 return;
385
386 /*
387 * if this is not append, and there are no files, we do not write a
388 * trailer
389 */
390 wr_one = is_app;
391
392 /*
393 * start up the file traversal code and format specific write
394 */
395 if (ftree_start() < 0) {
396 if (is_app)
397 goto trailer;
398 return;
399 } else if (((*frmt->st_wr)() < 0))
400 return;
401
402 wrf = frmt->wr;
403
404 /*
405 * When we are doing interactive rename, we store the mapping of names
406 * so we can fix up hard links files later in the archive.
407 */
408 if (iflag && (name_start() < 0))
409 return;
410
411 now = time(NULL);
412
413 /*
414 * while there are files to archive, process them one at at time
415 */
416 while (next_file(arcn) == 0) {
417 /*
418 * check if this file meets user specified options match.
419 */
420 if (sel_chk(arcn) != 0)
421 continue;
422 fd = -1;
423 if (uflag) {
424 /*
425 * only archive if this file is newer than a file with
426 * the same name that is already stored on the archive
427 */
428 if ((res = chk_ftime(arcn)) < 0)
429 break;
430 if (res > 0) {
431 ftree_skipped_newer(arcn);
432 continue;
433 }
434 }
435
436 /*
437 * this file is considered selected now. see if this is a hard
438 * link to a file already stored
439 */
440 ftree_sel(arcn);
441 if (hlk && (chk_lnk(arcn) < 0))
442 break;
443
444 if (PAX_IS_REG(arcn->type) || (arcn->type == PAX_HRG)) {
445 /*
446 * we will have to read this file. by opening it now we
447 * can avoid writing a header to the archive for a file
448 * we were later unable to read (we also purge it from
449 * the link table).
450 */
451 if ((fd = open(arcn->org_name, O_RDONLY, 0)) < 0) {
452 syswarn(1,errno, "Unable to open %s to read",
453 arcn->org_name);
454 purg_lnk(arcn);
455 continue;
456 }
457 }
458
459 /*
460 * Now modify the name as requested by the user
461 */
462 if ((res = mod_name(arcn)) < 0) {
463 /*
464 * name modification says to skip this file, close the
465 * file and purge link table entry
466 */
467 rdfile_close(arcn, &fd);
468 purg_lnk(arcn);
469 break;
470 }
471
472 if ((res > 0) || (docrc && (set_crc(arcn, fd) < 0))) {
473 /*
474 * unable to obtain the crc we need, close the file,
475 * purge link table entry
476 */
477 rdfile_close(arcn, &fd);
478 purg_lnk(arcn);
479 continue;
480 }
481
482 if (vflag) {
483 if (vflag > 1)
484 ls_list(arcn, now, listf);
485 else {
486 (void)safe_print(arcn->name, listf);
487 vfpart = 1;
488 }
489 }
490 ++flcnt;
491
492 /*
493 * looks safe to store the file, have the format specific
494 * routine write routine store the file header on the archive
495 */
496 if ((res = (*wrf)(arcn)) < 0) {
497 rdfile_close(arcn, &fd);
498 break;
499 }
500 wr_one = 1;
501 if (res > 0) {
502 /*
503 * format write says no file data needs to be stored
504 * so we are done messing with this file
505 */
506 if (vflag && vfpart) {
507 (void)putc('\n', listf);
508 vfpart = 0;
509 }
510 rdfile_close(arcn, &fd);
511 continue;
512 }
513
514 /*
515 * Add file data to the archive, quit on write error. if we
516 * cannot write the entire file contents to the archive we
517 * must pad the archive to replace the missing file data
518 * (otherwise during an extract the file header for the file
519 * which FOLLOWS this one will not be where we expect it to
520 * be).
521 */
522 res = wr_rdfile(arcn, fd, &cnt);
523 rdfile_close(arcn, &fd);
524 if (vflag && vfpart) {
525 (void)putc('\n', listf);
526 vfpart = 0;
527 }
528 if (res < 0)
529 break;
530
531 /*
532 * pad as required, cnt is number of bytes not written
533 */
534 if (((cnt > 0) && (wr_skip(cnt) < 0)) ||
535 ((arcn->pad > 0) && (wr_skip(arcn->pad) < 0)))
536 break;
537 }
538
539 trailer:
540 /*
541 * tell format to write trailer; pad to block boundary; reset directory
542 * mode/access times, and check if all patterns supplied by the user
543 * were matched. block off signals to avoid chance for multiple entry
544 * into the cleanup code
545 */
546 if (wr_one) {
547 (*frmt->end_wr)();
548 wr_fin();
549 }
550 (void)sigprocmask(SIG_BLOCK, &s_mask, NULL);
551 ar_close(0);
552 if (tflag)
553 proc_dir(0);
554 ftree_chk();
555 }
556
557 /*
558 * append()
559 * Add file to previously written archive. Archive format specified by the
560 * user must agree with archive. The archive is read first to collect
561 * modification times (if -u) and locate the archive trailer. The archive
562 * is positioned in front of the record with the trailer and wr_archive()
563 * is called to add the new members.
564 * PAX IMPLEMENTATION DETAIL NOTE:
565 * -u is implemented by adding the new members to the end of the archive.
566 * Care is taken so that these do not end up as links to the older
567 * version of the same file already stored in the archive. It is expected
568 * when extraction occurs these newer versions will over-write the older
569 * ones stored "earlier" in the archive (this may be a bad assumption as
570 * it depends on the implementation of the program doing the extraction).
571 * It is really difficult to splice in members without either re-writing
572 * the entire archive (from the point were the old version was), or having
573 * assistance of the format specification in terms of a special update
574 * header that invalidates a previous archive record. The posix spec left
575 * the method used to implement -u unspecified. This pax is able to
576 * over write existing files that it creates.
577 */
578
579 void
580 append(void)
581 {
582 ARCHD *arcn;
583 int res;
584 ARCHD archd;
585 FSUB *orgfrmt;
586 int udev;
587 off_t tlen;
588
589 arcn = &archd;
590 orgfrmt = frmt;
591
592 /*
593 * Do not allow an append operation if the actual archive is of a
594 * different format than the user specified format.
595 */
596 if (get_arc() < 0)
597 return;
598 if ((orgfrmt != NULL) && (orgfrmt != frmt)) {
599 paxwarn(1, "Cannot mix current archive format %s with %s",
600 frmt->name, orgfrmt->name);
601 return;
602 }
603
604 /*
605 * pass the format any options and start up format
606 */
607 if (((*frmt->options)() < 0) || ((*frmt->st_rd)() < 0))
608 return;
609
610 /*
611 * if we only are adding members that are newer, we need to save the
612 * mod times for all files we see.
613 */
614 if (uflag && (ftime_start() < 0))
615 return;
616
617 /*
618 * some archive formats encode hard links by recording the device and
619 * file serial number (inode) but copy the file anyway (multiple times)
620 * to the archive. When we append, we run the risk that newly added
621 * files may have the same device and inode numbers as those recorded
622 * on the archive but during a previous run. If this happens, when the
623 * archive is extracted we get INCORRECT hard links. We avoid this by
624 * remapping the device numbers so that newly added files will never
625 * use the same device number as one found on the archive. remapping
626 * allows new members to safely have links among themselves. remapping
627 * also avoids problems with file inode (serial number) truncations
628 * when the inode number is larger than storage space in the archive
629 * header. See the remap routines for more details.
630 */
631 if ((udev = frmt->udev) && (dev_start() < 0))
632 return;
633
634 /*
635 * reading the archive may take a long time. If verbose tell the user
636 */
637 if (vflag) {
638 (void)fprintf(listf,
639 "%s: Reading archive to position at the end...", argv0);
640 vfpart = 1;
641 }
642
643 /*
644 * step through the archive until the format says it is done
645 */
646 while (next_head(arcn) == 0) {
647 /*
648 * check if this file meets user specified options.
649 */
650 if (sel_chk(arcn) != 0) {
651 if (rd_skip(arcn->skip + arcn->pad) == 1)
652 break;
653 continue;
654 }
655
656 if (uflag) {
657 /*
658 * see if this is the newest version of this file has
659 * already been seen, if so skip.
660 */
661 if ((res = chk_ftime(arcn)) < 0)
662 break;
663 if (res > 0) {
664 if (rd_skip(arcn->skip + arcn->pad) == 1)
665 break;
666 continue;
667 }
668 }
669
670 /*
671 * Store this device number. Device numbers seen during the
672 * read phase of append will cause newly appended files with a
673 * device number seen in the old part of the archive to be
674 * remapped to an unused device number.
675 */
676 if ((udev && (add_dev(arcn) < 0)) ||
677 (rd_skip(arcn->skip + arcn->pad) == 1))
678 break;
679 }
680
681 /*
682 * done, finish up read and get the number of bytes to back up so we
683 * can add new members. The format might have used the hard link table,
684 * purge it.
685 */
686 tlen = (*frmt->end_rd)();
687 lnk_end();
688
689 /*
690 * try to position for write, if this fails quit. if any error occurs,
691 * we will refuse to write
692 */
693 if (appnd_start(tlen) < 0)
694 return;
695
696 /*
697 * tell the user we are done reading.
698 */
699 if (vflag && vfpart) {
700 (void)fputs("done.\n", listf);
701 vfpart = 0;
702 }
703
704 /*
705 * go to the writing phase to add the new members
706 */
707 wr_archive(arcn, 1);
708 }
709
710 /*
711 * archive()
712 * write a new archive
713 */
714
715 void
716 archive(void)
717 {
718 ARCHD archd;
719
720 /*
721 * if we only are adding members that are newer, we need to save the
722 * mod times for all files; set up for writing; pass the format any
723 * options write the archive
724 */
725 if ((uflag && (ftime_start() < 0)) || (wr_start() < 0))
726 return;
727 if ((*frmt->options)() < 0)
728 return;
729
730 wr_archive(&archd, 0);
731 }
732
733 /*
734 * copy()
735 * copy files from one part of the file system to another. this does not
736 * use any archive storage. The EFFECT OF THE COPY IS THE SAME as if an
737 * archive was written and then extracted in the destination directory
738 * (except the files are forced to be under the destination directory).
739 */
740
741 void
742 copy(void)
743 {
744 ARCHD *arcn;
745 int res;
746 int fddest;
747 char *dest_pt;
748 size_t dlen;
749 size_t drem;
750 int fdsrc = -1;
751 struct stat sb;
752 ARCHD archd;
753 char dirbuf[PAXPATHLEN+1];
754
755 sltab_start();
756
757 arcn = &archd;
758 /*
759 * set up the destination dir path and make sure it is a directory. We
760 * make sure we have a trailing / on the destination
761 */
762 dlen = strlcpy(dirbuf, dirptr, sizeof(dirbuf));
763 if (dlen >= sizeof(dirbuf) ||
764 (dlen == sizeof(dirbuf) - 1 && dirbuf[dlen - 1] != '/')) {
765 paxwarn(1, "directory name is too long %s", dirptr);
766 return;
767 }
768 dest_pt = dirbuf + dlen;
769 if (*(dest_pt-1) != '/') {
770 *dest_pt++ = '/';
771 *dest_pt = '\0';
772 ++dlen;
773 }
774 drem = PAXPATHLEN - dlen;
775
776 if (stat(dirptr, &sb) < 0) {
777 syswarn(1, errno, "Cannot access destination directory %s",
778 dirptr);
779 return;
780 }
781 if (!S_ISDIR(sb.st_mode)) {
782 paxwarn(1, "Destination is not a directory %s", dirptr);
783 return;
784 }
785
786 /*
787 * start up the hard link table; file traversal routines and the
788 * modification time and access mode database
789 */
790 if ((lnk_start() < 0) || (ftree_start() < 0) || (dir_start() < 0))
791 return;
792
793 /*
794 * When we are doing interactive rename, we store the mapping of names
795 * so we can fix up hard links files later in the archive.
796 */
797 if (iflag && (name_start() < 0))
798 return;
799
800 /*
801 * set up to cp file trees
802 */
803 cp_start();
804
805 /*
806 * while there are files to archive, process them
807 */
808 while (next_file(arcn) == 0) {
809 fdsrc = -1;
810
811 /*
812 * check if this file meets user specified options
813 */
814 if (sel_chk(arcn) != 0)
815 continue;
816
817 /*
818 * if there is already a file in the destination directory with
819 * the same name and it is newer, skip the one stored on the
820 * archive.
821 * NOTE: this test is done BEFORE name modifications as
822 * specified by pax. this can be confusing to the user who
823 * might expect the test to be done on an existing file AFTER
824 * the name mod. In honesty the pax spec is probably flawed in
825 * this respect
826 */
827 if (uflag || Dflag) {
828 /*
829 * create the destination name
830 */
831 if (strlcpy(dest_pt, arcn->name + (*arcn->name == '/'),
832 drem + 1) > drem) {
833 paxwarn(1, "Destination pathname too long %s",
834 arcn->name);
835 continue;
836 }
837
838 /*
839 * if existing file is same age or newer skip
840 */
841 res = lstat(dirbuf, &sb);
842 *dest_pt = '\0';
843
844 if (res == 0) {
845 ftree_skipped_newer(arcn);
846 if (cmp_file_times(uflag, Dflag, arcn, &sb))
847 continue;
848 }
849 }
850
851 /*
852 * this file is considered selected. See if this is a hard link
853 * to a previous file; modify the name as requested by the
854 * user; set the final destination.
855 */
856 ftree_sel(arcn);
857 if ((chk_lnk(arcn) < 0) || ((res = mod_name(arcn)) < 0))
858 break;
859 if ((res > 0) || (set_dest(arcn, dirbuf, dlen) < 0)) {
860 /*
861 * skip file, purge from link table
862 */
863 purg_lnk(arcn);
864 continue;
865 }
866
867 /*
868 * Non standard -Y and -Z flag. When the existing file is
869 * same age or newer skip
870 */
871 if ((Yflag || Zflag) &&
872 cmp_file_times(Yflag, Zflag, arcn, NULL))
873 continue;
874
875 if (vflag) {
876 (void)safe_print(arcn->name, listf);
877 vfpart = 1;
878 }
879 ++flcnt;
880
881 /*
882 * try to create a hard link to the src file if requested
883 * but make sure we are not trying to overwrite ourselves.
884 */
885 if (lflag)
886 res = cross_lnk(arcn);
887 else
888 res = chk_same(arcn);
889 if (res <= 0) {
890 if (vflag && vfpart) {
891 (void)putc('\n', listf);
892 vfpart = 0;
893 }
894 continue;
895 }
896
897 /*
898 * have to create a new file
899 */
900 if (!PAX_IS_REG(arcn->type)) {
901 /*
902 * create a link or special file
903 */
904 if (PAX_IS_HARDLINK(arcn->type))
905 res = lnk_creat(arcn);
906 else
907 res = node_creat(arcn);
908 if (res < 0)
909 purg_lnk(arcn);
910 if (vflag && vfpart) {
911 (void)putc('\n', listf);
912 vfpart = 0;
913 }
914 continue;
915 }
916
917 /*
918 * have to copy a regular file to the destination directory.
919 * first open source file and then create the destination file
920 */
921 if ((fdsrc = open(arcn->org_name, O_RDONLY, 0)) < 0) {
922 syswarn(1, errno, "Unable to open %s to read",
923 arcn->org_name);
924 purg_lnk(arcn);
925 continue;
926 }
927 if ((fddest = file_creat(arcn)) < 0) {
928 rdfile_close(arcn, &fdsrc);
929 purg_lnk(arcn);
930 continue;
931 }
932
933 /*
934 * copy source file data to the destination file
935 */
936 cp_file(arcn, fdsrc, fddest);
937 file_close(arcn, fddest);
938 rdfile_close(arcn, &fdsrc);
939
940 if (vflag && vfpart) {
941 (void)putc('\n', listf);
942 vfpart = 0;
943 }
944 }
945
946 /*
947 * restore directory modes and times as required; make sure all
948 * patterns were selected block off signals to avoid chance for
949 * multiple entry into the cleanup code.
950 */
951 (void)sigprocmask(SIG_BLOCK, &s_mask, NULL);
952 ar_close(0);
953 sltab_process(0);
954 proc_dir(0);
955 ftree_chk();
956 }
957
958 /*
959 * next_head()
960 * try to find a valid header in the archive. Uses format specific
961 * routines to extract the header and id the trailer. Trailers may be
962 * located within a valid header or in an invalid header (the location
963 * is format specific. The inhead field from the option table tells us
964 * where to look for the trailer).
965 * We keep reading (and resyncing) until we get enough contiguous data
966 * to check for a header. If we cannot find one, we shift by a byte
967 * add a new byte from the archive to the end of the buffer and try again.
968 * If we get a read error, we throw out what we have (as we must have
969 * contiguous data) and start over again.
970 * ASSUMED: headers fit within a BLKMULT header.
971 * Return:
972 * 0 if we got a header, -1 if we are unable to ever find another one
973 * (we reached the end of input, or we reached the limit on retries. see
974 * the specs for rd_wrbuf() for more details)
975 */
976
977 static int
978 next_head(ARCHD *arcn)
979 {
980 int ret;
981 char *hdend;
982 int res;
983 int shftsz;
984 int hsz;
985 int in_resync = 0; /* set when we are in resync mode */
986 int cnt = 0; /* counter for trailer function */
987 int first = 1; /* on 1st read, EOF isn't premature. */
988
989 /*
990 * set up initial conditions, we want a whole frmt->hsz block as we
991 * have no data yet.
992 */
993 res = hsz = frmt->hsz;
994 hdend = hdbuf;
995 shftsz = hsz - 1;
996 for (;;) {
997 /*
998 * keep looping until we get a contiguous FULL buffer
999 * (frmt->hsz is the proper size)
1000 */
1001 for (;;) {
1002 if ((ret = rd_wrbuf(hdend, res)) == res)
1003 break;
1004
1005 /*
1006 * If we read 0 bytes (EOF) from an archive when we
1007 * expect to find a header, we have stepped upon
1008 * an archive without the customary block of zeroes
1009 * end marker. It's just stupid to error out on
1010 * them, so exit gracefully.
1011 */
1012 if (first && ret == 0)
1013 return(-1);
1014 first = 0;
1015
1016 /*
1017 * some kind of archive read problem, try to resync the
1018 * storage device, better give the user the bad news.
1019 */
1020 if ((ret == 0) || (rd_sync() < 0)) {
1021 paxwarn(1,"Premature end of file on archive read");
1022 return(-1);
1023 }
1024 if (!in_resync) {
1025 if (act == APPND) {
1026 paxwarn(1,
1027 "Archive I/O error, cannot continue");
1028 return(-1);
1029 }
1030 paxwarn(1,"Archive I/O error. Trying to recover.");
1031 ++in_resync;
1032 }
1033
1034 /*
1035 * oh well, throw it all out and start over
1036 */
1037 res = hsz;
1038 hdend = hdbuf;
1039 }
1040
1041 /*
1042 * ok we have a contiguous buffer of the right size. Call the
1043 * format read routine. If this was not a valid header and this
1044 * format stores trailers outside of the header, call the
1045 * format specific trailer routine to check for a trailer. We
1046 * have to watch out that we do not mis-identify file data or
1047 * block padding as a header or trailer. Format specific
1048 * trailer functions must NOT check for the trailer while we
1049 * are running in resync mode. Some trailer functions may tell
1050 * us that this block cannot contain a valid header either, so
1051 * we then throw out the entire block and start over.
1052 */
1053 if ((*frmt->rd)(arcn, hdbuf) == 0)
1054 break;
1055
1056 if (!frmt->inhead) {
1057 /*
1058 * this format has trailers outside of valid headers
1059 */
1060 if ((ret = (*frmt->trail)(arcn,hdbuf,in_resync,&cnt)) == 0){
1061 /*
1062 * valid trailer found, drain input as required
1063 */
1064 ar_drain();
1065 return(-1);
1066 }
1067
1068 if (ret == 1) {
1069 /*
1070 * we are in resync and we were told to throw
1071 * the whole block out because none of the
1072 * bytes in this block can be used to form a
1073 * valid header
1074 */
1075 res = hsz;
1076 hdend = hdbuf;
1077 continue;
1078 }
1079 }
1080
1081 /*
1082 * Brute force section.
1083 * not a valid header. We may be able to find a header yet. So
1084 * we shift over by one byte, and set up to read one byte at a
1085 * time from the archive and place it at the end of the buffer.
1086 * We will keep moving byte at a time until we find a header or
1087 * get a read error and have to start over.
1088 */
1089 if (!in_resync) {
1090 if (act == APPND) {
1091 paxwarn(1,"Unable to append, archive header flaw");
1092 return(-1);
1093 }
1094 paxwarn(1,"Invalid header, starting valid header search.");
1095 ++in_resync;
1096 }
1097 memmove(hdbuf, hdbuf+1, shftsz);
1098 res = 1;
1099 hdend = hdbuf + shftsz;
1100 }
1101
1102 /*
1103 * ok got a valid header, check for trailer if format encodes it in the
1104 * the header. NOTE: the parameters are different than trailer routines
1105 * which encode trailers outside of the header!
1106 */
1107 if (frmt->inhead && ((*frmt->trail)(arcn,NULL,0,NULL) == 0)) {
1108 /*
1109 * valid trailer found, drain input as required
1110 */
1111 ar_drain();
1112 return(-1);
1113 }
1114
1115 ++flcnt;
1116 return(0);
1117 }
1118
1119 /*
1120 * get_arc()
1121 * Figure out what format an archive is. Handles archive with flaws by
1122 * brute force searches for a legal header in any supported format. The
1123 * format id routines have to be careful to NOT mis-identify a format.
1124 * ASSUMED: headers fit within a BLKMULT header.
1125 * Return:
1126 * 0 if archive found -1 otherwise
1127 */
1128
1129 static int
1130 get_arc(void)
1131 {
1132 int i;
1133 int hdsz = 0;
1134 int res;
1135 int minhd = BLKMULT;
1136 char *hdend;
1137 int notice = 0;
1138
1139 /*
1140 * find the smallest header size in all archive formats and then set up
1141 * to read the archive.
1142 */
1143 for (i = 0; ford[i] >= 0; ++i) {
1144 if (fsub[ford[i]].name != NULL && fsub[ford[i]].hsz < minhd)
1145 minhd = fsub[ford[i]].hsz;
1146 }
1147 if (rd_start() < 0)
1148 return(-1);
1149 res = BLKMULT;
1150 hdsz = 0;
1151 hdend = hdbuf;
1152 for (;;) {
1153 for (;;) {
1154 /*
1155 * fill the buffer with at least the smallest header
1156 */
1157 i = rd_wrbuf(hdend, res);
1158 if (i > 0)
1159 hdsz += i;
1160 if (hdsz >= minhd)
1161 break;
1162
1163 /*
1164 * if we cannot recover from a read error quit
1165 */
1166 if ((i == 0) || (rd_sync() < 0))
1167 goto out;
1168
1169 /*
1170 * when we get an error none of the data we already
1171 * have can be used to create a legal header (we just
1172 * got an error in the middle), so we throw it all out
1173 * and refill the buffer with fresh data.
1174 */
1175 res = BLKMULT;
1176 hdsz = 0;
1177 hdend = hdbuf;
1178 if (!notice) {
1179 if (act == APPND)
1180 return(-1);
1181 paxwarn(1,"Cannot identify format. Searching...");
1182 ++notice;
1183 }
1184 }
1185
1186 /*
1187 * we have at least the size of the smallest header in any
1188 * archive format. Look to see if we have a match. The array
1189 * ford[] is used to specify the header id order to reduce the
1190 * chance of incorrectly id'ing a valid header (some formats
1191 * may be subsets of each other and the order would then be
1192 * important).
1193 */
1194 for (i = 0; ford[i] >= 0; ++i) {
1195 if (fsub[ford[i]].id == NULL ||
1196 (*fsub[ford[i]].id)(hdbuf, hdsz) < 0)
1197 continue;
1198 frmt = &(fsub[ford[i]]);
1199 /*
1200 * yuck, to avoid slow special case code in the extract
1201 * routines, just push this header back as if it was
1202 * not seen. We have left extra space at start of the
1203 * buffer for this purpose. This is a bit ugly, but
1204 * adding all the special case code is far worse.
1205 */
1206 pback(hdbuf, hdsz);
1207 return(0);
1208 }
1209
1210 /*
1211 * We have a flawed archive, no match. we start searching, but
1212 * we never allow additions to flawed archives
1213 */
1214 if (!notice) {
1215 if (act == APPND)
1216 return(-1);
1217 paxwarn(1, "Cannot identify format. Searching...");
1218 ++notice;
1219 }
1220
1221 /*
1222 * brute force search for a header that we can id.
1223 * we shift through byte at a time. this is slow, but we cannot
1224 * determine the nature of the flaw in the archive in a
1225 * portable manner
1226 */
1227 if (--hdsz > 0) {
1228 memmove(hdbuf, hdbuf+1, hdsz);
1229 res = BLKMULT - hdsz;
1230 hdend = hdbuf + hdsz;
1231 } else {
1232 res = BLKMULT;
1233 hdend = hdbuf;
1234 hdsz = 0;
1235 }
1236 }
1237
1238 out:
1239 /*
1240 * we cannot find a header, bow, apologize and quit
1241 */
1242 paxwarn(1, "Sorry, unable to determine archive format.");
1243 return(-1);
1244 }
unleashed repo fork