static void
test_symlink(void)
{
const char *refname = "test_read_format_zip_symlink.zip";
char *p;
size_t s;
struct archive *a;
struct archive_entry *ae;
extract_reference_file(refname);
p = slurpfile(&s, refname);
/* Symlinks can only be extracted with the seeking reader. */
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, p, s, 1));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("file", archive_entry_pathname(ae));
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
assertEqualInt(archive_entry_is_encrypted(ae), 0);
assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("symlink", archive_entry_pathname(ae));
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualString("file", archive_entry_symlink(ae));
assertEqualInt(archive_entry_is_encrypted(ae), 0);
assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}
/**
* A file with leading garbage (similar to an SFX file).
*/
static void
test_compat_zip_4(void)
{
const char *refname = "test_compat_zip_4.zip";
struct archive_entry *ae;
struct archive *a;
void *p;
size_t s;
extract_reference_file(refname);
p = slurpfile(&s, refname);
/* SFX files require seek support. */
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, p, s, 18));
/* First entry. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("foo", archive_entry_pathname(ae));
assertEqualInt(4, archive_entry_size(ae));
assert(archive_entry_size_is_set(ae));
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
assertEqualInt(0412, archive_entry_perm(ae));
/* Second entry. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("bar", archive_entry_pathname(ae));
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
assertEqualInt(4, archive_entry_size(ae));
assert(archive_entry_size_is_set(ae));
assertEqualInt(0567, archive_entry_perm(ae));
/* Third entry. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("baz", archive_entry_pathname(ae));
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
assertEqualInt(4, archive_entry_size(ae));
assert(archive_entry_size_is_set(ae));
assertEqualInt(0644, archive_entry_perm(ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
/* Try reading without seek support and watch it fail. */
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_FATAL, read_open_memory(a, p, s, 3));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
free(p);
}
static int
archive_write_ustar_header(struct archive_write *a, struct archive_entry *entry)
{
char buff[512];
int ret, ret2;
struct ustar *ustar;
ustar = (struct ustar *)a->format_data;
/* Only regular files (not hardlinks) have data. */
if (archive_entry_hardlink(entry) != NULL ||
archive_entry_symlink(entry) != NULL ||
!(archive_entry_filetype(entry) == AE_IFREG))
archive_entry_set_size(entry, 0);
if (AE_IFDIR == archive_entry_filetype(entry)) {
const char *p;
char *t;
/*
* Ensure a trailing '/'. Modify the entry so
* the client sees the change.
*/
p = archive_entry_pathname(entry);
if (p[strlen(p) - 1] != '/') {
t = (char *)malloc(strlen(p) + 2);
if (t == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate ustar data");
return(ARCHIVE_FATAL);
}
strcpy(t, p);
strcat(t, "/");
archive_entry_copy_pathname(entry, t);
free(t);
}
}
ret = __archive_write_format_header_ustar(a, buff, entry, -1, 1);
if (ret < ARCHIVE_WARN)
return (ret);
ret2 = (a->compressor.write)(a, buff, 512);
if (ret2 < ARCHIVE_WARN)
return (ret2);
if (ret2 < ret)
ret = ret2;
ustar->entry_bytes_remaining = archive_entry_size(entry);
ustar->entry_padding = 0x1ff & (-(int64_t)ustar->entry_bytes_remaining);
return (ret);
}
int extract_iso(uniso_status_t *s, struct archive *iso, const char *dst,
distro_filter_f filter, uniso_progress_t total, uniso_progress_cb cb,
void *cb_data) {
struct archive_entry *e;
uniso_progress_t current = 0;
make_dir_parents(dst);
if(cb)
cb(current, total, cb_data);
while(archive_read_next_header(iso, &e) == ARCHIVE_OK) {
char *name = unix_path(strdup2(archive_entry_pathname(e)));
if(archive_entry_filetype(e) == AE_IFDIR
|| !filter(name)) {
free(name);
continue;
}
s->files = new_string_node_t(name, s->files);
char *dest = unix_path(create_dest(dst, "/", name));
if(!extract_file(s, iso, dest)) {
free(dest);
return 0;
}
++current;
if(cb)
cb(current, total, cb_data);
free(dest);
}
return 1;
}
static void verify1(struct archive_entry *ae)
{
/* A hardlink is not a symlink. */
assert(archive_entry_filetype(ae) != AE_IFLNK);
/* Nor is it a directory. */
assert(archive_entry_filetype(ae) != AE_IFDIR);
assertEqualInt(archive_entry_mode(ae) & 0777, 0644);
assertEqualInt(archive_entry_uid(ae), 1000);
assertEqualInt(archive_entry_gid(ae), 1000);
assertEqualString(archive_entry_uname(ae), "tim");
assertEqualString(archive_entry_gname(ae), "tim");
assertEqualString(archive_entry_pathname(ae), "hardlink");
assertEqualString(archive_entry_hardlink(ae), "file");
assert(archive_entry_symlink(ae) == NULL);
assertEqualInt(archive_entry_mtime(ae), 1184388530);
}
static void
test_read_format_mtree2(void)
{
static char archive[] =
"#mtree\n"
"d type=dir content=.\n";
struct archive_entry *ae;
struct archive *a;
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, archive, sizeof(archive)));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_MTREE);
assertEqualString(archive_entry_pathname(ae), "d");
assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_file_count(a));
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
static void create(struct archive_entry *ae, const char *msg)
{
struct archive *ad;
struct stat st;
/* Write the entry to disk. */
assert((ad = archive_write_disk_new()) != NULL);
failure("%s", msg);
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
#if ARCHIVE_API_VERSION > 1
assertEqualInt(0, archive_write_finish(ad));
#else
archive_write_finish(ad);
#endif
/* Test the entries on disk. */
assert(0 == stat(archive_entry_pathname(ae), &st));
failure("st.st_mode=%o archive_entry_mode(ae)=%o",
st.st_mode, archive_entry_mode(ae));
/* When verifying a dir, ignore the S_ISGID bit, as some systems set
* that automatically. */
if (archive_entry_filetype(ae) == AE_IFDIR)
st.st_mode &= ~S_ISGID;
assertEqualInt(st.st_mode, archive_entry_mode(ae) & ~UMASK);
}
/*
* Extract to memory to check CRC
*/
static int
test(struct archive *a, struct archive_entry *e)
{
ssize_t len;
int error_count;
error_count = 0;
if (S_ISDIR(archive_entry_filetype(e)))
return 0;
info(" testing: %s\t", archive_entry_pathname(e));
while ((len = archive_read_data(a, buffer, sizeof buffer)) > 0)
/* nothing */;
if (len < 0) {
info(" %s\n", archive_error_string(a));
++error_count;
} else {
info(" OK\n");
}
/* shouldn't be necessary, but it doesn't hurt */
ac(archive_read_data_skip(a));
return error_count;
}
static int
write_path(struct archive_entry *entry, struct archive_write *archive)
{
int ret;
const char *path;
mode_t type;
size_t written_bytes;
path = archive_entry_pathname(entry);
type = archive_entry_filetype(entry);
written_bytes = 0;
ret = __archive_write_output(archive, path, strlen(path));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
written_bytes += strlen(path);
/* Folders are recognized by a traling slash. */
if ((type == AE_IFDIR) & (path[strlen(path) - 1] != '/')) {
ret = __archive_write_output(archive, "/", 1);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
written_bytes += 1;
}
return ((int)written_bytes);
}
static int
archive_write_newc_header(struct archive_write *a, struct archive_entry *entry)
{
const char *path;
size_t len;
if (archive_entry_filetype(entry) == 0) {
archive_set_error(&a->archive, -1, "Filetype required");
return (ARCHIVE_FAILED);
}
if (archive_entry_pathname_l(entry, &path, &len, get_sconv(a)) != 0
&& errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Pathname");
return (ARCHIVE_FATAL);
}
if (len == 0 || path == NULL || path[0] == '\0') {
archive_set_error(&a->archive, -1, "Pathname required");
return (ARCHIVE_FAILED);
}
if (archive_entry_hardlink(entry) == NULL
&& (!archive_entry_size_is_set(entry) || archive_entry_size(entry) < 0)) {
archive_set_error(&a->archive, -1, "Size required");
return (ARCHIVE_FAILED);
}
return write_header(a, entry);
}
// Iterate entries. The first call establishes the first entry. Returns false
// if no entry found, otherwise returns true and sets mpa->entry/entry_filename.
bool mp_archive_next_entry(struct mp_archive *mpa)
{
mpa->entry = NULL;
talloc_free(mpa->entry_filename);
mpa->entry_filename = NULL;
while (!mp_cancel_test(mpa->primary_src->cancel)) {
struct archive_entry *entry;
int r = archive_read_next_header(mpa->arch, &entry);
if (r == ARCHIVE_EOF)
break;
if (r < ARCHIVE_OK)
MP_ERR(mpa, "%s\n", archive_error_string(mpa->arch));
if (r < ARCHIVE_WARN) {
MP_FATAL(mpa, "could not read archive entry\n");
break;
}
if (archive_entry_filetype(entry) != AE_IFREG)
continue;
// Some archives may have no filenames, or libarchive won't return some.
const char *fn = archive_entry_pathname(entry);
char buf[64];
if (!fn || bstr_validate_utf8(bstr0(fn)) < 0) {
snprintf(buf, sizeof(buf), "mpv_unknown#%d", mpa->entry_num);
fn = buf;
}
mpa->entry = entry;
mpa->entry_filename = talloc_strdup(mpa, fn);
mpa->entry_num += 1;
return true;
}
return false;
}
/*
* We should get a warning if the contents file doesn't exist.
*/
static void
test_read_format_mtree5(void)
{
static char archive[] =
"#mtree\n"
"a type=file contents=nonexistent_file\n";
struct archive_entry *ae;
struct archive *a;
assertMakeDir("mtree5", 0777);
assertChdir("mtree5");
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, archive, sizeof(archive)));
assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
assert(strlen(archive_error_string(a)) > 0);
assertEqualString(archive_entry_pathname(ae), "a");
assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_file_count(a));
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
assertChdir("..");
}
static int
do_extract(struct archive *a, struct archive_entry *ae)
{
int retcode = EPKG_OK;
int ret = 0;
char path[MAXPATHLEN];
struct stat st;
do {
const char *pathname = archive_entry_pathname(ae);
ret = archive_read_extract(a, ae, EXTRACT_ARCHIVE_FLAGS);
if (ret != ARCHIVE_OK) {
/*
* show error except when the failure is during
* extracting a directory and that the directory already
* exists.
* this allow to install packages linux_base from
* package for example
*/
if (archive_entry_filetype(ae) != AE_IFDIR ||
!is_dir(pathname)) {
pkg_emit_error("archive_read_extract(): %s",
archive_error_string(a));
retcode = EPKG_FATAL;
goto cleanup;
}
}
/*
* if the file is a configuration file and the configuration
* file does not already exist on the file system, then
* extract it
* ex: conf1.cfg.pkgconf:
* if conf1.cfg doesn't exists create it based on
* conf1.cfg.pkgconf
*/
if (is_conf_file(pathname, path, sizeof(path))
&& lstat(path, &st) == -1 && errno == ENOENT) {
archive_entry_set_pathname(ae, path);
ret = archive_read_extract(a,ae, EXTRACT_ARCHIVE_FLAGS);
if (ret != ARCHIVE_OK) {
pkg_emit_error("archive_read_extract(): %s",
archive_error_string(a));
retcode = EPKG_FATAL;
goto cleanup;
}
}
} while ((ret = archive_read_next_header(a, &ae)) == ARCHIVE_OK);
if (ret != ARCHIVE_EOF) {
pkg_emit_error("archive_read_next_header(): %s",
archive_error_string(a));
retcode = EPKG_FATAL;
}
cleanup:
return (retcode);
}
/*
* Issue 185: Test a regression that got in between 2.6 and 2.7 that
* broke extraction of Zip entries with length-at-end.
*/
static void
test_compat_zip_3(void)
{
const char *refname = "test_compat_zip_3.zip";
struct archive_entry *ae;
struct archive *a;
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 10240));
/* First entry. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("soapui-4.0.0/", archive_entry_pathname(ae));
assertEqualInt(0, archive_entry_size(ae));
assert(archive_entry_size_is_set(ae));
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
/* Second entry. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("soapui-4.0.0/soapui-settings.xml", archive_entry_pathname(ae));
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
assertEqualInt(1030, archive_entry_size(ae));
assert(archive_entry_size_is_set(ae));
/* Extract under a different name. */
archive_entry_set_pathname(ae, "test_3.txt");
if(libz_enabled) {
char *p;
size_t s;
assertEqualIntA(a, ARCHIVE_OK, archive_read_extract(a, ae, 0));
/* Verify the first 12 bytes actually got written to disk correctly. */
p = slurpfile(&s, "test_3.txt");
assertEqualInt(s, 1030);
assertEqualMem(p, "<?xml versio", 12);
free(p);
} else {
skipping("Skipping ZIP compression check, no libz support");
}
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}
int
packing_append_file(struct packing *pack, const char *filepath, const char *newpath)
{
int fd;
int len;
char linkdest[MAXPATHLEN];
char buf[BUFSIZ];
int retcode = EPKG_OK;
struct stat st;
archive_entry_clear(pack->entry);
archive_entry_copy_sourcepath(pack->entry, filepath);
retcode = archive_read_disk_entry_from_file(pack->aread, pack->entry, -1, NULL);
if (retcode != ARCHIVE_OK) {
pkg_emit_event(PKG_EVENT_ARCHIVE_ERROR, /*argc*/2,
filepath, pack->aread);
retcode = EPKG_FATAL;
goto cleanup;
}
retcode = EPKG_OK;
lstat(filepath, &st);
archive_entry_copy_stat(pack->entry, &st);
if (S_ISLNK(st.st_mode)) {
bzero(linkdest, MAXPATHLEN);
readlink(filepath, linkdest, MAXPATHLEN);
archive_entry_set_symlink(pack->entry, linkdest);
}
if (newpath != NULL)
archive_entry_set_pathname(pack->entry, newpath);
if (archive_entry_filetype(pack->entry) != AE_IFREG) {
archive_entry_set_size(pack->entry, 0);
}
archive_write_header(pack->awrite, pack->entry);
if (archive_entry_size(pack->entry) > 0) {
if ((fd = open(filepath, O_RDONLY)) < 0) {
pkg_emit_event(PKG_EVENT_IO_ERROR, /*argc*/3,
"open", filepath, strerror(errno));
retcode = EPKG_FATAL;
goto cleanup;
}
while ((len = read(fd, buf, sizeof(buf))) > 0 )
archive_write_data(pack->awrite, buf, len);
close(fd);
}
cleanup:
archive_entry_clear(pack->entry);
return (retcode);
}
bool Decompress(const std::string & file, const std::string & output_path, std::ostream & info_output, std::ostream & error_output)
{
// Ensure the output path exists.
PathManager::MakeDir(output_path);
struct archive * a = archive_read_new();
archive_read_support_filter_all(a);
archive_read_support_format_all(a);
if (archive_read_open_filename(a, file.c_str(), BUFFSIZE) != ARCHIVE_OK)
{
error_output << "Unable to open " << file << std::endl;
return false;
}
char buff[BUFFSIZE];
struct archive_entry *entry;
while (archive_read_next_header(a, &entry) == ARCHIVE_OK)
{
std::string filename = archive_entry_pathname(entry);
std::string fullpath = output_path + "/" + filename;
if (archive_entry_filetype(entry) == AE_IFDIR)
PathManager::MakeDir(fullpath);
else
{
std::fstream f(fullpath.c_str(), std::ios_base::out | std::ios_base::binary | std::ios_base::trunc);
if (!f)
{
error_output << "Unable to open file for write (permissions issue?): " << fullpath << std::endl;
return false;
}
int size = -1;
while (size != 0)
{
size = archive_read_data(a, buff, BUFFSIZE);
if (size < 0)
{
error_output << "Encountered corrupt file: " << filename << std::endl;
return false;
}
else if (size != 0)
f.write(buff, size);
}
}
archive_read_data_skip(a);
}
if (archive_read_free(a) != ARCHIVE_OK)
{
error_output << "Unable to finish read of " << file << std::endl;
return false;
}
info_output << "Successfully decompressed " << file << std::endl;
return true;
}
static void verify1(struct archive *a, struct archive_entry *ae)
{
(void)a; /* UNUSED */
/* A hardlink is not a symlink. */
assert(archive_entry_filetype(ae) != AE_IFLNK);
/* Nor is it a directory. */
assert(archive_entry_filetype(ae) != AE_IFDIR);
assertEqualInt(archive_entry_mode(ae) & 0777, 0644);
assertEqualInt(archive_entry_uid(ae), UID);
assertEqualInt(archive_entry_gid(ae), GID);
assertEqualString(archive_entry_uname(ae), UNAME);
assertEqualString(archive_entry_gname(ae), GNAME);
assertEqualString(archive_entry_pathname(ae), "hardlink");
assertEqualString(archive_entry_hardlink(ae), "f1");
assert(archive_entry_symlink(ae) == NULL);
assertEqualInt(archive_entry_mtime(ae), 86401);
assertEqualInt(archive_entry_nlink(ae), 2);
}
bool Entry::is_file()
{
if(S_ISREG(archive_entry_filetype(_entry)) &&
!this->is_hardlink()) {
return true;
}
return false;
}
static int open_file(struct demuxer *demuxer, enum demux_check check)
{
if (stream_get_size(demuxer->stream) == 0)
return -1;
int flags = 0;
if (check <= DEMUX_CHECK_REQUEST)
flags |= MP_ARCHIVE_FLAG_UNSAFE;
struct mp_archive *mpa = mp_archive_new(demuxer->log, demuxer->stream, flags);
if (!mpa)
return -1;
struct playlist *pl = talloc_zero(demuxer, struct playlist);
demuxer->playlist = pl;
// make it load archive://
pl->disable_safety = true;
char *prefix = mp_url_escape(mpa, demuxer->stream->url, "~|");
char **files = NULL;
int num_files = 0;
for (;;) {
struct archive_entry *entry;
int r = archive_read_next_header(mpa->arch, &entry);
if (r == ARCHIVE_EOF)
break;
if (r < ARCHIVE_OK)
MP_ERR(demuxer, "libarchive: %s\n", archive_error_string(mpa->arch));
if (r < ARCHIVE_WARN)
break;
if (archive_entry_filetype(entry) != AE_IFREG)
continue;
const char *fn = archive_entry_pathname(entry);
// Some archives may have no filenames.
if (!fn)
fn = talloc_asprintf(mpa, "mpv_unknown#%d\n", num_files);
// stream_libarchive.c does the real work
char *f = talloc_asprintf(mpa, "archive://%s|%s", prefix, fn);
MP_TARRAY_APPEND(mpa, files, num_files, f);
}
if (files)
qsort(files, num_files, sizeof(files[0]), cmp_filename);
for (int n = 0; n < num_files; n++)
playlist_add_file(pl, files[n]);
demuxer->filetype = "archive";
demuxer->fully_read = true;
mp_archive_free(mpa);
return 0;
}
static void verify5(struct archive_entry *ae)
{
assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
assertEqualInt(archive_entry_mtime(ae), 1131430878);
assertEqualInt(archive_entry_mode(ae) & 0777, 0755);
assertEqualInt(archive_entry_uid(ae), 1000);
assertEqualInt(archive_entry_gid(ae), 1000);
assertEqualString(archive_entry_uname(ae), "tim");
assertEqualString(archive_entry_gname(ae), "tim");
}
static int
archive_read_format_cpio_read_header(struct archive_read *a,
struct archive_entry *entry)
{
struct cpio *cpio;
const void *h;
size_t namelength;
size_t name_pad;
int r;
cpio = (struct cpio *)(a->format->data);
r = (cpio->read_header(a, cpio, entry, &namelength, &name_pad));
if (r < ARCHIVE_WARN)
return (r);
/* Read name from buffer. */
h = __archive_read_ahead(a, namelength + name_pad, NULL);
if (h == NULL)
return (ARCHIVE_FATAL);
__archive_read_consume(a, namelength + name_pad);
archive_strncpy(&cpio->entry_name, (const char *)h, namelength);
archive_entry_set_pathname(entry, cpio->entry_name.s);
cpio->entry_offset = 0;
/* If this is a symlink, read the link contents. */
if (archive_entry_filetype(entry) == AE_IFLNK) {
h = __archive_read_ahead(a, cpio->entry_bytes_remaining, NULL);
if (h == NULL)
return (ARCHIVE_FATAL);
__archive_read_consume(a, cpio->entry_bytes_remaining);
archive_strncpy(&cpio->entry_linkname, (const char *)h,
cpio->entry_bytes_remaining);
archive_entry_set_symlink(entry, cpio->entry_linkname.s);
cpio->entry_bytes_remaining = 0;
}
/* XXX TODO: If the full mode is 0160200, then this is a Solaris
* ACL description for the following entry. Read this body
* and parse it as a Solaris-style ACL, then read the next
* header. XXX */
/* Compare name to "TRAILER!!!" to test for end-of-archive. */
if (namelength == 11 && strcmp((const char *)h, "TRAILER!!!") == 0) {
/* TODO: Store file location of start of block. */
archive_set_error(&a->archive, 0, NULL);
return (ARCHIVE_EOF);
}
/* Detect and record hardlinks to previously-extracted entries. */
record_hardlink(cpio, entry);
return (r);
}
static int
restore_time(struct cpio *cpio, struct archive_entry *entry,
const char *name, int fd)
{
#ifndef HAVE_UTIMES
static int warned = 0;
(void)cpio; /* UNUSED */
(void)entry; /* UNUSED */
(void)name; /* UNUSED */
if (!warned)
lafe_warnc(0, "Can't restore access times on this platform");
warned = 1;
return (fd);
#else
#if defined(_WIN32) && !defined(__CYGWIN__)
struct __timeval times[2];
#else
struct timeval times[2];
#endif
if (!cpio->option_atime_restore)
return (fd);
times[1].tv_sec = archive_entry_mtime(entry);
times[1].tv_usec = archive_entry_mtime_nsec(entry) / 1000;
times[0].tv_sec = archive_entry_atime(entry);
times[0].tv_usec = archive_entry_atime_nsec(entry) / 1000;
#if defined(HAVE_FUTIMES) && !defined(__CYGWIN__)
if (fd >= 0 && futimes(fd, times) == 0)
return (fd);
#endif
/*
* Some platform cannot restore access times if the file descriptor
* is still opened.
*/
if (fd >= 0) {
close(fd);
fd = -1;
}
#ifdef HAVE_LUTIMES
if (lutimes(name, times) != 0)
#else
if ((AE_IFLNK != archive_entry_filetype(entry))
&& utimes(name, times) != 0)
#endif
lafe_warnc(errno, "Can't update time for %s", name);
#endif
return (fd);
}
static void verify5(struct archive *a, struct archive_entry *ae)
{
(void)a; /* UNUSED */
assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
assertEqualInt(archive_entry_mtime(ae), 86401);
assertEqualInt(archive_entry_mode(ae) & 0777, 0755);
assertEqualInt(archive_entry_uid(ae), UID);
assertEqualInt(archive_entry_gid(ae), GID);
assertEqualString(archive_entry_uname(ae), UNAME);
assertEqualString(archive_entry_gname(ae), GNAME);
}
/*
* Issue 225: Errors extracting MSDOS Zip archives with directories.
*/
static void
compat_zip_6_verify(struct archive *a)
{
struct archive_entry *ae;
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("New Folder/New Folder/", archive_entry_pathname(ae));
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
/* Zip timestamps are local time, so vary by time zone. */
/* TODO: A more complex assert would work here; we could
verify that it's within +/- 24 hours of a particular value. */
/* assertEqualInt(1327314468, archive_entry_mtime(ae)); */
assertEqualInt(0, archive_entry_size(ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("New Folder/New Folder/New Text Document.txt", archive_entry_pathname(ae));
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
/* Zip timestamps are local time, so vary by time zone. */
/* assertEqualInt(1327314476, archive_entry_mtime(ae)); */
assertEqualInt(11, archive_entry_size(ae));
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
}
void load_examples(const void *data, size_t len, example_list_t *examples)
{
example_patch_t *patch;
struct archive *arch;
struct archive_entry *ent;
const char *path;
FILE *fp;
char *buf;
size_t size;
char block[4096];
ssize_t count;
int ret;
assert(data != NULL);
arch = archive_read_new();
assert(arch != NULL);
if (archive_read_support_format_zip(arch))
abort();
if (archive_read_open_memory(arch, (void *) data, len))
abort();
while (!(ret = archive_read_next_header(arch, &ent))) {
if (!S_ISREG(archive_entry_filetype(ent)))
continue;
path = archive_entry_pathname(ent);
if (strncmp(path, EXAMPLE_DIR "/", strlen(EXAMPLE_DIR) + 1))
continue;
/* archive_entry_size() is not reliable for Zip files */
fp = open_memstream(&buf, &size);
if (fp == NULL)
abort();
while ((count = archive_read_data(arch, block,
sizeof(block))) > 0)
if (fwrite(block, 1, count, fp) != (size_t) count)
abort();
if (count < 0) {
fprintf(stderr, "%s\n", archive_error_string(arch));
abort();
}
fclose(fp);
patch = malloc(sizeof(*patch));
patch->image = read_rgb_image(buf, size);
if (patch->image == NULL) {
fprintf(stderr, "Couldn't decode example %s\n", path);
abort();
}
TAILQ_INSERT_TAIL(examples, patch, link);
free(buf);
}
assert(ret == ARCHIVE_EOF);
if (archive_read_finish(arch))
abort();
}
static void verify6(struct archive_entry *ae)
{
assertEqualInt(archive_entry_filetype(ae), AE_IFIFO);
assertEqualInt(archive_entry_mode(ae) & 0777, 0755);
assertEqualInt(archive_entry_uid(ae), 1000);
assertEqualInt(archive_entry_gid(ae), 1000);
assertEqualString(archive_entry_uname(ae), "tim");
assertEqualString(archive_entry_gname(ae), "tim");
assertEqualString(archive_entry_pathname(ae), "fifo");
assert(archive_entry_symlink(ae) == NULL);
assert(archive_entry_hardlink(ae) == NULL);
assertEqualInt(archive_entry_mtime(ae), 1184389185);
}
static void verify2(struct archive *a, struct archive_entry *ae)
{
(void)a; /* UNUSED */
assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
assertEqualInt(archive_entry_mode(ae) & 0777, 0755);
assertEqualInt(archive_entry_uid(ae), UID);
assertEqualInt(archive_entry_gid(ae), GID);
assertEqualString(archive_entry_uname(ae), UNAME);
assertEqualString(archive_entry_gname(ae), GNAME);
assertEqualString(archive_entry_pathname(ae), "symlink");
assertEqualString(archive_entry_symlink(ae), "f1");
assert(archive_entry_hardlink(ae) == NULL);
}
/*
* Reported to libarchive.googlecode.com as Issue 121.
*/
static void
test_read_format_mtree3(void)
{
static char archive[] =
"#mtree\n"
"a type=file contents=file\n"
"b type=link link=a\n"
"c type=file contents=file\n";
struct archive_entry *ae;
struct archive *a;
assertMakeDir("mtree3", 0777);
assertChdir("mtree3");
assertMakeFile("file", 0644, "file contents");
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, archive, sizeof(archive)));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString(archive_entry_pathname(ae), "a");
assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString(archive_entry_pathname(ae), "b");
assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString(archive_entry_pathname(ae), "c");
assertEqualInt(archive_entry_filetype(ae), AE_IFREG);
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualInt(3, archive_file_count(a));
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
assertChdir("..");
}
static int
archive_read_format_cpio_read_header(struct archive_read *a,
struct archive_entry *entry)
{
struct cpio *cpio;
size_t bytes;
const void *h;
size_t namelength;
size_t name_pad;
int r;
cpio = (struct cpio *)(a->format->data);
r = (cpio->read_header(a, cpio, entry, &namelength, &name_pad));
if (r < ARCHIVE_WARN)
return (r);
/* Read name from buffer. */
bytes = (a->decompressor->read_ahead)(a, &h, namelength + name_pad);
if (bytes < namelength + name_pad)
return (ARCHIVE_FATAL);
(a->decompressor->consume)(a, namelength + name_pad);
archive_strncpy(&cpio->entry_name, (const char *)h, namelength);
archive_entry_set_pathname(entry, cpio->entry_name.s);
cpio->entry_offset = 0;
/* If this is a symlink, read the link contents. */
if (archive_entry_filetype(entry) == AE_IFLNK) {
bytes = (a->decompressor->read_ahead)(a, &h,
cpio->entry_bytes_remaining);
if ((off_t)bytes < cpio->entry_bytes_remaining)
return (ARCHIVE_FATAL);
(a->decompressor->consume)(a, cpio->entry_bytes_remaining);
archive_strncpy(&cpio->entry_linkname, (const char *)h,
cpio->entry_bytes_remaining);
archive_entry_set_symlink(entry, cpio->entry_linkname.s);
cpio->entry_bytes_remaining = 0;
}
/* Compare name to "TRAILER!!!" to test for end-of-archive. */
if (namelength == 11 && strcmp((const char *)h, "TRAILER!!!") == 0) {
/* TODO: Store file location of start of block. */
archive_set_error(&a->archive, 0, NULL);
return (ARCHIVE_EOF);
}
/* Detect and record hardlinks to previously-extracted entries. */
record_hardlink(cpio, entry);
return (r);
}
static void
write_entry(struct archive *archive, struct archive_entry *entry)
{
char buf[16384];
const char *name;
int fd;
off_t len;
ssize_t buf_len;
if (archive_entry_pathname(entry) == NULL) {
warnx("entry with NULL path");
return;
}
if (archive_write_header(archive, entry)) {
errx(2, "cannot write %s to archive: %s",
archive_entry_pathname(entry),
archive_error_string(archive));
}
/* Only regular files can have data. */
if (archive_entry_filetype(entry) != AE_IFREG ||
archive_entry_size(entry) == 0) {
archive_entry_free(entry);
return;
}
name = archive_entry_pathname(entry);
if ((fd = open(name, O_RDONLY)) == -1)
err(2, "cannot open data file %s", name);
len = archive_entry_size(entry);
while (len > 0) {
buf_len = (len > (off_t)sizeof(buf)) ? (ssize_t)sizeof(buf) : (ssize_t)len;
if ((buf_len = read(fd, buf, buf_len)) == 0)
break;
else if (buf_len < 0)
err(2, "cannot read from %s", name);
archive_write_data(archive, buf, (size_t)buf_len);
len -= buf_len;
}
close(fd);
archive_entry_free(entry);
}
