1 /* $OpenBSD: ar_subs.c,v 1.28 2004/04/16 22:50:23 deraadt Exp $ */
2 /* $NetBSD: ar_subs.c,v 1.5 1995/03/21 09:07:06 cgd Exp $ */
5 * Copyright (c) 1992 Keith Muller.
6 * Copyright (c) 1992, 1993
7 * The Regents of the University of California. All rights reserved.
9 * This code is derived from software contributed to Berkeley by
10 * Keith Muller of the University of California, San Diego.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
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.
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
39 static const char sccsid
[] = "@(#)ar_subs.c 8.2 (Berkeley) 4/18/94";
41 static const char rcsid
[] __attribute__((__unused__
)) = "$OpenBSD: ar_subs.c,v 1.28 2004/04/16 22:50:23 deraadt Exp $";
45 #include <sys/types.h>
48 #include <sys/param.h>
59 #include <sys/queue.h>
64 static void wr_archive(ARCHD
*, int is_app
);
65 static int get_arc(void);
66 static int next_head(ARCHD
*);
67 extern sigset_t s_mask
;
72 * Routines which control the overall operation modes of pax as specified by
73 * the user: list, append, read ...
76 static char hdbuf
[BLKMULT
]; /* space for archive header on read */
77 u_long flcnt
; /* number of files processed */
81 * list the contents of an archive which match user supplied pattern(s)
82 * (no pattern matches all).
95 * figure out archive type; pass any format specific options to the
96 * archive option processing routine; call the format init routine. We
97 * also save current time for ls_list() so we do not make a system
98 * call for each file we need to print. If verbose (vflag) start up
99 * the name and group caches.
101 if ((get_arc() < 0) || ((*frmt
->options
)() < 0) ||
102 ((*frmt
->st_rd
)() < 0))
105 if (vflag
&& ((uidtb_start() < 0) || (gidtb_start() < 0)))
111 * step through the archive until the format says it is done
113 while (next_head(arcn
) == 0) {
114 if (arcn
->type
== PAX_GLL
|| arcn
->type
== PAX_GLF
) {
116 * we need to read, to get the real filename
119 if (!(*frmt
->rd_data
)(arcn
, arcn
->type
== PAX_GLF
121 (void)rd_skip(cnt
+ arcn
->pad
);
126 * check for pattern, and user specified options match.
127 * When all patterns are matched we are done.
129 if ((res
= pat_match(arcn
)) < 0)
132 if ((res
== 0) && (sel_chk(arcn
) == 0)) {
134 * pattern resulted in a selected file
136 if (pat_sel(arcn
) < 0)
140 * modify the name as requested by the user if name
141 * survives modification, do a listing of the file
143 if ((res
= mod_name(arcn
)) < 0)
146 ls_list(arcn
, now
, stdout
);
150 * skip to next archive format header using values calculated
151 * by the format header read routine
153 if (rd_skip(arcn
->skip
+ arcn
->pad
) == 1)
158 * all done, let format have a chance to cleanup, and make sure that
159 * the patterns supplied by the user were all matched
161 (void)(*frmt
->end_rd
)();
162 (void)sigprocmask(SIG_BLOCK
, &s_mask
, NULL
);
169 * extract the member(s) of an archive as specified by user supplied
170 * pattern(s) (no patterns extracts all members)
184 int copyfile_disable
= (getenv(COPYFILE_DISABLE_VAR
) != NULL
);
185 LIST_HEAD(copyfile_list_t
, copyfile_list_entry_t
) copyfile_list
;
186 struct copyfile_list_entry_t
{
190 LIST_ENTRY(copyfile_list_entry_t
) link
;
193 LIST_INIT(©file_list
);
198 * figure out archive type; pass any format specific options to the
199 * archive option processing routine; call the format init routine;
200 * start up the directory modification time and access mode database
202 if ((get_arc() < 0) || ((*frmt
->options
)() < 0) ||
203 ((*frmt
->st_rd
)() < 0) || (dir_start() < 0))
207 * When we are doing interactive rename, we store the mapping of names
208 * so we can fix up hard links files later in the archive.
210 if (iflag
&& (name_start() < 0))
216 * step through each entry on the archive until the format read routine
219 while (next_head(arcn
) == 0) {
220 if (arcn
->type
== PAX_GLL
|| arcn
->type
== PAX_GLF
) {
222 * we need to read, to get the real filename
224 if (!(*frmt
->rd_data
)(arcn
, arcn
->type
== PAX_GLF
226 (void)rd_skip(cnt
+ arcn
->pad
);
231 * check for pattern, and user specified options match. When
232 * all the patterns are matched we are done
234 if ((res
= pat_match(arcn
)) < 0)
237 if ((res
> 0) || (sel_chk(arcn
) != 0)) {
239 * file is not selected. skip past any file data and
240 * padding and go back for the next archive member
242 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
247 * with -u or -D only extract when the archive member is newer
248 * than the file with the same name in the file system (no
249 * test of being the same type is required).
250 * NOTE: this test is done BEFORE name modifications as
251 * specified by pax. this operation can be confusing to the
252 * user who might expect the test to be done on an existing
253 * file AFTER the name mod. In honesty the pax spec is probably
254 * flawed in this respect.
256 if ((uflag
|| Dflag
) && ((lstat(arcn
->name
, &sb
) == 0))) {
257 if (uflag
&& Dflag
) {
258 if ((arcn
->sb
.st_mtime
<= sb
.st_mtime
) &&
259 (arcn
->sb
.st_ctime
<= sb
.st_ctime
)) {
260 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
264 if (arcn
->sb
.st_ctime
<= sb
.st_ctime
) {
265 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
268 } else if (arcn
->sb
.st_mtime
<= sb
.st_mtime
) {
269 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
275 * this archive member is now been selected. modify the name.
277 if ((pat_sel(arcn
) < 0) || ((res
= mod_name(arcn
)) < 0))
281 * a bad name mod, skip and purge name from link table
284 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
289 * Non standard -Y and -Z flag. When the existing file is
290 * same age or newer skip
292 if ((Yflag
|| Zflag
) && ((lstat(arcn
->name
, &sb
) == 0))) {
293 if (Yflag
&& Zflag
) {
294 if ((arcn
->sb
.st_mtime
<= sb
.st_mtime
) &&
295 (arcn
->sb
.st_ctime
<= sb
.st_ctime
)) {
296 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
300 if (arcn
->sb
.st_ctime
<= sb
.st_ctime
) {
301 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
304 } else if (arcn
->sb
.st_mtime
<= sb
.st_mtime
) {
305 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
312 ls_list(arcn
, now
, listf
);
314 (void)safe_print(arcn
->name
, listf
);
320 * if required, chdir around.
322 if ((arcn
->pat
!= NULL
) && (arcn
->pat
->chdname
!= NULL
))
323 if (chdir(arcn
->pat
->chdname
) != 0)
324 syswarn(1, errno
, "Cannot chdir to %s",
328 * all ok, extract this member based on type
330 if ((arcn
->type
!= PAX_REG
) && (arcn
->type
!= PAX_CTG
)) {
332 * process archive members that are not regular files.
333 * throw out padding and any data that might follow the
334 * header (as determined by the format).
336 if ((arcn
->type
== PAX_HLK
) || (arcn
->type
== PAX_HRG
))
337 res
= lnk_creat(arcn
);
339 res
= node_creat(arcn
);
341 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
345 if (vflag
&& vfpart
) {
346 (void)putc('\n', listf
);
352 * we have a file with data here. If we can not create it, skip
353 * over the data and purge the name from hard link table
355 if ((fd
= file_creat(arcn
)) < 0) {
356 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
361 * extract the file from the archive and skip over padding and
362 * any unprocessed data
364 res
= (*frmt
->rd_data
)(arcn
, fd
, &cnt
);
365 file_close(arcn
, fd
);
366 if (vflag
&& vfpart
) {
367 (void)putc('\n', listf
);
371 (void)rd_skip(cnt
+ arcn
->pad
);
374 if (!strncmp(basename(arcn
->name
), "._", 2))
376 cle
= alloca(sizeof(struct copyfile_list_entry_t
));
377 cle
->src
= strdup(arcn
->name
);
379 if (asprintf(&cle
->tmp
, "%s.XXX", cle
->src
) > MAXPATHLEN
)
381 if (mktemp(cle
->tmp
) == NULL
)
383 if (rename(cle
->src
, cle
->tmp
))
386 if (asprintf(&cle
->dst
, "%s/%s",
387 dirname(arcn
->name
), basename(arcn
->name
) + 2) != -1)
388 LIST_INSERT_HEAD(©file_list
, cle
, link
);
392 * if required, chdir around.
394 if ((arcn
->pat
!= NULL
) && (arcn
->pat
->chdname
!= NULL
))
395 if (fchdir(cwdfd
) != 0)
397 "Can't fchdir to starting directory");
401 LIST_FOREACH(cle
, ©file_list
, link
)
403 if(copyfile_disable
|| copyfile(cle
->tmp
, cle
->dst
, NULL
,
404 COPYFILE_UNPACK
| COPYFILE_XATTR
| COPYFILE_ACL
))
405 rename(cle
->tmp
, cle
->src
);
415 * all done, restore directory modes and times as required; make sure
416 * all patterns supplied by the user were matched; block off signals
417 * to avoid chance for multiple entry into the cleanup code.
419 (void)(*frmt
->end_rd
)();
420 (void)sigprocmask(SIG_BLOCK
, &s_mask
, NULL
);
428 * Write an archive. used in both creating a new archive and appends on
429 * previously written archive.
433 wr_archive(ARCHD
*arcn
, int is_app
)
444 char *md_fname
= NULL
;
446 char arcn_copy_name
[PAXPATHLEN
+1];
450 * if this format supports hard link storage, start up the database
453 if (((hlk
= frmt
->hlk
) == 1) && (lnk_start() < 0))
455 if (hlk
&& want_linkdata
) hlk
=0; /* Treat hard links as individual files */
458 * start up the file traversal code and format specific write
460 if ((ftree_start() < 0) || ((*frmt
->st_wr
)() < 0))
465 * When we are doing interactive rename, we store the mapping of names
466 * so we can fix up hard links files later in the archive.
468 if (iflag
&& (name_start() < 0))
472 * if this is not append, and there are no files, we do not write a
480 * while there are files to archive, process them one at at time
482 while (next_file(arcn
) == 0) {
484 * check if this file meets user specified options match.
486 if (sel_chk(arcn
) != 0)
490 * synthesize ._ files for each node we encounter
492 if (getenv(COPYFILE_DISABLE_VAR
) == NULL
493 && copyfile(arcn
->name
, NULL
, NULL
,
494 COPYFILE_CHECK
| COPYFILE_XATTR
| COPYFILE_ACL
)
495 && arcn
->nlen
+ 2 < sizeof(arcn
->name
))
500 md_fname
= strdup("/tmp/pax.md.XXXX");
501 memcpy(&arcn_copy
, arcn
, sizeof(ARCHD
));
502 strncpy(arcn_copy_name
, arcn
->name
, PAXPATHLEN
+1);
507 arcn
->ln_name
[0] = '\0';
508 arcn
->type
= PAX_REG
;
510 if(md_fname
&& mktemp(md_fname
))
511 if(copyfile(arcn
->name
, md_fname
, NULL
,
512 COPYFILE_PACK
| COPYFILE_XATTR
| COPYFILE_ACL
) < 0)
515 "Unable to preserve metadata on %s", arcn
->name
);
519 stat(md_fname
, &arcn
->sb
);
520 arcn
->skip
= arcn
->sb
.st_size
;
522 if (!strncmp(dirname(arcn
->name
), ".", 2))
523 size
= asprintf(&new, "._%s",
524 basename(arcn
->name
));
526 size
= asprintf(&new, "%s/._%s",
527 dirname(arcn
->name
), basename(arcn
->name
));
529 if (size
!= -1 && size
< sizeof arcn
->name
)
531 strncpy(arcn
->name
, new, PAXPATHLEN
+1);
535 arcn
->nlen
= strlen(arcn
->name
);
536 arcn
->org_name
= arcn
->name
;
539 } else if (metadata
) {
542 memcpy(arcn
, &arcn_copy
, sizeof(ARCHD
));
543 strncpy(arcn
->name
, arcn_copy_name
, PAXPATHLEN
+1);
549 * only archive if this file is newer than a file with
550 * the same name that is already stored on the archive
552 if ((res
= chk_ftime(arcn
)) < 0)
559 * this file is considered selected now. see if this is a hard
560 * link to a file already stored
563 if (hlk
&& (chk_lnk(arcn
) < 0))
566 if ((arcn
->type
== PAX_REG
) || (arcn
->type
== PAX_HRG
) ||
567 (arcn
->type
== PAX_CTG
)) {
569 * we will have to read this file. by opening it now we
570 * can avoid writing a header to the archive for a file
571 * we were later unable to read (we also purge it from
577 fd
= open(md_fname
, O_RDONLY
, 0);
581 fd
= open(arcn
->org_name
, O_RDONLY
, 0);
584 if ((fd
= open(arcn
->org_name
, O_RDONLY
, 0)) < 0) {
586 /* suppress set if size==0 ?? */
587 syswarn(1,errno
, "Unable to open %s to read",
595 * Now modify the name as requested by the user
597 if ((res
= mod_name(arcn
)) < 0) {
599 * name modification says to skip this file, close the
600 * file and purge link table entry
602 rdfile_close(arcn
, &fd
);
607 if ((res
> 0) || (docrc
&& (set_crc(arcn
, fd
) < 0))) {
609 * unable to obtain the crc we need, close the file,
610 * purge link table entry
612 rdfile_close(arcn
, &fd
);
619 ls_list(arcn
, now
, listf
);
621 (void)safe_print(arcn
->name
, listf
);
628 * looks safe to store the file, have the format specific
629 * routine write routine store the file header on the archive
631 if ((res
= (*wrf
)(arcn
)) < 0) {
632 rdfile_close(arcn
, &fd
);
638 * format write says no file data needs to be stored
639 * so we are done messing with this file
641 if (vflag
&& vfpart
) {
642 (void)putc('\n', listf
);
645 rdfile_close(arcn
, &fd
);
650 * Add file data to the archive, quit on write error. if we
651 * cannot write the entire file contents to the archive we
652 * must pad the archive to replace the missing file data
653 * (otherwise during an extract the file header for the file
654 * which FOLLOWS this one will not be where we expect it to
657 res
= (*frmt
->wr_data
)(arcn
, fd
, &cnt
);
658 rdfile_close(arcn
, &fd
);
659 if (vflag
&& vfpart
) {
660 (void)putc('\n', listf
);
667 * pad as required, cnt is number of bytes not written
669 if (((cnt
> 0) && (wr_skip(cnt
) < 0)) ||
670 ((arcn
->pad
> 0) && (wr_skip(arcn
->pad
) < 0)))
679 * tell format to write trailer; pad to block boundary; reset directory
680 * mode/access times, and check if all patterns supplied by the user
681 * were matched. block off signals to avoid chance for multiple entry
682 * into the cleanup code
688 (void)sigprocmask(SIG_BLOCK
, &s_mask
, NULL
);
697 * Add file to previously written archive. Archive format specified by the
698 * user must agree with archive. The archive is read first to collect
699 * modification times (if -u) and locate the archive trailer. The archive
700 * is positioned in front of the record with the trailer and wr_archive()
701 * is called to add the new members.
702 * PAX IMPLEMENTATION DETAIL NOTE:
703 * -u is implemented by adding the new members to the end of the archive.
704 * Care is taken so that these do not end up as links to the older
705 * version of the same file already stored in the archive. It is expected
706 * when extraction occurs these newer versions will over-write the older
707 * ones stored "earlier" in the archive (this may be a bad assumption as
708 * it depends on the implementation of the program doing the extraction).
709 * It is really difficult to splice in members without either re-writing
710 * the entire archive (from the point were the old version was), or having
711 * assistance of the format specification in terms of a special update
712 * header that invalidates a previous archive record. The posix spec left
713 * the method used to implement -u unspecified. This pax is able to
714 * over write existing files that it creates.
731 * Do not allow an append operation if the actual archive is of a
732 * different format than the user specified format.
736 if ((orgfrmt
!= NULL
) && (orgfrmt
!= frmt
)) {
737 paxwarn(1, "Cannot mix current archive format %s with %s",
738 frmt
->name
, orgfrmt
->name
);
743 * pass the format any options and start up format
745 if (((*frmt
->options
)() < 0) || ((*frmt
->st_rd
)() < 0))
749 * if we only are adding members that are newer, we need to save the
750 * mod times for all files we see.
752 if (uflag
&& (ftime_start() < 0))
756 * some archive formats encode hard links by recording the device and
757 * file serial number (inode) but copy the file anyway (multiple times)
758 * to the archive. When we append, we run the risk that newly added
759 * files may have the same device and inode numbers as those recorded
760 * on the archive but during a previous run. If this happens, when the
761 * archive is extracted we get INCORRECT hard links. We avoid this by
762 * remapping the device numbers so that newly added files will never
763 * use the same device number as one found on the archive. remapping
764 * allows new members to safely have links among themselves. remapping
765 * also avoids problems with file inode (serial number) truncations
766 * when the inode number is larger than storage space in the archive
767 * header. See the remap routines for more details.
769 if ((udev
= frmt
->udev
) && (dev_start() < 0))
773 * reading the archive may take a long time. If verbose tell the user
777 "%s: Reading archive to position at the end...", argv0
);
782 * step through the archive until the format says it is done
784 while (next_head(arcn
) == 0) {
786 * check if this file meets user specified options.
788 if (sel_chk(arcn
) != 0) {
789 if (rd_skip(arcn
->skip
+ arcn
->pad
) == 1)
796 * see if this is the newest version of this file has
797 * already been seen, if so skip.
799 if ((res
= chk_ftime(arcn
)) < 0)
802 if (rd_skip(arcn
->skip
+ arcn
->pad
) == 1)
809 * Store this device number. Device numbers seen during the
810 * read phase of append will cause newly appended files with a
811 * device number seen in the old part of the archive to be
812 * remapped to an unused device number.
814 if ((udev
&& (add_dev(arcn
) < 0)) ||
815 (rd_skip(arcn
->skip
+ arcn
->pad
) == 1))
820 * done, finish up read and get the number of bytes to back up so we
821 * can add new members. The format might have used the hard link table,
824 tlen
= (*frmt
->end_rd
)();
828 * try to position for write, if this fails quit. if any error occurs,
829 * we will refuse to write
831 if (appnd_start(tlen
) < 0)
835 * tell the user we are done reading.
837 if (vflag
&& vfpart
) {
838 (void)fputs("done.\n", listf
);
843 * go to the writing phase to add the new members
850 * write a new archive
859 * if we only are adding members that are newer, we need to save the
860 * mod times for all files; set up for writing; pass the format any
861 * options write the archive
863 if ((uflag
&& (ftime_start() < 0)) || (wr_start() < 0))
865 if ((*frmt
->options
)() < 0)
868 wr_archive(&archd
, 0);
873 * copy files from one part of the file system to another. this does not
874 * use any archive storage. The EFFECT OF THE COPY IS THE SAME as if an
875 * archive was written and then extracted in the destination directory
876 * (except the files are forced to be under the destination directory).
891 char dirbuf
[PAXPATHLEN
+1];
895 if (frmt
&& strcmp(frmt
->name
, "pax")==0) {
896 /* Copy using pax format: must check if any -o options */
897 if ((*frmt
->options
)() < 0)
899 if (pax_invalid_action
==0)
900 pax_invalid_action
= PAX_INVALID_ACTION_BYPASS
;
903 * set up the destination dir path and make sure it is a directory. We
904 * make sure we have a trailing / on the destination
906 dlen
= strlcpy(dirbuf
, dirptr
, sizeof(dirbuf
));
907 if (dlen
>= sizeof(dirbuf
) ||
908 (dlen
== sizeof(dirbuf
) - 1 && dirbuf
[dlen
- 1] != '/')) {
909 paxwarn(1, "directory name is too long %s", dirptr
);
912 dest_pt
= dirbuf
+ dlen
;
913 if (*(dest_pt
-1) != '/') {
918 drem
= PAXPATHLEN
- dlen
;
920 if (stat(dirptr
, &sb
) < 0) {
921 syswarn(1, errno
, "Cannot access destination directory %s",
925 if (!S_ISDIR(sb
.st_mode
)) {
926 paxwarn(1, "Destination is not a directory %s", dirptr
);
931 * start up the hard link table; file traversal routines and the
932 * modification time and access mode database
934 if ((lnk_start() < 0) || (ftree_start() < 0) || (dir_start() < 0))
938 * When we are doing interactive rename, we store the mapping of names
939 * so we can fix up hard links files later in the archive.
941 if (iflag
&& (name_start() < 0))
945 * set up to cp file trees
950 * while there are files to archive, process them
952 while (next_file(arcn
) == 0) {
956 * Fill in arcn from any pax options
958 adjust_copy_for_pax_options(arcn
);
961 * check if this file meets user specified options
963 if (sel_chk(arcn
) != 0)
967 * if there is already a file in the destination directory with
968 * the same name and it is newer, skip the one stored on the
970 * NOTE: this test is done BEFORE name modifications as
971 * specified by pax. this can be confusing to the user who
972 * might expect the test to be done on an existing file AFTER
973 * the name mod. In honesty the pax spec is probably flawed in
976 if (uflag
|| Dflag
) {
978 * create the destination name
980 if (strlcpy(dest_pt
, arcn
->name
+ (*arcn
->name
== '/'),
982 paxwarn(1, "Destination pathname too long %s",
988 * if existing file is same age or newer skip
990 res
= lstat(dirbuf
, &sb
);
994 if (uflag
&& Dflag
) {
995 if ((arcn
->sb
.st_mtime
<=sb
.st_mtime
) &&
996 (arcn
->sb
.st_ctime
<=sb
.st_ctime
))
999 if (arcn
->sb
.st_ctime
<= sb
.st_ctime
)
1001 } else if (arcn
->sb
.st_mtime
<= sb
.st_mtime
)
1007 * this file is considered selected. See if this is a hard link
1008 * to a previous file; modify the name as requested by the
1009 * user; set the final destination.
1012 if ((chk_lnk(arcn
) < 0) || ((res
= mod_name(arcn
)) < 0))
1014 if ((res
> 0) || (set_dest(arcn
, dirbuf
, dlen
) < 0)) {
1016 * skip file, purge from link table
1023 * Non standard -Y and -Z flag. When the existing file is
1024 * same age or newer skip
1026 if ((Yflag
|| Zflag
) && ((lstat(arcn
->name
, &sb
) == 0))) {
1027 if (Yflag
&& Zflag
) {
1028 if ((arcn
->sb
.st_mtime
<= sb
.st_mtime
) &&
1029 (arcn
->sb
.st_ctime
<= sb
.st_ctime
))
1032 if (arcn
->sb
.st_ctime
<= sb
.st_ctime
)
1034 } else if (arcn
->sb
.st_mtime
<= sb
.st_mtime
)
1039 (void)safe_print(arcn
->name
, listf
);
1045 * try to create a hard link to the src file if requested
1046 * but make sure we are not trying to overwrite ourselves.
1049 res
= cross_lnk(arcn
);
1051 res
= chk_same(arcn
);
1053 if (vflag
&& vfpart
) {
1054 (void)putc('\n', listf
);
1061 * have to create a new file
1063 if ((arcn
->type
!= PAX_REG
) && (arcn
->type
!= PAX_CTG
)) {
1065 * create a link or special file
1067 if ((arcn
->type
== PAX_HLK
) || (arcn
->type
== PAX_HRG
))
1068 res
= lnk_creat(arcn
);
1070 res
= node_creat(arcn
);
1075 arcn
->type
== PAX_DIR
&&
1076 copyfile(arcn
->org_name
, arcn
->name
, NULL
, COPYFILE_ACL
| COPYFILE_XATTR
) < 0)
1077 paxwarn(1, "Directory %s had metadata that could not be copied: %s", arcn
->org_name
, strerror(errno
));
1078 #endif /* __APPLE__ */
1079 if (vflag
&& vfpart
) {
1080 (void)putc('\n', listf
);
1087 * have to copy a regular file to the destination directory.
1088 * first open source file and then create the destination file
1090 if ((fdsrc
= open(arcn
->org_name
, O_RDONLY
, 0)) < 0) {
1091 syswarn(1, errno
, "Unable to open %s to read",
1096 if ((fddest
= file_creat(arcn
)) < 0) {
1097 rdfile_close(arcn
, &fdsrc
);
1103 * copy source file data to the destination file
1105 cp_file(arcn
, fdsrc
, fddest
);
1107 /* do this before file close so that mtimes are correct regardless */
1108 if (getenv(COPYFILE_DISABLE_VAR
) == NULL
) {
1109 if (copyfile(arcn
->org_name
, arcn
->name
, NULL
, COPYFILE_ACL
| COPYFILE_XATTR
) < 0)
1110 paxwarn(1, "File %s had metadata that could not be copied", arcn
->org_name
);
1113 file_close(arcn
, fddest
);
1114 rdfile_close(arcn
, &fdsrc
);
1116 if (vflag
&& vfpart
) {
1117 (void)putc('\n', listf
);
1123 * restore directory modes and times as required; make sure all
1124 * patterns were selected block off signals to avoid chance for
1125 * multiple entry into the cleanup code.
1127 (void)sigprocmask(SIG_BLOCK
, &s_mask
, NULL
);
1135 * try to find a valid header in the archive. Uses format specific
1136 * routines to extract the header and id the trailer. Trailers may be
1137 * located within a valid header or in an invalid header (the location
1138 * is format specific. The inhead field from the option table tells us
1139 * where to look for the trailer).
1140 * We keep reading (and resyncing) until we get enough contiguous data
1141 * to check for a header. If we cannot find one, we shift by a byte
1142 * add a new byte from the archive to the end of the buffer and try again.
1143 * If we get a read error, we throw out what we have (as we must have
1144 * contiguous data) and start over again.
1145 * ASSUMED: headers fit within a BLKMULT header.
1147 * 0 if we got a header, -1 if we are unable to ever find another one
1148 * (we reached the end of input, or we reached the limit on retries. see
1149 * the specs for rd_wrbuf() for more details)
1153 next_head(ARCHD
*arcn
)
1160 int in_resync
= 0; /* set when we are in resync mode */
1161 int cnt
= 0; /* counter for trailer function */
1162 int first
= 1; /* on 1st read, EOF isn't premature. */
1165 * set up initial conditions, we want a whole frmt->hsz block as we
1168 res
= hsz
= frmt
->hsz
;
1173 * keep looping until we get a contiguous FULL buffer
1174 * (frmt->hsz is the proper size)
1177 if ((ret
= rd_wrbuf(hdend
, res
)) == res
)
1181 * If we read 0 bytes (EOF) from an archive when we
1182 * expect to find a header, we have stepped upon
1183 * an archive without the customary block of zeroes
1184 * end marker. It's just stupid to error out on
1185 * them, so exit gracefully.
1187 if (first
&& ret
== 0)
1192 * some kind of archive read problem, try to resync the
1193 * storage device, better give the user the bad news.
1195 if ((ret
== 0) || (rd_sync() < 0)) {
1196 paxwarn(1,"Premature end of file on archive read");
1202 "Archive I/O error, cannot continue");
1205 paxwarn(1,"Archive I/O error. Trying to recover.");
1210 * oh well, throw it all out and start over
1217 * ok we have a contiguous buffer of the right size. Call the
1218 * format read routine. If this was not a valid header and this
1219 * format stores trailers outside of the header, call the
1220 * format specific trailer routine to check for a trailer. We
1221 * have to watch out that we do not mis-identify file data or
1222 * block padding as a header or trailer. Format specific
1223 * trailer functions must NOT check for the trailer while we
1224 * are running in resync mode. Some trailer functions may tell
1225 * us that this block cannot contain a valid header either, so
1226 * we then throw out the entire block and start over.
1228 if ((*frmt
->rd
)(arcn
, hdbuf
) == 0)
1231 if (!frmt
->inhead
) {
1233 * this format has trailers outside of valid headers
1235 if ((ret
= (*frmt
->trail
)(arcn
,hdbuf
,in_resync
,&cnt
)) == 0){
1237 * valid trailer found, drain input as required
1245 * we are in resync and we were told to throw
1246 * the whole block out because none of the
1247 * bytes in this block can be used to form a
1257 * Brute force section.
1258 * not a valid header. We may be able to find a header yet. So
1259 * we shift over by one byte, and set up to read one byte at a
1260 * time from the archive and place it at the end of the buffer.
1261 * We will keep moving byte at a time until we find a header or
1262 * get a read error and have to start over.
1266 paxwarn(1,"Unable to append, archive header flaw");
1269 paxwarn(1,"Invalid header, starting valid header search.");
1272 memmove(hdbuf
, hdbuf
+1, shftsz
);
1274 hdend
= hdbuf
+ shftsz
;
1278 * ok got a valid header, check for trailer if format encodes it in the
1279 * the header. NOTE: the parameters are different than trailer routines
1280 * which encode trailers outside of the header!
1282 if (frmt
->inhead
&& ((*frmt
->trail
)(arcn
,NULL
,0,NULL
) == 0)) {
1284 * valid trailer found, drain input as required
1296 * Figure out what format an archive is. Handles archive with flaws by
1297 * brute force searches for a legal header in any supported format. The
1298 * format id routines have to be careful to NOT mis-identify a format.
1299 * ASSUMED: headers fit within a BLKMULT header.
1301 * 0 if archive found -1 otherwise
1310 int minhd
= BLKMULT
;
1315 * find the smallest header size in all archive formats and then set up
1316 * to read the archive.
1318 for (i
= 0; ford
[i
] >= 0; ++i
) {
1319 if (fsub
[ford
[i
]].hsz
< minhd
)
1320 minhd
= fsub
[ford
[i
]].hsz
;
1330 * fill the buffer with at least the smallest header
1332 i
= rd_wrbuf(hdend
, res
);
1339 * if we cannot recover from a read error quit
1341 if ((i
== 0) || (rd_sync() < 0))
1345 * when we get an error none of the data we already
1346 * have can be used to create a legal header (we just
1347 * got an error in the middle), so we throw it all out
1348 * and refill the buffer with fresh data.
1356 paxwarn(1,"Cannot identify format. Searching...");
1362 * we have at least the size of the smallest header in any
1363 * archive format. Look to see if we have a match. The array
1364 * ford[] is used to specify the header id order to reduce the
1365 * chance of incorrectly id'ing a valid header (some formats
1366 * may be subsets of each other and the order would then be
1369 for (i
= 0; ford
[i
] >= 0; ++i
) {
1370 if ((*fsub
[ford
[i
]].id
)(hdbuf
, hdsz
) < 0)
1372 frmt
= &(fsub
[ford
[i
]]);
1374 * yuck, to avoid slow special case code in the extract
1375 * routines, just push this header back as if it was
1376 * not seen. We have left extra space at start of the
1377 * buffer for this purpose. This is a bit ugly, but
1378 * adding all the special case code is far worse.
1385 * We have a flawed archive, no match. we start searching, but
1386 * we never allow additions to flawed archives
1391 paxwarn(1, "Cannot identify format. Searching...");
1396 * brute force search for a header that we can id.
1397 * we shift through byte at a time. this is slow, but we cannot
1398 * determine the nature of the flaw in the archive in a
1402 memmove(hdbuf
, hdbuf
+1, hdsz
);
1403 res
= BLKMULT
- hdsz
;
1404 hdend
= hdbuf
+ hdsz
;
1414 * we cannot find a header, bow, apologize and quit
1416 paxwarn(1, "Sorry, unable to determine archive format.");