1 /* $OpenBSD: ar_subs.c,v 1.13 1997/09/16 21:20:35 niklas 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. All advertising materials mentioning features or use of this software
21 * must display the following acknowledgement:
22 * This product includes software developed by the University of
23 * California, Berkeley and its contributors.
24 * 4. Neither the name of the University nor the names of its contributors
25 * may be used to endorse or promote products derived from this software
26 * without specific prior written permission.
28 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
43 static char sccsid
[] = "@(#)ar_subs.c 8.2 (Berkeley) 4/18/94";
45 static char rcsid
[] __attribute__((__unused__
)) = "$OpenBSD: ar_subs.c,v 1.13 1997/09/16 21:20:35 niklas Exp $";
49 #include <sys/types.h>
52 #include <sys/param.h>
63 #include <sys/queue.h>
68 static void wr_archive
__P((register ARCHD
*, int is_app
));
69 static int get_arc
__P((void));
70 static int next_head
__P((register ARCHD
*));
71 extern sigset_t s_mask
;
76 * Routines which control the overall operation modes of pax as specified by
77 * the user: list, append, read ...
80 static char hdbuf
[BLKMULT
]; /* space for archive header on read */
81 u_long flcnt
; /* number of files processed */
85 * list the contents of an archive which match user supplied pattern(s)
86 * (no pattern matches all).
104 * figure out archive type; pass any format specific options to the
105 * archive option processing routine; call the format init routine. We
106 * also save current time for ls_list() so we do not make a system
107 * call for each file we need to print. If verbose (vflag) start up
108 * the name and group caches.
110 if ((get_arc() < 0) || ((*frmt
->options
)() < 0) ||
111 ((*frmt
->st_rd
)() < 0))
114 if (vflag
&& ((uidtb_start() < 0) || (gidtb_start() < 0)))
120 * step through the archive until the format says it is done
122 while (next_head(arcn
) == 0) {
124 * check for pattern, and user specified options match.
125 * When all patterns are matched we are done.
127 if ((res
= pat_match(arcn
)) < 0)
130 if ((res
== 0) && (sel_chk(arcn
) == 0)) {
132 * pattern resulted in a selected file
134 if (pat_sel(arcn
) < 0)
138 * modify the name as requested by the user if name
139 * survives modification, do a listing of the file
141 if ((res
= mod_name(arcn
)) < 0)
144 ls_list(arcn
, now
, stdout
);
148 * skip to next archive format header using values calculated
149 * by the format header read routine
151 if (rd_skip(arcn
->skip
+ arcn
->pad
) == 1)
156 * all done, let format have a chance to cleanup, and make sure that
157 * the patterns supplied by the user were all matched
159 (void)(*frmt
->end_rd
)();
160 (void)sigprocmask(SIG_BLOCK
, &s_mask
, NULL
);
167 * extract the member(s) of an archive as specified by user supplied
168 * pattern(s) (no patterns extracts all members)
179 register ARCHD
*arcn
;
187 int copyfile_disable
= (getenv(COPYFILE_DISABLE_VAR
) != NULL
);
188 LIST_HEAD(copyfile_list_t
, copyfile_list_entry_t
) copyfile_list
;
189 struct copyfile_list_entry_t
{
193 LIST_ENTRY(copyfile_list_entry_t
) link
;
196 LIST_INIT(©file_list
);
201 * figure out archive type; pass any format specific options to the
202 * archive option processing routine; call the format init routine;
203 * start up the directory modification time and access mode database
205 if ((get_arc() < 0) || ((*frmt
->options
)() < 0) ||
206 ((*frmt
->st_rd
)() < 0) || (dir_start() < 0))
210 * When we are doing interactive rename, we store the mapping of names
211 * so we can fix up hard links files later in the archive.
213 if (iflag
&& (name_start() < 0))
219 * step through each entry on the archive until the format read routine
222 while (next_head(arcn
) == 0) {
225 * check for pattern, and user specified options match. When
226 * all the patterns are matched we are done
228 if ((res
= pat_match(arcn
)) < 0)
231 if ((res
> 0) || (sel_chk(arcn
) != 0)) {
233 * file is not selected. skip past any file data and
234 * padding and go back for the next archive member
236 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
241 * with -u or -D only extract when the archive member is newer
242 * than the file with the same name in the file system (nos
243 * test of being the same type is required).
244 * NOTE: this test is done BEFORE name modifications as
245 * specified by pax. this operation can be confusing to the
246 * user who might expect the test to be done on an existing
247 * file AFTER the name mod. In honesty the pax spec is probably
248 * flawed in this respect.
250 if ((uflag
|| Dflag
) && ((lstat(arcn
->name
, &sb
) == 0))) {
251 if (uflag
&& Dflag
) {
252 if ((arcn
->sb
.st_mtime
<= sb
.st_mtime
) &&
253 (arcn
->sb
.st_ctime
<= sb
.st_ctime
)) {
254 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
258 if (arcn
->sb
.st_ctime
<= sb
.st_ctime
) {
259 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
262 } else if (arcn
->sb
.st_mtime
<= sb
.st_mtime
) {
263 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
269 * this archive member is now been selected. modify the name.
271 if ((pat_sel(arcn
) < 0) || ((res
= mod_name(arcn
)) < 0))
275 * a bad name mod, skip and purge name from link table
278 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
283 * Non standard -Y and -Z flag. When the exisiting file is
284 * same age or newer skip
286 if ((Yflag
|| Zflag
) && ((lstat(arcn
->name
, &sb
) == 0))) {
287 if (Yflag
&& Zflag
) {
288 if ((arcn
->sb
.st_mtime
<= sb
.st_mtime
) &&
289 (arcn
->sb
.st_ctime
<= sb
.st_ctime
)) {
290 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
294 if (arcn
->sb
.st_ctime
<= sb
.st_ctime
) {
295 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
298 } else if (arcn
->sb
.st_mtime
<= sb
.st_mtime
) {
299 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
306 ls_list(arcn
, now
, stderr
);
308 (void)fputs(arcn
->name
, stderr
);
314 * if required, chdir around.
316 if ((arcn
->pat
!= NULL
) && (arcn
->pat
->chdname
!= NULL
))
317 if (chdir(arcn
->pat
->chdname
) != 0)
318 syswarn(1, errno
, "Cannot chdir to %s",
322 * all ok, extract this member based on type
324 if ((arcn
->type
!= PAX_REG
) && (arcn
->type
!= PAX_CTG
)) {
326 * process archive members that are not regular files.
327 * throw out padding and any data that might follow the
328 * header (as determined by the format).
330 if ((arcn
->type
== PAX_HLK
) || (arcn
->type
== PAX_HRG
))
331 res
= lnk_creat(arcn
);
333 res
= node_creat(arcn
);
335 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
339 if (vflag
&& vfpart
) {
340 (void)putc('\n', stderr
);
346 * we have a file with data here. If we can not create it, skip
347 * over the data and purge the name from hard link table
349 if ((fd
= file_creat(arcn
)) < 0) {
350 (void)rd_skip(arcn
->skip
+ arcn
->pad
);
355 * extract the file from the archive and skip over padding and
356 * any unprocessed data
358 res
= (*frmt
->rd_data
)(arcn
, fd
, &cnt
);
359 file_close(arcn
, fd
);
360 if (vflag
&& vfpart
) {
361 (void)putc('\n', stderr
);
365 (void)rd_skip(cnt
+ arcn
->pad
);
368 if (!strncmp(basename(arcn
->name
), "._", 2))
370 cle
= alloca(sizeof(struct copyfile_list_entry_t
));
371 cle
->src
= strdup(arcn
->name
);
373 if (asprintf(&cle
->tmp
, "%s.XXX", cle
->src
) > MAXPATHLEN
)
375 if (mktemp(cle
->tmp
) == NULL
)
377 if (rename(cle
->src
, cle
->tmp
))
380 if (asprintf(&cle
->dst
, "%s/%s",
381 dirname(arcn
->name
), basename(arcn
->name
) + 2) != -1)
382 LIST_INSERT_HEAD(©file_list
, cle
, link
);
386 * if required, chdir around.
388 if ((arcn
->pat
!= NULL
) && (arcn
->pat
->chdname
!= NULL
))
389 if (fchdir(cwdfd
) != 0)
391 "Can't fchdir to starting directory");
395 LIST_FOREACH(cle
, ©file_list
, link
)
397 if(copyfile_disable
|| copyfile(cle
->tmp
, cle
->dst
, 0,
398 COPYFILE_UNPACK
| COPYFILE_XATTR
| COPYFILE_ACL
))
399 rename(cle
->tmp
, cle
->src
);
409 * all done, restore directory modes and times as required; make sure
410 * all patterns supplied by the user were matched; block off signals
411 * to avoid chance for multiple entry into the cleanup code.
413 (void)(*frmt
->end_rd
)();
414 (void)sigprocmask(SIG_BLOCK
, &s_mask
, NULL
);
422 * Write an archive. used in both creating a new archive and appends on
423 * previously written archive.
428 wr_archive(register ARCHD
*arcn
, int is_app
)
431 wr_archive(arcn
, is_app
)
432 register ARCHD
*arcn
;
445 char *md_fname
= NULL
;
447 char arcn_copy_name
[PAXPATHLEN
+1];
451 * if this format supports hard link storage, start up the database
454 if (((hlk
= frmt
->hlk
) == 1) && (lnk_start() < 0))
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 not append, and there are no files, we do no write a trailer
479 * while there are files to archive, process them one at at time
481 while (next_file(arcn
) == 0) {
483 * check if this file meets user specified options match.
485 if (sel_chk(arcn
) != 0)
489 * synthesize ._ files for each node we encounter
491 if (getenv(COPYFILE_DISABLE_VAR
) == NULL
492 && copyfile(arcn
->name
, NULL
, NULL
,
493 COPYFILE_CHECK
| COPYFILE_XATTR
| COPYFILE_ACL
)
494 && arcn
->nlen
+ 2 < sizeof(arcn
->name
))
499 md_fname
= strdup("/tmp/pax.md.XXXX");
500 memcpy(&arcn_copy
, arcn
, sizeof(ARCHD
));
501 strncpy(arcn_copy_name
, arcn
->name
, PAXPATHLEN
+1);
506 arcn
->ln_name
[0] = '\0';
507 arcn
->type
= PAX_REG
;
509 if(md_fname
&& mktemp(md_fname
))
510 if(copyfile(arcn
->name
, md_fname
, NULL
,
511 COPYFILE_PACK
| COPYFILE_XATTR
| COPYFILE_ACL
) < 0)
514 "Unable to preserve metadata on %s", arcn
->name
);
518 stat(md_fname
, &arcn
->sb
);
519 arcn
->skip
= arcn
->sb
.st_size
;
521 if (!strncmp(dirname(arcn
->name
), ".", 2))
522 size
= asprintf(&new, "._%s",
523 basename(arcn
->name
));
525 size
= asprintf(&new, "%s/._%s",
526 dirname(arcn
->name
), basename(arcn
->name
));
528 if (size
!= -1 && size
< sizeof arcn
->name
)
530 strncpy(arcn
->name
, new, PAXPATHLEN
+1);
534 arcn
->nlen
= strlen(arcn
->name
);
535 arcn
->org_name
= arcn
->name
;
538 } else if (metadata
) {
541 memcpy(arcn
, &arcn_copy
, sizeof(ARCHD
));
542 strncpy(arcn
->name
, arcn_copy_name
, PAXPATHLEN
+1);
548 * only archive if this file is newer than a file with
549 * the same name that is already stored on the archive
551 if ((res
= chk_ftime(arcn
)) < 0)
558 * this file is considered selected now. see if this is a hard
559 * link to a file already stored
562 if (hlk
&& (chk_lnk(arcn
) < 0))
565 if ((arcn
->type
== PAX_REG
) || (arcn
->type
== PAX_HRG
) ||
566 (arcn
->type
== PAX_CTG
)) {
568 * we will have to read this file. by opening it now we
569 * can avoid writing a header to the archive for a file
570 * we were later unable to read (we also purge it from
576 fd
= open(md_fname
, O_RDONLY
, 0);
580 fd
= open(arcn
->org_name
, O_RDONLY
, 0);
583 if ((fd
= open(arcn
->org_name
, O_RDONLY
, 0)) < 0) {
585 syswarn(1,errno
, "Unable to open %s to read",
593 * Now modify the name as requested by the user
595 if ((res
= mod_name(arcn
)) < 0) {
597 * name modification says to skip this file, close the
598 * file and purge link table entry
600 rdfile_close(arcn
, &fd
);
605 if ((res
> 0) || (docrc
&& (set_crc(arcn
, fd
) < 0))) {
607 * unable to obtain the crc we need, close the file,
608 * purge link table entry
610 rdfile_close(arcn
, &fd
);
617 ls_list(arcn
, now
, stderr
);
619 (void)fputs(arcn
->name
, stderr
);
626 * looks safe to store the file, have the format specific
627 * routine write routine store the file header on the archive
629 if ((res
= (*wrf
)(arcn
)) < 0) {
630 rdfile_close(arcn
, &fd
);
636 * format write says no file data needs to be stored
637 * so we are done messing with this file
639 if (vflag
&& vfpart
) {
640 (void)putc('\n', stderr
);
643 rdfile_close(arcn
, &fd
);
648 * Add file data to the archive, quit on write error. if we
649 * cannot write the entire file contents to the archive we
650 * must pad the archive to replace the missing file data
651 * (otherwise during an extract the file header for the file
652 * which FOLLOWS this one will not be where we expect it to
655 res
= (*frmt
->wr_data
)(arcn
, fd
, &cnt
);
656 rdfile_close(arcn
, &fd
);
657 if (vflag
&& vfpart
) {
658 (void)putc('\n', stderr
);
665 * pad as required, cnt is number of bytes not written
667 if (((cnt
> 0) && (wr_skip(cnt
) < 0)) ||
668 ((arcn
->pad
> 0) && (wr_skip(arcn
->pad
) < 0)))
677 * tell format to write trailer; pad to block boundry; reset directory
678 * mode/access times, and check if all patterns supplied by the user
679 * were matched. block off signals to avoid chance for multiple entry
680 * into the cleanup code
686 (void)sigprocmask(SIG_BLOCK
, &s_mask
, NULL
);
695 * Add file to previously written archive. Archive format specified by the
696 * user must agree with archive. The archive is read first to collect
697 * modification times (if -u) and locate the archive trailer. The archive
698 * is positioned in front of the record with the trailer and wr_archive()
699 * is called to add the new members.
700 * PAX IMPLEMENTATION DETAIL NOTE:
701 * -u is implemented by adding the new members to the end of the archive.
702 * Care is taken so that these do not end up as links to the older
703 * version of the same file already stored in the archive. It is expected
704 * when extraction occurs these newer versions will over-write the older
705 * ones stored "earlier" in the archive (this may be a bad assumption as
706 * it depends on the implementation of the program doing the extraction).
707 * It is really difficult to splice in members without either re-writing
708 * the entire archive (from the point were the old version was), or having
709 * assistance of the format specification in terms of a special update
710 * header that invalidates a previous archive record. The posix spec left
711 * the method used to implement -u unspecified. This pax is able to
712 * over write existing files that it creates.
723 register ARCHD
*arcn
;
734 * Do not allow an append operation if the actual archive is of a
735 * different format than the user specified foramt.
739 if ((orgfrmt
!= NULL
) && (orgfrmt
!= frmt
)) {
740 paxwarn(1, "Cannot mix current archive format %s with %s",
741 frmt
->name
, orgfrmt
->name
);
746 * pass the format any options and start up format
748 if (((*frmt
->options
)() < 0) || ((*frmt
->st_rd
)() < 0))
752 * if we only are adding members that are newer, we need to save the
753 * mod times for all files we see.
755 if (uflag
&& (ftime_start() < 0))
759 * some archive formats encode hard links by recording the device and
760 * file serial number (inode) but copy the file anyway (multiple times)
761 * to the archive. When we append, we run the risk that newly added
762 * files may have the same device and inode numbers as those recorded
763 * on the archive but during a previous run. If this happens, when the
764 * archive is extracted we get INCORRECT hard links. We avoid this by
765 * remapping the device numbers so that newly added files will never
766 * use the same device number as one found on the archive. remapping
767 * allows new members to safely have links among themselves. remapping
768 * also avoids problems with file inode (serial number) truncations
769 * when the inode number is larger than storage space in the archive
770 * header. See the remap routines for more details.
772 if ((udev
= frmt
->udev
) && (dev_start() < 0))
776 * reading the archive may take a long time. If verbose tell the user
779 (void)fprintf(stderr
,
780 "%s: Reading archive to position at the end...", argv0
);
785 * step through the archive until the format says it is done
787 while (next_head(arcn
) == 0) {
789 * check if this file meets user specified options.
791 if (sel_chk(arcn
) != 0) {
792 if (rd_skip(arcn
->skip
+ arcn
->pad
) == 1)
799 * see if this is the newest version of this file has
800 * already been seen, if so skip.
802 if ((res
= chk_ftime(arcn
)) < 0)
805 if (rd_skip(arcn
->skip
+ arcn
->pad
) == 1)
812 * Store this device number. Device numbers seen during the
813 * read phase of append will cause newly appended files with a
814 * device number seen in the old part of the archive to be
815 * remapped to an unused device number.
817 if ((udev
&& (add_dev(arcn
) < 0)) ||
818 (rd_skip(arcn
->skip
+ arcn
->pad
) == 1))
823 * done, finish up read and get the number of bytes to back up so we
824 * can add new members. The format might have used the hard link table,
827 tlen
= (*frmt
->end_rd
)();
831 * try to postion for write, if this fails quit. if any error occurs,
832 * we will refuse to write
834 if (appnd_start(tlen
) < 0)
838 * tell the user we are done reading.
840 if (vflag
&& vfpart
) {
841 (void)fputs("done.\n", stderr
);
846 * go to the writing phase to add the new members
853 * write a new archive
867 * if we only are adding members that are newer, we need to save the
868 * mod times for all files; set up for writing; pass the format any
869 * options write the archive
871 if ((uflag
&& (ftime_start() < 0)) || (wr_start() < 0))
873 if ((*frmt
->options
)() < 0)
876 wr_archive(&archd
, 0);
881 * copy files from one part of the file system to another. this does not
882 * use any archive storage. The EFFECT OF THE COPY IS THE SAME as if an
883 * archive was written and then extracted in the destination directory
884 * (except the files are forced to be under the destination directory).
895 register ARCHD
*arcn
;
898 register char *dest_pt
;
904 char dirbuf
[PAXPATHLEN
+1];
908 * set up the destination dir path and make sure it is a directory. We
909 * make sure we have a trailing / on the destination
911 dlen
= l_strncpy(dirbuf
, dirptr
, sizeof(dirbuf
) - 1);
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 * check if this file meets user specified options
958 if (sel_chk(arcn
) != 0)
962 * if there is already a file in the destination directory with
963 * the same name and it is newer, skip the one stored on the
965 * NOTE: this test is done BEFORE name modifications as
966 * specified by pax. this can be confusing to the user who
967 * might expect the test to be done on an existing file AFTER
968 * the name mod. In honesty the pax spec is probably flawed in
971 if (uflag
|| Dflag
) {
973 * create the destination name
975 if (*(arcn
->name
) == '/')
979 if ((arcn
->nlen
- res
) > drem
) {
980 paxwarn(1, "Destination pathname too long %s",
984 (void)strncpy(dest_pt
, arcn
->name
+ res
, drem
);
985 dirbuf
[PAXPATHLEN
] = '\0';
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 exisiting 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)fputs(arcn
->name
, stderr
);
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', stderr
);
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
);
1073 if (vflag
&& vfpart
) {
1074 (void)putc('\n', stderr
);
1081 * have to copy a regular file to the destination directory.
1082 * first open source file and then create the destination file
1084 if ((fdsrc
= open(arcn
->org_name
, O_RDONLY
, 0)) < 0) {
1085 syswarn(1, errno
, "Unable to open %s to read",
1090 if ((fddest
= file_creat(arcn
)) < 0) {
1091 rdfile_close(arcn
, &fdsrc
);
1097 * copy source file data to the destination file
1099 cp_file(arcn
, fdsrc
, fddest
);
1100 file_close(arcn
, fddest
);
1101 rdfile_close(arcn
, &fdsrc
);
1103 if (vflag
&& vfpart
) {
1104 (void)putc('\n', stderr
);
1108 if (getenv(COPYFILE_DISABLE_VAR
) == NULL
) {
1109 if (copyfile(arcn
->org_name
, arcn
->name
, 0, COPYFILE_ACL
| COPYFILE_XATTR
) < 0)
1110 paxwarn(1, "File %s had metadata that could not be copied", arcn
->org_name
);
1116 * restore directory modes and times as required; make sure all
1117 * patterns were selected block off signals to avoid chance for
1118 * multiple entry into the cleanup code.
1120 (void)sigprocmask(SIG_BLOCK
, &s_mask
, NULL
);
1128 * try to find a valid header in the archive. Uses format specific
1129 * routines to extract the header and id the trailer. Trailers may be
1130 * located within a valid header or in an invalid header (the location
1131 * is format specific. The inhead field from the option table tells us
1132 * where to look for the trailer).
1133 * We keep reading (and resyncing) until we get enough contiguous data
1134 * to check for a header. If we cannot find one, we shift by a byte
1135 * add a new byte from the archive to the end of the buffer and try again.
1136 * If we get a read error, we throw out what we have (as we must have
1137 * contiguous data) and start over again.
1138 * ASSUMED: headers fit within a BLKMULT header.
1140 * 0 if we got a header, -1 if we are unable to ever find another one
1141 * (we reached the end of input, or we reached the limit on retries. see
1142 * the specs for rd_wrbuf() for more details)
1147 next_head(register ARCHD
*arcn
)
1151 register ARCHD
*arcn
;
1155 register char *hdend
;
1157 register int shftsz
;
1159 register int in_resync
= 0; /* set when we are in resync mode */
1160 int cnt
= 0; /* counter for trailer function */
1161 int first
= 1; /* on 1st read, EOF isn't premature. */
1164 * set up initial conditions, we want a whole frmt->hsz block as we
1167 res
= hsz
= frmt
->hsz
;
1172 * keep looping until we get a contiguous FULL buffer
1173 * (frmt->hsz is the proper size)
1176 if ((ret
= rd_wrbuf(hdend
, res
)) == res
)
1180 * If we read 0 bytes (EOF) from an archive when we
1181 * expect to find a header, we have stepped upon
1182 * an archive without the customary block of zeroes
1183 * end marker. It's just stupid to error out on
1184 * them, so exit gracefully.
1186 if (first
&& ret
== 0)
1191 * some kind of archive read problem, try to resync the
1192 * storage device, better give the user the bad news.
1194 if ((ret
== 0) || (rd_sync() < 0)) {
1195 paxwarn(1,"Premature end of file on archive read");
1201 "Archive I/O error, cannot continue");
1204 paxwarn(1,"Archive I/O error. Trying to recover.");
1209 * oh well, throw it all out and start over
1216 * ok we have a contiguous buffer of the right size. Call the
1217 * format read routine. If this was not a valid header and this
1218 * format stores trailers outside of the header, call the
1219 * format specific trailer routine to check for a trailer. We
1220 * have to watch out that we do not mis-identify file data or
1221 * block padding as a header or trailer. Format specific
1222 * trailer functions must NOT check for the trailer while we
1223 * are running in resync mode. Some trailer functions may tell
1224 * us that this block cannot contain a valid header either, so
1225 * we then throw out the entire block and start over.
1227 if ((*frmt
->rd
)(arcn
, hdbuf
) == 0)
1230 if (!frmt
->inhead
) {
1232 * this format has trailers outside of valid headers
1234 if ((ret
= (*frmt
->trail
)(hdbuf
,in_resync
,&cnt
)) == 0){
1236 * valid trailer found, drain input as required
1244 * we are in resync and we were told to throw
1245 * the whole block out because none of the
1246 * bytes in this block can be used to form a
1256 * Brute force section.
1257 * not a valid header. We may be able to find a header yet. So
1258 * we shift over by one byte, and set up to read one byte at a
1259 * time from the archive and place it at the end of the buffer.
1260 * We will keep moving byte at a time until we find a header or
1261 * get a read error and have to start over.
1265 paxwarn(1,"Unable to append, archive header flaw");
1268 paxwarn(1,"Invalid header, starting valid header search.");
1271 memmove(hdbuf
, hdbuf
+1, shftsz
);
1273 hdend
= hdbuf
+ shftsz
;
1277 * ok got a valid header, check for trailer if format encodes it in the
1278 * the header. NOTE: the parameters are different than trailer routines
1279 * which encode trailers outside of the header!
1281 if (frmt
->inhead
&& ((*frmt
->trail
)(arcn
) == 0)) {
1283 * valid trailer found, drain input as required
1295 * Figure out what format an archive is. Handles archive with flaws by
1296 * brute force searches for a legal header in any supported format. The
1297 * format id routines have to be careful to NOT mis-identify a format.
1298 * ASSUMED: headers fit within a BLKMULT header.
1300 * 0 if archive found -1 otherwise
1312 register int hdsz
= 0;
1314 register int minhd
= BLKMULT
;
1319 * find the smallest header size in all archive formats and then set up
1320 * to read the archive.
1322 for (i
= 0; ford
[i
] >= 0; ++i
) {
1323 if (fsub
[ford
[i
]].hsz
< minhd
)
1324 minhd
= fsub
[ford
[i
]].hsz
;
1334 * fill the buffer with at least the smallest header
1336 i
= rd_wrbuf(hdend
, res
);
1343 * if we cannot recover from a read error quit
1345 if ((i
== 0) || (rd_sync() < 0))
1349 * when we get an error none of the data we already
1350 * have can be used to create a legal header (we just
1351 * got an error in the middle), so we throw it all out
1352 * and refill the buffer with fresh data.
1360 paxwarn(1,"Cannot identify format. Searching...");
1366 * we have at least the size of the smallest header in any
1367 * archive format. Look to see if we have a match. The array
1368 * ford[] is used to specify the header id order to reduce the
1369 * chance of incorrectly id'ing a valid header (some formats
1370 * may be subsets of each other and the order would then be
1373 for (i
= 0; ford
[i
] >= 0; ++i
) {
1374 if ((*fsub
[ford
[i
]].id
)(hdbuf
, hdsz
) < 0)
1376 frmt
= &(fsub
[ford
[i
]]);
1378 * yuck, to avoid slow special case code in the extract
1379 * routines, just push this header back as if it was
1380 * not seen. We have left extra space at start of the
1381 * buffer for this purpose. This is a bit ugly, but
1382 * adding all the special case code is far worse.
1389 * We have a flawed archive, no match. we start searching, but
1390 * we never allow additions to flawed archives
1395 paxwarn(1, "Cannot identify format. Searching...");
1400 * brute force search for a header that we can id.
1401 * we shift through byte at a time. this is slow, but we cannot
1402 * determine the nature of the flaw in the archive in a
1406 memmove(hdbuf
, hdbuf
+1, hdsz
);
1407 res
= BLKMULT
- hdsz
;
1408 hdend
= hdbuf
+ hdsz
;
1418 * we cannot find a header, bow, apologize and quit
1420 paxwarn(1, "Sorry, unable to determine archive format.");