static int
append_archive(struct bsdtar *bsdtar, struct archive *a, struct archive *ina)
{
struct archive_entry *in_entry;
int e;
while (ARCHIVE_OK == (e = archive_read_next_header(ina, &in_entry))) {
if (!new_enough(bsdtar, archive_entry_pathname(in_entry),
archive_entry_stat(in_entry)))
continue;
if (lafe_excluded(bsdtar->matching, archive_entry_pathname(in_entry)))
continue;
if (bsdtar->option_interactive &&
!yes("copy '%s'", archive_entry_pathname(in_entry)))
continue;
if (bsdtar->verbose)
safe_fprintf(stderr, "a %s",
archive_entry_pathname(in_entry));
if (need_report())
report_write(bsdtar, a, in_entry, 0);
e = archive_write_header(a, in_entry);
if (e != ARCHIVE_OK) {
if (!bsdtar->verbose)
lafe_warnc(0, "%s: %s",
archive_entry_pathname(in_entry),
archive_error_string(a));
else
fprintf(stderr, ": %s", archive_error_string(a));
}
if (e == ARCHIVE_FATAL)
exit(1);
if (e >= ARCHIVE_WARN) {
if (archive_entry_size(in_entry) == 0)
archive_read_data_skip(ina);
else if (copy_file_data(bsdtar, a, ina, in_entry))
exit(1);
}
if (bsdtar->verbose)
fprintf(stderr, "\n");
}
return (e == ARCHIVE_EOF ? ARCHIVE_OK : e);
}
static void
mode_list(struct cpio *cpio)
{
struct archive *a;
struct archive_entry *entry;
int r;
a = archive_read_new();
if (a == NULL)
lafe_errc(1, 0, "Couldn't allocate archive object");
archive_read_support_compression_all(a);
archive_read_support_format_all(a);
if (archive_read_open_file(a, cpio->filename, cpio->bytes_per_block))
lafe_errc(1, archive_errno(a),
"%s", archive_error_string(a));
for (;;) {
r = archive_read_next_header(a, &entry);
if (r == ARCHIVE_EOF)
break;
if (r != ARCHIVE_OK) {
lafe_errc(1, archive_errno(a),
"%s", archive_error_string(a));
}
if (lafe_excluded(cpio->matching, archive_entry_pathname(entry)))
continue;
if (cpio->verbose)
list_item_verbose(cpio, entry);
else
fprintf(stdout, "%s\n", archive_entry_pathname(entry));
}
r = archive_read_close(a);
if (r != ARCHIVE_OK)
lafe_errc(1, 0, "%s", archive_error_string(a));
if (!cpio->quiet) {
int64_t blocks = (archive_position_uncompressed(a) + 511)
/ 512;
fprintf(stderr, "%lu %s\n", (unsigned long)blocks,
blocks == 1 ? "block" : "blocks");
}
archive_read_finish(a);
exit(0);
}
static void
mode_in(struct cpio *cpio)
{
struct archive *a;
struct archive_entry *entry;
struct archive *ext;
const char *destpath;
int r;
ext = archive_write_disk_new();
if (ext == NULL)
lafe_errc(1, 0, "Couldn't allocate restore object");
r = archive_write_disk_set_options(ext, cpio->extract_flags);
if (r != ARCHIVE_OK)
lafe_errc(1, 0, "%s", archive_error_string(ext));
a = archive_read_new();
if (a == NULL)
lafe_errc(1, 0, "Couldn't allocate archive object");
archive_read_support_compression_all(a);
archive_read_support_format_all(a);
if (archive_read_open_file(a, cpio->filename, cpio->bytes_per_block))
lafe_errc(1, archive_errno(a),
"%s", archive_error_string(a));
for (;;) {
r = archive_read_next_header(a, &entry);
if (r == ARCHIVE_EOF)
break;
if (r != ARCHIVE_OK) {
lafe_errc(1, archive_errno(a),
"%s", archive_error_string(a));
}
if (lafe_excluded(cpio->matching, archive_entry_pathname(entry)))
continue;
if (cpio->option_rename) {
destpath = cpio_rename(archive_entry_pathname(entry));
archive_entry_set_pathname(entry, destpath);
} else
destpath = archive_entry_pathname(entry);
if (destpath == NULL)
continue;
if (cpio->verbose)
fprintf(stdout, "%s\n", destpath);
if (cpio->uid_override >= 0)
archive_entry_set_uid(entry, cpio->uid_override);
if (cpio->gid_override >= 0)
archive_entry_set_gid(entry, cpio->gid_override);
r = archive_write_header(ext, entry);
if (r != ARCHIVE_OK) {
fprintf(stderr, "%s: %s\n",
archive_entry_pathname(entry),
archive_error_string(ext));
} else if (archive_entry_size(entry) > 0) {
r = extract_data(a, ext);
if (r != ARCHIVE_OK)
cpio->return_value = 1;
}
}
r = archive_read_close(a);
if (r != ARCHIVE_OK)
lafe_errc(1, 0, "%s", archive_error_string(a));
r = archive_write_close(ext);
if (r != ARCHIVE_OK)
lafe_errc(1, 0, "%s", archive_error_string(ext));
if (!cpio->quiet) {
int64_t blocks = (archive_position_uncompressed(a) + 511)
/ 512;
fprintf(stderr, "%lu %s\n", (unsigned long)blocks,
blocks == 1 ? "block" : "blocks");
}
archive_read_finish(a);
archive_write_finish(ext);
exit(cpio->return_value);
}
/*
* Handle 'x' and 't' modes.
*/
static void
read_archive(struct bsdtar *bsdtar, char mode)
{
struct progress_data progress_data;
FILE *out;
struct archive *a;
struct archive_entry *entry;
const struct stat *st;
int r;
while (*bsdtar->argv) {
lafe_include(&bsdtar->matching, *bsdtar->argv);
bsdtar->argv++;
}
if (bsdtar->names_from_file != NULL)
lafe_include_from_file(&bsdtar->matching,
bsdtar->names_from_file, bsdtar->option_null);
a = archive_read_new();
if (bsdtar->compress_program != NULL)
archive_read_support_compression_program(a, bsdtar->compress_program);
else
archive_read_support_compression_all(a);
archive_read_support_format_all(a);
if (ARCHIVE_OK != archive_read_set_options(a, bsdtar->option_options))
lafe_errc(1, 0, "%s", archive_error_string(a));
if (archive_read_open_file(a, bsdtar->filename,
bsdtar->bytes_per_block != 0 ? bsdtar->bytes_per_block :
DEFAULT_BYTES_PER_BLOCK))
lafe_errc(1, 0, "Error opening archive: %s",
archive_error_string(a));
do_chdir(bsdtar);
if (mode == 'x') {
/* Set an extract callback so that we can handle SIGINFO. */
progress_data.bsdtar = bsdtar;
progress_data.archive = a;
archive_read_extract_set_progress_callback(a, progress_func,
&progress_data);
}
if (mode == 'x' && bsdtar->option_chroot) {
#if HAVE_CHROOT
if (chroot(".") != 0)
lafe_errc(1, errno, "Can't chroot to \".\"");
#else
lafe_errc(1, 0,
"chroot isn't supported on this platform");
#endif
}
for (;;) {
/* Support --fast-read option */
if (bsdtar->option_fast_read &&
lafe_unmatched_inclusions(bsdtar->matching) == 0)
break;
r = archive_read_next_header(a, &entry);
progress_data.entry = entry;
if (r == ARCHIVE_EOF)
break;
if (r < ARCHIVE_OK)
lafe_warnc(0, "%s", archive_error_string(a));
if (r <= ARCHIVE_WARN)
bsdtar->return_value = 1;
if (r == ARCHIVE_RETRY) {
/* Retryable error: try again */
lafe_warnc(0, "Retrying...");
continue;
}
if (r == ARCHIVE_FATAL)
break;
if (bsdtar->uid >= 0) {
archive_entry_set_uid(entry, bsdtar->uid);
archive_entry_set_uname(entry, NULL);
}
if (bsdtar->gid >= 0) {
archive_entry_set_gid(entry, bsdtar->gid);
archive_entry_set_gname(entry, NULL);
}
if (bsdtar->uname)
archive_entry_set_uname(entry, bsdtar->uname);
if (bsdtar->gname)
archive_entry_set_gname(entry, bsdtar->gname);
/*
* Exclude entries that are too old.
*/
st = archive_entry_stat(entry);
if (bsdtar->newer_ctime_sec > 0) {
if (st->st_ctime < bsdtar->newer_ctime_sec)
continue; /* Too old, skip it. */
if (st->st_ctime == bsdtar->newer_ctime_sec
&& ARCHIVE_STAT_CTIME_NANOS(st)
<= bsdtar->newer_ctime_nsec)
continue; /* Too old, skip it. */
}
if (bsdtar->newer_mtime_sec > 0) {
if (st->st_mtime < bsdtar->newer_mtime_sec)
continue; /* Too old, skip it. */
if (st->st_mtime == bsdtar->newer_mtime_sec
&& ARCHIVE_STAT_MTIME_NANOS(st)
<= bsdtar->newer_mtime_nsec)
continue; /* Too old, skip it. */
}
/*
* Note that pattern exclusions are checked before
* pathname rewrites are handled. This gives more
* control over exclusions, since rewrites always lose
* information. (For example, consider a rewrite
* s/foo[0-9]/foo/. If we check exclusions after the
* rewrite, there would be no way to exclude foo1/bar
* while allowing foo2/bar.)
*/
if (lafe_excluded(bsdtar->matching, archive_entry_pathname(entry)))
continue; /* Excluded by a pattern test. */
if (mode == 't') {
/* Perversely, gtar uses -O to mean "send to stderr"
* when used with -t. */
out = bsdtar->option_stdout ? stderr : stdout;
/*
* TODO: Provide some reasonable way to
* preview rewrites. gtar always displays
* the unedited path in -t output, which means
* you cannot easily preview rewrites.
*/
if (bsdtar->verbose < 2)
safe_fprintf(out, "%s",
archive_entry_pathname(entry));
else
list_item_verbose(bsdtar, out, entry);
fflush(out);
r = archive_read_data_skip(a);
if (r == ARCHIVE_WARN) {
fprintf(out, "\n");
lafe_warnc(0, "%s",
archive_error_string(a));
}
if (r == ARCHIVE_RETRY) {
fprintf(out, "\n");
lafe_warnc(0, "%s",
archive_error_string(a));
}
if (r == ARCHIVE_FATAL) {
fprintf(out, "\n");
lafe_warnc(0, "%s",
archive_error_string(a));
bsdtar->return_value = 1;
break;
}
fprintf(out, "\n");
} else {
/* Note: some rewrite failures prevent extraction. */
if (edit_pathname(bsdtar, entry))
continue; /* Excluded by a rewrite failure. */
if (bsdtar->option_interactive &&
!yes("extract '%s'", archive_entry_pathname(entry)))
continue;
/*
* Format here is from SUSv2, including the
* deferred '\n'.
*/
if (bsdtar->verbose) {
safe_fprintf(stderr, "x %s",
archive_entry_pathname(entry));
fflush(stderr);
}
// TODO siginfo_printinfo(bsdtar, 0);
if (bsdtar->option_stdout)
r = archive_read_data_into_fd(a, 1);
else
r = archive_read_extract(a, entry,
bsdtar->extract_flags);
if (r != ARCHIVE_OK) {
if (!bsdtar->verbose)
safe_fprintf(stderr, "%s",
archive_entry_pathname(entry));
safe_fprintf(stderr, ": %s",
archive_error_string(a));
if (!bsdtar->verbose)
fprintf(stderr, "\n");
bsdtar->return_value = 1;
}
if (bsdtar->verbose)
fprintf(stderr, "\n");
if (r == ARCHIVE_FATAL)
break;
}
}
r = archive_read_close(a);
if (r != ARCHIVE_OK)
lafe_warnc(0, "%s", archive_error_string(a));
if (r <= ARCHIVE_WARN)
bsdtar->return_value = 1;
if (bsdtar->verbose > 2)
fprintf(stdout, "Archive Format: %s, Compression: %s\n",
archive_format_name(a), archive_compression_name(a));
archive_read_finish(a);
}
/*
* Add the file or dir hierarchy named by 'path' to the archive
*/
static void
write_hierarchy(struct bsdtar *bsdtar, struct archive *a, const char *path)
{
struct archive_entry *entry = NULL, *spare_entry = NULL;
struct tree *tree;
char symlink_mode = bsdtar->symlink_mode;
dev_t first_dev = 0;
int dev_recorded = 0;
int tree_ret;
tree = tree_open(path);
if (!tree) {
lafe_warnc(errno, "%s: Cannot open", path);
bsdtar->return_value = 1;
return;
}
while ((tree_ret = tree_next(tree)) != 0) {
int r;
const char *name = tree_current_path(tree);
const struct stat *st = NULL; /* info to use for this entry */
const struct stat *lst = NULL; /* lstat() information */
int descend;
if (tree_ret == TREE_ERROR_FATAL)
lafe_errc(1, tree_errno(tree),
"%s: Unable to continue traversing directory tree",
name);
if (tree_ret == TREE_ERROR_DIR) {
lafe_warnc(errno,
"%s: Couldn't visit directory", name);
bsdtar->return_value = 1;
}
if (tree_ret != TREE_REGULAR)
continue;
/*
* If this file/dir is excluded by a filename
* pattern, skip it.
*/
if (lafe_excluded(bsdtar->matching, name))
continue;
/*
* Get lstat() info from the tree library.
*/
lst = tree_current_lstat(tree);
if (lst == NULL) {
/* Couldn't lstat(); must not exist. */
lafe_warnc(errno, "%s: Cannot stat", name);
/* Return error if files disappear during traverse. */
bsdtar->return_value = 1;
continue;
}
/*
* Distinguish 'L'/'P'/'H' symlink following.
*/
switch(symlink_mode) {
case 'H':
/* 'H': After the first item, rest like 'P'. */
symlink_mode = 'P';
/* 'H': First item (from command line) like 'L'. */
/* FALLTHROUGH */
case 'L':
/* 'L': Do descend through a symlink to dir. */
descend = tree_current_is_dir(tree);
/* 'L': Follow symlinks to files. */
archive_read_disk_set_symlink_logical(bsdtar->diskreader);
/* 'L': Archive symlinks as targets, if we can. */
st = tree_current_stat(tree);
if (st != NULL)
break;
/* If stat fails, we have a broken symlink;
* in that case, don't follow the link. */
/* FALLTHROUGH */
default:
/* 'P': Don't descend through a symlink to dir. */
descend = tree_current_is_physical_dir(tree);
/* 'P': Don't follow symlinks to files. */
archive_read_disk_set_symlink_physical(bsdtar->diskreader);
/* 'P': Archive symlinks as symlinks. */
st = lst;
break;
}
if (bsdtar->option_no_subdirs)
descend = 0;
/*
* Are we about to cross to a new filesystem?
*/
if (!dev_recorded) {
/* This is the initial file system. */
first_dev = lst->st_dev;
dev_recorded = 1;
} else if (lst->st_dev == first_dev) {
/* The starting file system is always acceptable. */
} else if (descend == 0) {
/* We're not descending, so no need to check. */
} else if (bsdtar->option_dont_traverse_mounts) {
descend = 0;
} else {
/* We're prepared to cross a mount point. */
/* XXX TODO: check whether this filesystem is
* synthetic and/or local. Add a new
* --local-only option to skip non-local
* filesystems. Skip synthetic filesystems
* regardless.
*
* The results should be cached, since
* tree.c doesn't usually visit a directory
* and the directory contents together. A simple
* move-to-front list should perform quite well.
*
* This is going to be heavily OS dependent:
* FreeBSD's statfs() in conjunction with getvfsbyname()
* provides all of this; NetBSD's statvfs() does
* most of it; other systems will vary.
*/
}
/*
* In -u mode, check that the file is newer than what's
* already in the archive; in all modes, obey --newerXXX flags.
*/
if (!new_enough(bsdtar, name, st)) {
if (!descend)
continue;
if (bsdtar->option_interactive &&
!yes("add '%s'", name))
continue;
tree_descend(tree);
continue;
}
archive_entry_free(entry);
entry = archive_entry_new();
archive_entry_set_pathname(entry, name);
archive_entry_copy_sourcepath(entry,
tree_current_access_path(tree));
/* Populate the archive_entry with metadata from the disk. */
/* XXX TODO: Arrange to open a regular file before
* calling this so we can pass in an fd and shorten
* the race to query metadata. The linkify dance
* makes this more complex than it might sound. */
#if defined(_WIN32) && !defined(__CYGWIN__)
/* TODO: tree.c uses stat(), which is badly broken
* on Windows. To fix this, we should
* deprecate tree_current_stat() and provide a new
* call tree_populate_entry(t, entry). This call
* would use stat() internally on POSIX and
* GetInfoByFileHandle() internally on Windows.
* This would be another step towards a tree-walker
* that can be integrated deep into libarchive.
* For now, just set st to NULL on Windows;
* archive_read_disk_entry_from_file() should
* be smart enough to use platform-appropriate
* ways to probe file information.
*/
st = NULL;
#endif
r = archive_read_disk_entry_from_file(bsdtar->diskreader,
entry, -1, st);
if (bsdtar->uid >= 0) {
archive_entry_set_uid(entry, bsdtar->uid);
if (!bsdtar->uname)
archive_entry_set_uname(entry,
archive_read_disk_uname(bsdtar->diskreader,
bsdtar->uid));
}
if (bsdtar->gid >= 0) {
archive_entry_set_gid(entry, bsdtar->gid);
if (!bsdtar->gname)
archive_entry_set_gname(entry,
archive_read_disk_gname(bsdtar->diskreader,
bsdtar->gid));
}
if (bsdtar->uname)
archive_entry_set_uname(entry, bsdtar->uname);
if (bsdtar->gname)
archive_entry_set_gname(entry, bsdtar->gname);
if (r != ARCHIVE_OK)
lafe_warnc(archive_errno(bsdtar->diskreader),
"%s", archive_error_string(bsdtar->diskreader));
if (r < ARCHIVE_WARN)
continue;
/* XXX TODO: Just use flag data from entry; avoid the
* duplicate check here. */
/*
* If this file/dir is flagged "nodump" and we're
* honoring such flags, skip this file/dir.
*/
#if defined(HAVE_STRUCT_STAT_ST_FLAGS) && defined(UF_NODUMP)
/* BSD systems store flags in struct stat */
if (bsdtar->option_honor_nodump &&
(lst->st_flags & UF_NODUMP))
continue;
#endif
#if defined(EXT2_IOC_GETFLAGS) && defined(EXT2_NODUMP_FL)
/* Linux uses ioctl to read flags. */
if (bsdtar->option_honor_nodump) {
int fd = open(name, O_RDONLY | O_NONBLOCK | O_BINARY);
if (fd >= 0) {
unsigned long fflags;
int r = ioctl(fd, EXT2_IOC_GETFLAGS, &fflags);
close(fd);
if (r >= 0 && (fflags & EXT2_NODUMP_FL))
continue;
}
}
#endif
#ifdef __APPLE__
if (bsdtar->enable_copyfile) {
/* If we're using copyfile(), ignore "._XXX" files. */
const char *bname = strrchr(name, '/');
if (bname == NULL)
bname = name;
else
++bname;
if (bname[0] == '.' && bname[1] == '_')
continue;
} else {
/* If not, drop the copyfile() data. */
archive_entry_copy_mac_metadata(entry, NULL, 0);
}
#endif
/*
* If the user vetoes this file/directory, skip it.
* We want this to be fairly late; if some other
* check would veto this file, we shouldn't bother
* the user with it.
*/
if (bsdtar->option_interactive &&
!yes("add '%s'", name))
continue;
if (descend)
tree_descend(tree);
/*
* Rewrite the pathname to be archived. If rewrite
* fails, skip the entry.
*/
if (edit_pathname(bsdtar, entry))
continue;
/* Display entry as we process it.
* This format is required by SUSv2. */
if (bsdtar->verbose)
safe_fprintf(stderr, "a %s",
archive_entry_pathname(entry));
/* Non-regular files get archived with zero size. */
if (archive_entry_filetype(entry) != AE_IFREG)
archive_entry_set_size(entry, 0);
archive_entry_linkify(bsdtar->resolver, &entry, &spare_entry);
while (entry != NULL) {
write_file(bsdtar, a, entry);
archive_entry_free(entry);
entry = spare_entry;
spare_entry = NULL;
}
if (bsdtar->verbose)
fprintf(stderr, "\n");
}
archive_entry_free(entry);
tree_close(tree);
}
