void EnableArchiveFormats(struct archive *p_archive)
{
// archive_read_support_filter_bzip2(p_archive);
// archive_read_support_filter_compress(p_archive);
// archive_read_support_filter_gzip(p_archive);
// archive_read_support_filter_grzip(p_archive);
// archive_read_support_filter_lrzip(p_archive);
// archive_read_support_filter_lzip(p_archive);
archive_read_support_filter_lzma(p_archive);
archive_read_support_filter_lzop(p_archive);
archive_read_support_filter_none(p_archive);
archive_read_support_filter_rpm(p_archive);
archive_read_support_filter_uu(p_archive);
archive_read_support_filter_xz(p_archive);
// archive_read_support_format_7zip(p_archive);
archive_read_support_format_ar(p_archive);
archive_read_support_format_cab(p_archive);
archive_read_support_format_cpio(p_archive);
archive_read_support_format_gnutar(p_archive);
// archive_read_support_format_iso9660(p_archive);
archive_read_support_format_lha(p_archive);
archive_read_support_format_mtree(p_archive);
archive_read_support_format_rar(p_archive);
archive_read_support_format_raw(p_archive);
archive_read_support_format_tar(p_archive);
archive_read_support_format_xar(p_archive);
// archive_read_support_format_zip(p_archive);
}
int
archive_read_support_format_all(struct archive *a)
{
archive_check_magic(a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_NEW, "archive_read_support_format_all");
/* TODO: It would be nice to compute the ordering
* here automatically so that people who enable just
* a few formats can still get the benefits. That
* may just require the format registration to include
* a "maximum read-ahead" value (anything that uses seek
* would be essentially infinite read-ahead). The core
* bid management can then sort the bidders before calling
* them.
*
* If you implement the above, please return the list below
* to alphabetic order.
*/
/*
* These bidders are all pretty cheap; they just examine a
* small initial part of the archive. If one of these bids
* high, we can maybe avoid running any of the more expensive
* bidders below.
*/
archive_read_support_format_ar(a);
archive_read_support_format_cpio(a);
archive_read_support_format_empty(a);
archive_read_support_format_lha(a);
archive_read_support_format_mtree(a);
archive_read_support_format_tar(a);
archive_read_support_format_xar(a);
/*
* Install expensive bidders last. By doing them last, we
* increase the chance that a high bid from someone else will
* make it unnecessary for these to do anything at all.
*/
/* These three have potentially large look-ahead. */
archive_read_support_format_7zip(a);
archive_read_support_format_cab(a);
archive_read_support_format_rar(a);
archive_read_support_format_iso9660(a);
/* Seek is really bad, since it forces the read-ahead
* logic to discard buffered data. */
archive_read_support_format_zip(a);
/* Note: We always return ARCHIVE_OK here, even if some of the
* above return ARCHIVE_WARN. The intent here is to enable
* "as much as possible." Clients who need specific
* compression should enable those individually so they can
* verify the level of support. */
/* Clear any warning messages set by the above functions. */
archive_clear_error(a);
return (ARCHIVE_OK);
}
int
archive_read_support_format_all(struct archive *a)
{
archive_read_support_format_ar(a);
archive_read_support_format_cpio(a);
archive_read_support_format_empty(a);
archive_read_support_format_iso9660(a);
archive_read_support_format_mtree(a);
archive_read_support_format_tar(a);
archive_read_support_format_xar(a);
archive_read_support_format_zip(a);
return (ARCHIVE_OK);
}
inline void genSafariExtension(const std::string& path, QueryData& results) {
Row r;
r["path"] = path;
// Loop through (Plist key -> table column name) in kSafariExtensionKeys.
struct archive* ext = archive_read_new();
if (ext == nullptr) {
return;
}
// Use open_file, instead of the preferred open_filename for OS X 10.9.
archive_read_support_format_xar(ext);
if (archive_read_open_file(ext, path.c_str(), 10240) != ARCHIVE_OK) {
archive_read_finish(ext);
return;
}
struct archive_entry* entry = nullptr;
while (archive_read_next_header(ext, &entry) == ARCHIVE_OK) {
auto item_path = archive_entry_pathname(entry);
// Documentation for libarchive mentions these APIs may return NULL.
if (item_path == nullptr) {
archive_read_data_skip(ext);
continue;
}
// Assume there is no non-root Info.
if (std::string(item_path).find("Info.plist") == std::string::npos) {
archive_read_data_skip(ext);
continue;
}
// Read the decompressed Info.plist content.
auto content = std::string(archive_entry_size(entry), '\0');
archive_read_data_into_buffer(ext, &content[0], content.size());
// If the Plist can be parsed, extract important keys into columns.
pt::ptree tree;
if (parsePlistContent(content, tree).ok()) {
for (const auto& it : kSafariExtensionKeys) {
r[it.second] = tree.get(it.first, "");
}
}
break;
}
archive_read_close(ext);
archive_read_finish(ext);
results.push_back(std::move(r));
}
int
archive_read_support_format_by_code(struct archive *a, int format_code)
{
archive_check_magic(a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_NEW, "archive_read_support_format_by_code");
switch (format_code & ARCHIVE_FORMAT_BASE_MASK) {
case ARCHIVE_FORMAT_7ZIP:
return archive_read_support_format_7zip(a);
break;
case ARCHIVE_FORMAT_AR:
return archive_read_support_format_ar(a);
break;
case ARCHIVE_FORMAT_CAB:
return archive_read_support_format_cab(a);
break;
case ARCHIVE_FORMAT_CPIO:
return archive_read_support_format_cpio(a);
break;
case ARCHIVE_FORMAT_ISO9660:
return archive_read_support_format_iso9660(a);
break;
case ARCHIVE_FORMAT_LHA:
return archive_read_support_format_lha(a);
break;
case ARCHIVE_FORMAT_MTREE:
return archive_read_support_format_mtree(a);
break;
case ARCHIVE_FORMAT_RAR:
return archive_read_support_format_rar(a);
break;
case ARCHIVE_FORMAT_TAR:
return archive_read_support_format_tar(a);
break;
case ARCHIVE_FORMAT_XAR:
return archive_read_support_format_xar(a);
break;
case ARCHIVE_FORMAT_ZIP:
return archive_read_support_format_zip(a);
break;
}
return (ARCHIVE_FATAL);
}
static void verify(unsigned char *d, size_t s,
void (*f1)(struct archive *, struct archive_entry *),
void (*f2)(struct archive *, struct archive_entry *),
enum enc etype)
{
struct archive_entry *ae;
struct archive *a;
unsigned char *buff;
int r;
assert((a = archive_read_new()) != NULL);
switch (etype) {
case BZIP2:
/* This is only check whether bzip is supported or not.
* This filter won't be used this test. */
if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) {
skipping("Unsupported bzip2");
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
break;
case GZIP:
/* This gzip must be needed. archive_read_support_format_xar()
* will return a warning if gzip is unsupported. */
break;
}
assertA(0 == archive_read_support_filter_all(a));
r = archive_read_support_format_xar(a);
if (r == ARCHIVE_WARN) {
skipping("xar reading not fully supported on this platform");
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
assert((buff = malloc(100000)) != NULL);
if (buff == NULL)
return;
memcpy(buff, d, s);
memset(buff + s, 0, 2048);
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_open_memory(a, buff, s + 1024));
assertA(0 == archive_read_next_header(a, &ae));
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_NONE);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_XAR);
/* Verify the only entry. */
f1(a, ae);
if (f2) {
assertA(0 == archive_read_next_header(a, &ae));
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_NONE);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_XAR);
/* Verify the only entry. */
f2(a, ae);
assertEqualInt(2, archive_file_count(a));
} else {
assertEqualInt(1, archive_file_count(a));
}
/* End of archive. */
assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
free(buff);
}
