static void
test_archive_string_copy(void)
{
struct archive_string s, t, u, v;
archive_string_init(&s);
assertExactString(0, 0, NULL, s);
archive_string_init(&t);
assertExactString(0, 0, NULL, t);
archive_string_init(&u);
assertExactString(0, 0, NULL, u);
archive_string_init(&v);
assertExactString(0, 0, NULL, v);
/* null target, null source */
archive_string_copy(&t, &s);
assertExactString(0, 0, NULL, s);
assertExactString(0, EXTENT, "", t);
/* null target, empty source */
archive_string_copy(&u, &t);
assertExactString(0, EXTENT, "", t);
assertExactString(0, EXTENT, "", u);
/* empty target, empty source */
archive_string_copy(&u, &t);
assertExactString(0, EXTENT, "", t);
assertExactString(0, EXTENT, "", u);
/* null target, non-empty source */
assert(NULL != archive_strcpy(&s, "snafubar"));
assertExactString(8, EXTENT, "snafubar", s);
archive_string_copy(&v, &s);
assertExactString(8, EXTENT, "snafubar", s);
assertExactString(8, EXTENT, "snafubar", v);
/* empty target, non-empty source */
assertExactString(0, EXTENT, "", t);
archive_string_copy(&t, &s);
assertExactString(8, EXTENT, "snafubar", s);
assertExactString(8, EXTENT, "snafubar", t);
/* non-empty target, non-empty source */
assert(NULL != archive_strcpy(&s, "fubar"));
assertExactString(5, EXTENT, "fubar", s);
archive_string_copy(&t, &s);
assertExactString(5, EXTENT, "fubar", s);
assertExactString(5, EXTENT, "fubar", t);
}
int
__archive_mktemp(const char *tmpdir)
{
static const char num[] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
'u', 'v', 'w', 'x', 'y', 'z'
};
struct archive_string temp_name;
struct stat st;
int fd;
char *tp, *ep;
fd = -1;
archive_string_init(&temp_name);
if (tmpdir == NULL) {
if (get_tempdir(&temp_name) != ARCHIVE_OK)
goto exit_tmpfile;
} else
archive_strcpy(&temp_name, tmpdir);
if (temp_name.s[temp_name.length-1] == '/') {
temp_name.s[temp_name.length-1] = '\0';
temp_name.length --;
}
if (stat(temp_name.s, &st) < 0)
goto exit_tmpfile;
if (!S_ISDIR(st.st_mode)) {
errno = ENOTDIR;
goto exit_tmpfile;
}
archive_strcat(&temp_name, "/libarchive_");
tp = temp_name.s + archive_strlen(&temp_name);
archive_strcat(&temp_name, "XXXXXXXXXX");
ep = temp_name.s + archive_strlen(&temp_name);
do {
char *p;
p = tp;
archive_random(p, ep - p);
while (p < ep) {
int d = *((unsigned char *)p) % sizeof(num);
*p++ = num[d];
}
fd = open(temp_name.s, O_CREAT | O_EXCL | O_RDWR | O_CLOEXEC,
0600);
} while (fd < 0 && errno == EEXIST);
if (fd < 0)
goto exit_tmpfile;
__archive_ensure_cloexec_flag(fd);
unlink(temp_name.s);
exit_tmpfile:
archive_string_free(&temp_name);
return (fd);
}
int
__archive_mktemp(const char *tmpdir)
{
struct archive_string temp_name;
int fd = -1;
archive_string_init(&temp_name);
if (tmpdir == NULL) {
if (get_tempdir(&temp_name) != ARCHIVE_OK)
goto exit_tmpfile;
} else {
archive_strcpy(&temp_name, tmpdir);
if (temp_name.s[temp_name.length-1] != '/')
archive_strappend_char(&temp_name, '/');
}
archive_strcat(&temp_name, "libarchive_XXXXXX");
fd = mkstemp(temp_name.s);
if (fd < 0)
goto exit_tmpfile;
__archive_ensure_cloexec_flag(fd);
unlink(temp_name.s);
exit_tmpfile:
archive_string_free(&temp_name);
return (fd);
}
static void
test_archive_strcpy(void)
{
struct archive_string s;
archive_string_init(&s);
assertExactString(0, 0, NULL, s);
/* null target */
assert(&s == archive_strcpy(&s, "snafu"));
assertExactString(5, EXTENT, "snafu", s);
/* dirty target */
assert(&s == archive_strcpy(&s, "foo"));
assertExactString(3, EXTENT, "foo", s);
/* dirty target, empty source */
assert(&s == archive_strcpy(&s, ""));
assertExactString(0, EXTENT, "", s);
}
static int
get_tempdir(struct archive_string *temppath)
{
const char *tmp;
tmp = getenv("TMPDIR");
if (tmp == NULL)
#ifdef _PATH_TMP
tmp = _PATH_TMP;
#else
tmp = "/tmp";
#endif
archive_strcpy(temppath, tmp);
if (temppath->s[temppath->length-1] != '/')
archive_strappend_char(temppath, '/');
return (ARCHIVE_OK);
}
/*
* Add a filter to this write handle that passes all data through an
* external program.
*/
int
archive_write_add_filter_program(struct archive *_a, const char *cmd)
{
struct archive_write_filter *f = __archive_write_allocate_filter(_a);
struct private_data *data;
static const char *prefix = "Program: ";
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_program");
f->data = calloc(1, sizeof(*data));
if (f->data == NULL)
goto memerr;
data = (struct private_data *)f->data;
data->cmd = strdup(cmd);
if (data->cmd == NULL)
goto memerr;
data->pdata = __archive_write_program_allocate();
if (data->pdata == NULL)
goto memerr;
/* Make up a description string. */
if (archive_string_ensure(&data->description,
strlen(prefix) + strlen(cmd) + 1) == NULL)
goto memerr;
archive_strcpy(&data->description, prefix);
archive_strcat(&data->description, cmd);
f->name = data->description.s;
f->code = ARCHIVE_FILTER_PROGRAM;
f->open = archive_compressor_program_open;
f->write = archive_compressor_program_write;
f->close = archive_compressor_program_close;
f->free = archive_compressor_program_free;
return (ARCHIVE_OK);
memerr:
archive_compressor_program_free(f);
archive_set_error(_a, ENOMEM,
"Can't allocate memory for filter program");
return (ARCHIVE_FATAL);
}
static int
archive_write_lrzip_open(struct archive_write_filter *f)
{
struct write_lrzip *data = (struct write_lrzip *)f->data;
struct archive_string as;
int r;
archive_string_init(&as);
archive_strcpy(&as, "lrzip -q");
/* Specify compression type. */
switch (data->compression) {
case lzma:/* default compression */
break;
case bzip2:
archive_strcat(&as, " -b");
break;
case gzip:
archive_strcat(&as, " -g");
break;
case lzo:
archive_strcat(&as, " -l");
break;
case none:
archive_strcat(&as, " -n");
break;
case zpaq:
archive_strcat(&as, " -z");
break;
}
/* Specify compression level. */
if (data->compression_level > 0) {
archive_strcat(&as, " -L ");
archive_strappend_char(&as, '0' + data->compression_level);
}
r = __archive_write_program_open(f, data->pdata, as.s);
archive_string_free(&as);
return (r);
}
static int
archive_compressor_bzip2_open(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
struct archive_string as;
int r;
archive_string_init(&as);
archive_strcpy(&as, "bzip2");
/* Specify compression level. */
if (data->compression_level > 0) {
archive_strcat(&as, " -");
archive_strappend_char(&as, '0' + data->compression_level);
}
f->write = archive_compressor_bzip2_write;
r = __archive_write_program_open(f, data->pdata, as.s);
archive_string_free(&as);
return (r);
}
/*
* The Mac OS "copyfile()" API copies the extended metadata for a
* file into a separate file in AppleDouble format (see RFC 1740).
*
* Mac OS tar and cpio implementations store this extended
* metadata as a separate entry just before the regular entry
* with a "._" prefix added to the filename.
*
* Note that this is currently done unconditionally; the tar program has
* an option to discard this information before the archive is written.
*
* TODO: If there's a failure, report it and return ARCHIVE_WARN.
*/
static int
setup_mac_metadata(struct archive_read_disk *a,
struct archive_entry *entry, int *fd)
{
int tempfd = -1;
int copyfile_flags = COPYFILE_NOFOLLOW | COPYFILE_ACL | COPYFILE_XATTR;
struct stat copyfile_stat;
int ret = ARCHIVE_OK;
void *buff = NULL;
int have_attrs;
const char *name, *tempdir;
struct archive_string tempfile;
(void)fd; /* UNUSED */
name = archive_entry_sourcepath(entry);
if (name == NULL)
name = archive_entry_pathname(entry);
if (name == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Can't open file to read extended attributes: No name");
return (ARCHIVE_WARN);
}
if (a->tree != NULL) {
if (a->tree_enter_working_dir(a->tree) != 0) {
archive_set_error(&a->archive, errno,
"Couldn't change dir");
return (ARCHIVE_FAILED);
}
}
/* Short-circuit if there's nothing to do. */
have_attrs = copyfile(name, NULL, 0, copyfile_flags | COPYFILE_CHECK);
if (have_attrs == -1) {
archive_set_error(&a->archive, errno,
"Could not check extended attributes");
return (ARCHIVE_WARN);
}
if (have_attrs == 0)
return (ARCHIVE_OK);
tempdir = NULL;
if (issetugid() == 0)
tempdir = getenv("TMPDIR");
if (tempdir == NULL)
tempdir = _PATH_TMP;
archive_string_init(&tempfile);
archive_strcpy(&tempfile, tempdir);
archive_strcat(&tempfile, "tar.md.XXXXXX");
tempfd = mkstemp(tempfile.s);
if (tempfd < 0) {
archive_set_error(&a->archive, errno,
"Could not open extended attribute file");
ret = ARCHIVE_WARN;
goto cleanup;
}
__archive_ensure_cloexec_flag(tempfd);
/* XXX I wish copyfile() could pack directly to a memory
* buffer; that would avoid the temp file here. For that
* matter, it would be nice if fcopyfile() actually worked,
* that would reduce the many open/close races here. */
if (copyfile(name, tempfile.s, 0, copyfile_flags | COPYFILE_PACK)) {
archive_set_error(&a->archive, errno,
"Could not pack extended attributes");
ret = ARCHIVE_WARN;
goto cleanup;
}
if (fstat(tempfd, ©file_stat)) {
archive_set_error(&a->archive, errno,
"Could not check size of extended attributes");
ret = ARCHIVE_WARN;
goto cleanup;
}
buff = malloc(copyfile_stat.st_size);
if (buff == NULL) {
archive_set_error(&a->archive, errno,
"Could not allocate memory for extended attributes");
ret = ARCHIVE_WARN;
goto cleanup;
}
if (copyfile_stat.st_size != read(tempfd, buff, copyfile_stat.st_size)) {
archive_set_error(&a->archive, errno,
"Could not read extended attributes into memory");
ret = ARCHIVE_WARN;
goto cleanup;
}
archive_entry_copy_mac_metadata(entry, buff, copyfile_stat.st_size);
cleanup:
if (tempfd >= 0) {
close(tempfd);
unlink(tempfile.s);
}
archive_string_free(&tempfile);
free(buff);
return (ret);
}
static ssize_t
_popul_ehdr(struct archive_string *tgt, size_t tsz, warc_essential_hdr_t hdr)
{
static const char _ver[] = "WARC/1.0\r\n";
static const char * const _typ[LAST_WT] = {
NULL, "warcinfo", "metadata", "resource", NULL
};
char std_uuid[48U];
if (hdr.type == WT_NONE || hdr.type > WT_RSRC) {
/* brilliant, how exactly did we get here? */
return -1;
}
archive_strcpy(tgt, _ver);
archive_string_sprintf(tgt, "WARC-Type: %s\r\n", _typ[hdr.type]);
if (hdr.tgturi != NULL) {
/* check if there's a xyz:// */
static const char _uri[] = "";
static const char _fil[] = "file://";
const char *u;
char *chk = strchr(hdr.tgturi, ':');
if (chk != NULL && chk[1U] == '/' && chk[2U] == '/') {
/* yep, it's definitely a URI */
u = _uri;
} else {
/* hm, best to prepend file:// then */
u = _fil;
}
archive_string_sprintf(tgt,
"WARC-Target-URI: %s%s\r\n", u, hdr.tgturi);
}
/* record time is usually when the http is sent off,
* just treat the archive writing as such for a moment */
xstrftime(tgt, "WARC-Date: %Y-%m-%dT%H:%M:%SZ\r\n", hdr.rtime);
/* while we're at it, record the mtime */
xstrftime(tgt, "Last-Modified: %Y-%m-%dT%H:%M:%SZ\r\n", hdr.mtime);
if (hdr.recid == NULL) {
/* generate one, grrrr */
warc_uuid_t u;
_gen_uuid(&u);
/* Unfortunately, archive_string_sprintf does not
* handle the minimum number following '%'.
* So we have to use snprintf function here instead
* of archive_string_snprintf function. */
#if defined(_WIN32) && !defined(__CYGWIN__) && !( defined(_MSC_VER) && _MSC_VER >= 1900)
#define snprintf _snprintf
#endif
snprintf(
std_uuid, sizeof(std_uuid),
"<urn:uuid:%08x-%04x-%04x-%04x-%04x%08x>",
u.u[0U],
u.u[1U] >> 16U, u.u[1U] & 0xffffU,
u.u[2U] >> 16U, u.u[2U] & 0xffffU,
u.u[3U]);
hdr.recid = std_uuid;
}
/*
* Parse a single keyword and its value.
*/
static int
parse_keyword(struct archive_read *a, struct mtree *mtree,
struct archive_entry *entry, struct mtree_option *opt, int *parsed_kws)
{
char *val, *key;
key = opt->value;
if (*key == '\0')
return (ARCHIVE_OK);
if (strcmp(key, "nochange") == 0) {
*parsed_kws |= MTREE_HAS_NOCHANGE;
return (ARCHIVE_OK);
}
if (strcmp(key, "optional") == 0) {
*parsed_kws |= MTREE_HAS_OPTIONAL;
return (ARCHIVE_OK);
}
if (strcmp(key, "ignore") == 0) {
/*
* The mtree processing is not recursive, so
* recursion will only happen for explicitly listed
* entries.
*/
return (ARCHIVE_OK);
}
val = strchr(key, '=');
if (val == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Malformed attribute \"%s\" (%d)", key, key[0]);
return (ARCHIVE_WARN);
}
*val = '\0';
++val;
switch (key[0]) {
case 'c':
if (strcmp(key, "content") == 0
|| strcmp(key, "contents") == 0) {
parse_escapes(val, NULL);
archive_strcpy(&mtree->contents_name, val);
break;
}
if (strcmp(key, "cksum") == 0)
break;
case 'd':
if (strcmp(key, "device") == 0) {
*parsed_kws |= MTREE_HAS_DEVICE;
return parse_device(&a->archive, entry, val);
}
case 'f':
if (strcmp(key, "flags") == 0) {
*parsed_kws |= MTREE_HAS_FFLAGS;
archive_entry_copy_fflags_text(entry, val);
break;
}
case 'g':
if (strcmp(key, "gid") == 0) {
*parsed_kws |= MTREE_HAS_GID;
archive_entry_set_gid(entry, mtree_atol10(&val));
break;
}
if (strcmp(key, "gname") == 0) {
*parsed_kws |= MTREE_HAS_GNAME;
archive_entry_copy_gname(entry, val);
break;
}
case 'l':
if (strcmp(key, "link") == 0) {
archive_entry_copy_symlink(entry, val);
break;
}
case 'm':
if (strcmp(key, "md5") == 0 || strcmp(key, "md5digest") == 0)
break;
if (strcmp(key, "mode") == 0) {
if (val[0] >= '0' && val[0] <= '9') {
*parsed_kws |= MTREE_HAS_PERM;
archive_entry_set_perm(entry,
(mode_t)mtree_atol8(&val));
} else {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Symbolic mode \"%s\" unsupported", val);
return ARCHIVE_WARN;
}
break;
}
case 'n':
if (strcmp(key, "nlink") == 0) {
*parsed_kws |= MTREE_HAS_NLINK;
archive_entry_set_nlink(entry,
(unsigned int)mtree_atol10(&val));
break;
}
case 'r':
if (strcmp(key, "rmd160") == 0 ||
strcmp(key, "rmd160digest") == 0)
break;
case 's':
if (strcmp(key, "sha1") == 0 || strcmp(key, "sha1digest") == 0)
break;
if (strcmp(key, "sha256") == 0 ||
strcmp(key, "sha256digest") == 0)
break;
if (strcmp(key, "sha384") == 0 ||
strcmp(key, "sha384digest") == 0)
break;
if (strcmp(key, "sha512") == 0 ||
strcmp(key, "sha512digest") == 0)
break;
if (strcmp(key, "size") == 0) {
archive_entry_set_size(entry, mtree_atol10(&val));
break;
}
case 't':
if (strcmp(key, "tags") == 0) {
/*
* Comma delimited list of tags.
* Ignore the tags for now, but the interface
* should be extended to allow inclusion/exclusion.
*/
break;
}
if (strcmp(key, "time") == 0) {
int64_t m;
int64_t my_time_t_max = get_time_t_max();
int64_t my_time_t_min = get_time_t_min();
long ns;
*parsed_kws |= MTREE_HAS_MTIME;
m = mtree_atol10(&val);
/* Replicate an old mtree bug:
* 123456789.1 represents 123456789
* seconds and 1 nanosecond. */
if (*val == '.') {
++val;
ns = (long)mtree_atol10(&val);
} else
ns = 0;
if (m > my_time_t_max)
m = my_time_t_max;
else if (m < my_time_t_min)
m = my_time_t_min;
archive_entry_set_mtime(entry, (time_t)m, ns);
break;
}
if (strcmp(key, "type") == 0) {
switch (val[0]) {
case 'b':
if (strcmp(val, "block") == 0) {
archive_entry_set_filetype(entry, AE_IFBLK);
break;
}
case 'c':
if (strcmp(val, "char") == 0) {
archive_entry_set_filetype(entry, AE_IFCHR);
break;
}
case 'd':
if (strcmp(val, "dir") == 0) {
archive_entry_set_filetype(entry, AE_IFDIR);
break;
}
case 'f':
if (strcmp(val, "fifo") == 0) {
archive_entry_set_filetype(entry, AE_IFIFO);
break;
}
if (strcmp(val, "file") == 0) {
archive_entry_set_filetype(entry, AE_IFREG);
break;
}
case 'l':
if (strcmp(val, "link") == 0) {
archive_entry_set_filetype(entry, AE_IFLNK);
break;
}
default:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Unrecognized file type \"%s\"; assuming \"file\"", val);
archive_entry_set_filetype(entry, AE_IFREG);
return (ARCHIVE_WARN);
}
*parsed_kws |= MTREE_HAS_TYPE;
break;
}
case 'u':
if (strcmp(key, "uid") == 0) {
*parsed_kws |= MTREE_HAS_UID;
archive_entry_set_uid(entry, mtree_atol10(&val));
break;
}
if (strcmp(key, "uname") == 0) {
*parsed_kws |= MTREE_HAS_UNAME;
archive_entry_copy_uname(entry, val);
break;
}
default:
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Unrecognized key %s=%s", key, val);
return (ARCHIVE_WARN);
}
return (ARCHIVE_OK);
}
static int
archive_read_format_iso9660_read_header(struct archive_read *a,
struct archive_entry *entry)
{
struct iso9660 *iso9660;
struct file_info *file;
ssize_t bytes_read;
int r;
iso9660 = (struct iso9660 *)(a->format->data);
if (!a->archive.archive_format) {
a->archive.archive_format = ARCHIVE_FORMAT_ISO9660;
a->archive.archive_format_name = "ISO9660";
}
/* Get the next entry that appears after the current offset. */
r = next_entry_seek(a, iso9660, &file);
if (r != ARCHIVE_OK)
return (r);
iso9660->entry_bytes_remaining = file->size;
iso9660->entry_sparse_offset = 0; /* Offset for sparse-file-aware clients. */
/* Set up the entry structure with information about this entry. */
archive_entry_set_mode(entry, file->mode);
archive_entry_set_uid(entry, file->uid);
archive_entry_set_gid(entry, file->gid);
archive_entry_set_nlink(entry, file->nlinks);
archive_entry_set_ino(entry, file->inode);
archive_entry_set_mtime(entry, file->mtime, 0);
archive_entry_set_ctime(entry, file->ctime, 0);
archive_entry_set_atime(entry, file->atime, 0);
archive_entry_set_size(entry, iso9660->entry_bytes_remaining);
archive_string_empty(&iso9660->pathname);
archive_entry_set_pathname(entry,
build_pathname(&iso9660->pathname, file));
if (file->symlink.s != NULL)
archive_entry_copy_symlink(entry, file->symlink.s);
/* If this entry points to the same data as the previous
* entry, convert this into a hardlink to that entry.
* But don't bother for zero-length files. */
if (file->offset == iso9660->previous_offset
&& file->size == iso9660->previous_size
&& file->size > 0) {
archive_entry_set_hardlink(entry,
iso9660->previous_pathname.s);
iso9660->entry_bytes_remaining = 0;
iso9660->entry_sparse_offset = 0;
release_file(iso9660, file);
return (ARCHIVE_OK);
}
/* If the offset is before our current position, we can't
* seek backwards to extract it, so issue a warning. */
if (file->offset < iso9660->current_position) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Ignoring out-of-order file");
iso9660->entry_bytes_remaining = 0;
iso9660->entry_sparse_offset = 0;
release_file(iso9660, file);
return (ARCHIVE_WARN);
}
iso9660->previous_size = file->size;
iso9660->previous_offset = file->offset;
archive_strcpy(&iso9660->previous_pathname, iso9660->pathname.s);
/* If this is a directory, read in all of the entries right now. */
if (archive_entry_filetype(entry) == AE_IFDIR) {
while (iso9660->entry_bytes_remaining > 0) {
const void *block;
const unsigned char *p;
ssize_t step = iso9660->logical_block_size;
if (step > iso9660->entry_bytes_remaining)
step = iso9660->entry_bytes_remaining;
bytes_read = (a->decompressor->read_ahead)(a, &block, step);
if (bytes_read < step) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Failed to read full block when scanning ISO9660 directory list");
release_file(iso9660, file);
return (ARCHIVE_FATAL);
}
if (bytes_read > step)
bytes_read = step;
(a->decompressor->consume)(a, bytes_read);
iso9660->current_position += bytes_read;
iso9660->entry_bytes_remaining -= bytes_read;
for (p = (const unsigned char *)block;
*p != 0 && p < (const unsigned char *)block + bytes_read;
p += *p) {
struct file_info *child;
/* Skip '.' entry. */
if (*(p + DR_name_len_offset) == 1
&& *(p + DR_name_offset) == '\0')
continue;
/* Skip '..' entry. */
if (*(p + DR_name_len_offset) == 1
&& *(p + DR_name_offset) == '\001')
continue;
child = parse_file_info(iso9660, file, p);
add_entry(iso9660, child);
if (iso9660->seenRockridge) {
a->archive.archive_format =
ARCHIVE_FORMAT_ISO9660_ROCKRIDGE;
a->archive.archive_format_name =
"ISO9660 with Rockridge extensions";
}
}
}
}
release_file(iso9660, file);
return (ARCHIVE_OK);
}
static int
slurp_central_directory(struct archive_read *a, struct zip *zip)
{
unsigned i;
int64_t correction;
static const struct archive_rb_tree_ops rb_ops = {
&cmp_node, &cmp_key
};
static const struct archive_rb_tree_ops rb_rsrc_ops = {
&rsrc_cmp_node, &rsrc_cmp_key
};
/*
* Consider the archive file we are reading may be SFX.
* So we have to calculate a SFX header size to revise
* ZIP header offsets.
*/
correction = zip->end_of_central_directory_offset -
(zip->central_directory_offset + zip->central_directory_size);
/* The central directory offset is relative value, and so
* we revise this offset for SFX. */
zip->central_directory_offset += correction;
__archive_read_seek(a, zip->central_directory_offset, SEEK_SET);
zip->offset = zip->central_directory_offset;
__archive_rb_tree_init(&zip->tree, &rb_ops);
__archive_rb_tree_init(&zip->tree_rsrc, &rb_rsrc_ops);
zip->zip_entries = calloc(zip->central_directory_entries,
sizeof(struct zip_entry));
for (i = 0; i < zip->central_directory_entries; ++i) {
struct zip_entry *zip_entry = &zip->zip_entries[i];
size_t filename_length, extra_length, comment_length;
uint32_t external_attributes;
const char *name, *p, *r;
if ((p = __archive_read_ahead(a, 46, NULL)) == NULL)
return ARCHIVE_FATAL;
if (memcmp(p, "PK\001\002", 4) != 0) {
archive_set_error(&a->archive,
-1, "Invalid central directory signature");
return ARCHIVE_FATAL;
}
zip->have_central_directory = 1;
/* version = p[4]; */
zip_entry->system = p[5];
/* version_required = archive_le16dec(p + 6); */
zip_entry->flags = archive_le16dec(p + 8);
zip_entry->compression = (char)archive_le16dec(p + 10);
zip_entry->mtime = zip_time(p + 12);
zip_entry->crc32 = archive_le32dec(p + 16);
zip_entry->compressed_size = archive_le32dec(p + 20);
zip_entry->uncompressed_size = archive_le32dec(p + 24);
filename_length = archive_le16dec(p + 28);
extra_length = archive_le16dec(p + 30);
comment_length = archive_le16dec(p + 32);
/* disk_start = archive_le16dec(p + 34); */ /* Better be zero. */
/* internal_attributes = archive_le16dec(p + 36); */ /* text bit */
external_attributes = archive_le32dec(p + 38);
zip_entry->local_header_offset =
archive_le32dec(p + 42) + correction;
/* If we can't guess the mode, leave it zero here;
when we read the local file header we might get
more information. */
zip_entry->mode = 0;
if (zip_entry->system == 3) {
zip_entry->mode = external_attributes >> 16;
}
/*
* Mac resource fork files are stored under the
* "__MACOSX/" directory, so we should check if
* it is.
*/
/* Make sure we have the file name. */
if ((p = __archive_read_ahead(a, 46 + filename_length, NULL))
== NULL)
return ARCHIVE_FATAL;
name = p + 46;
r = rsrc_basename(name, filename_length);
if (filename_length >= 9 &&
strncmp("__MACOSX/", name, 9) == 0) {
/* If this file is not a resource fork nor
* a directory. We should treat it as a non
* resource fork file to expose it. */
if (name[filename_length-1] != '/' &&
(r - name < 3 || r[0] != '.' || r[1] != '_')) {
__archive_rb_tree_insert_node(&zip->tree,
&zip_entry->node);
/* Expose its parent directories. */
expose_parent_dirs(zip, name, filename_length);
} else {
/* This file is a resource fork file or
* a directory. */
archive_strncpy(&(zip_entry->rsrcname), name,
filename_length);
__archive_rb_tree_insert_node(&zip->tree_rsrc,
&zip_entry->node);
}
} else {
/* Generate resource fork name to find its resource
* file at zip->tree_rsrc. */
archive_strcpy(&(zip_entry->rsrcname), "__MACOSX/");
archive_strncat(&(zip_entry->rsrcname), name, r - name);
archive_strcat(&(zip_entry->rsrcname), "._");
archive_strncat(&(zip_entry->rsrcname),
name + (r - name), filename_length - (r - name));
/* Register an entry to RB tree to sort it by
* file offset. */
__archive_rb_tree_insert_node(&zip->tree,
&zip_entry->node);
}
/* We don't read the filename until we get to the
local file header. Reading it here would speed up
table-of-contents operations (removing the need to
find and read local file header to get the
filename) at the cost of requiring a lot of extra
space. */
/* We don't read the extra block here. We assume it
will be duplicated at the local file header. */
__archive_read_consume(a,
46 + filename_length + extra_length + comment_length);
}
int
__archive_read_program(struct archive_read_filter *self, const char *cmd)
{
struct program_filter *state;
static const size_t out_buf_len = 65536;
char *out_buf;
const char *prefix = "Program: ";
pid_t child;
size_t l;
l = strlen(prefix) + strlen(cmd) + 1;
state = (struct program_filter *)calloc(1, sizeof(*state));
out_buf = (char *)malloc(out_buf_len);
if (state == NULL || out_buf == NULL ||
archive_string_ensure(&state->description, l) == NULL) {
archive_set_error(&self->archive->archive, ENOMEM,
"Can't allocate input data");
if (state != NULL) {
archive_string_free(&state->description);
free(state);
}
free(out_buf);
return (ARCHIVE_FATAL);
}
archive_strcpy(&state->description, prefix);
archive_strcat(&state->description, cmd);
self->code = ARCHIVE_FILTER_PROGRAM;
self->name = state->description.s;
state->out_buf = out_buf;
state->out_buf_len = out_buf_len;
child = __archive_create_child(cmd, &state->child_stdin,
&state->child_stdout);
if (child == -1) {
free(state->out_buf);
free(state);
archive_set_error(&self->archive->archive, EINVAL,
"Can't initialize filter; unable to run program \"%s\"",
cmd);
return (ARCHIVE_FATAL);
}
#if defined(_WIN32) && !defined(__CYGWIN__)
state->child = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, child);
if (state->child == NULL) {
child_stop(self, state);
free(state->out_buf);
free(state);
archive_set_error(&self->archive->archive, EINVAL,
"Can't initialize filter; unable to run program \"%s\"",
cmd);
return (ARCHIVE_FATAL);
}
#else
state->child = child;
#endif
self->data = state;
self->read = program_filter_read;
self->skip = NULL;
self->close = program_filter_close;
/* XXX Check that we can read at least one byte? */
return (ARCHIVE_OK);
}
