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);
}
/* Open an outer archive with the given filename. */
static struct archive *open_outer(const char *filename)
{
struct archive *outer;
int r;
outer = archive_read_new();
if (!outer) {
opkg_msg(ERROR, "Failed to create outer archive object.\n");
return NULL;
}
/* Outer package is in 'ar' format, uncompressed. */
r = archive_read_support_format_ar(outer);
if (r != ARCHIVE_OK) {
opkg_msg(ERROR, "Ar format not supported: %s\n",
archive_error_string(outer));
goto err_cleanup;
}
r = archive_read_open_filename(outer, filename, EXTRACT_BUFFER_LEN);
if (r != ARCHIVE_OK) {
opkg_msg(ERROR, "Failed to open package '%s': %s\n", filename,
archive_error_string(outer));
goto err_cleanup;
}
return outer;
err_cleanup:
archive_read_free(outer);
return NULL;
}
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);
}
void archive::applyFormats()
{
int ret = archive_read_support_format_ar(m_archive);
if (ret != ARCHIVE_OK)
{
archive_read_free(m_archive);
m_archive = nullptr;
throw std::runtime_error("libstriezel::ar::archive::applyFormats(): Format not supported!");
}
}
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);
}
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);
}
/*
* Handle read modes: 'x', 't' and 'p'.
*/
static void
read_archive(struct bsdar *bsdar, char mode)
{
struct archive *a;
struct archive_entry *entry;
struct stat sb;
struct tm *tp;
const char *bname;
const char *name;
mode_t md;
size_t size;
time_t mtime;
uid_t uid;
gid_t gid;
char **av;
char buf[25];
char find;
int flags, r, i;
if ((a = archive_read_new()) == NULL)
bsdar_errc(bsdar, EX_SOFTWARE, 0, "archive_read_new failed");
archive_read_support_format_ar(a);
AC(archive_read_open_filename(a, bsdar->filename, DEF_BLKSZ));
for (;;) {
r = archive_read_next_header(a, &entry);
if (r == ARCHIVE_WARN || r == ARCHIVE_RETRY ||
r == ARCHIVE_FATAL)
bsdar_warnc(bsdar, archive_errno(a), "%s",
archive_error_string(a));
if (r == ARCHIVE_EOF || r == ARCHIVE_FATAL)
break;
if (r == ARCHIVE_RETRY) {
bsdar_warnc(bsdar, 0, "Retrying...");
continue;
}
if ((name = archive_entry_pathname(entry)) == NULL)
break;
/* Skip pseudo members. */
if (strcmp(name, "/") == 0 || strcmp(name, "//") == 0 ||
strcmp(name, "/SYM64/") == 0)
continue;
if (bsdar->argc > 0) {
find = 0;
for(i = 0; i < bsdar->argc; i++) {
av = &bsdar->argv[i];
if (*av == NULL)
continue;
if ((bname = basename(*av)) == NULL)
bsdar_errc(bsdar, EX_SOFTWARE, errno,
"basename failed");
if (strcmp(bname, name) != 0)
continue;
*av = NULL;
find = 1;
break;
}
if (!find)
continue;
}
if (mode == 't') {
if (bsdar->options & AR_V) {
md = archive_entry_mode(entry);
uid = archive_entry_uid(entry);
gid = archive_entry_gid(entry);
size = archive_entry_size(entry);
mtime = archive_entry_mtime(entry);
(void)strmode(md, buf);
(void)fprintf(stdout, "%s %6d/%-6d %8ju ",
buf + 1, uid, gid, (uintmax_t)size);
tp = localtime(&mtime);
(void)strftime(buf, sizeof(buf),
"%b %e %H:%M %Y", tp);
(void)fprintf(stdout, "%s %s", buf, name);
} else
(void)fprintf(stdout, "%s", name);
r = archive_read_data_skip(a);
if (r == ARCHIVE_WARN || r == ARCHIVE_RETRY ||
r == ARCHIVE_FATAL) {
(void)fprintf(stdout, "\n");
bsdar_warnc(bsdar, archive_errno(a), "%s",
archive_error_string(a));
}
if (r == ARCHIVE_FATAL)
break;
(void)fprintf(stdout, "\n");
} else {
/* mode == 'x' || mode = 'p' */
if (mode == 'p') {
if (bsdar->options & AR_V) {
(void)fprintf(stdout, "\n<%s>\n\n",
name);
fflush(stdout);
}
r = archive_read_data_into_fd(a, 1);
} else {
/* mode == 'x' */
if (stat(name, &sb) != 0) {
if (errno != ENOENT) {
bsdar_warnc(bsdar, 0,
"stat %s failed",
bsdar->filename);
continue;
}
} else {
/* stat success, file exist */
if (bsdar->options & AR_CC)
continue;
if (bsdar->options & AR_U &&
archive_entry_mtime(entry) <=
sb.st_mtime)
continue;
}
if (bsdar->options & AR_V)
(void)fprintf(stdout, "x - %s\n", name);
/* Disallow absolute paths. */
if (name[0] == '/') {
bsdar_warnc(bsdar, 0,
"Absolute path '%s'", name);
continue;
}
/* Basic path security flags. */
flags = ARCHIVE_EXTRACT_SECURE_SYMLINKS |
ARCHIVE_EXTRACT_SECURE_NODOTDOT;
if (bsdar->options & AR_O)
flags |= ARCHIVE_EXTRACT_TIME;
r = archive_read_extract(a, entry, flags);
}
if (r)
bsdar_warnc(bsdar, archive_errno(a), "%s",
archive_error_string(a));
}
}
AC(archive_read_close(a));
AC(archive_read_free(a));
}
int
main(int argc, char **argv)
{
struct archive *a1;
struct archive *a2;
struct archive_entry *e1;
struct archive_entry *e2;
const char *tc;
char *buf1;
char *buf2;
char checkcont;
char checklen;
char checkname;
char checksize;
char checktime;
char a1end;
size_t size1;
size_t size2;
int opt, r;
/*
* Parse command line options.
*/
checkcont = 0;
checklen = 0;
checkname = 0;
checksize = 0;
checktime = 0;
tc = NULL;
while ((opt = getopt(argc, argv, "cilnst:")) != -1) {
switch(opt) {
case 'c':
checkcont = 1;
break;
case 'i':
checktime = 1;
break;
case 'l':
checklen = 1;
break;
case 'n':
checkname = 1;
break;
case 's':
checksize = 1;
case 't':
tc = optarg;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc != 2)
usage();
/* Open file 1 */
a1 = archive_read_new();
archive_read_support_format_ar(a1);
if (archive_read_open_filename(a1, argv[0],
1024*10)) {
warnx("%s", archive_error_string(a1));
filediff(tc, "archive open failed", NULL);
}
/* Open file 2 */
a2 = archive_read_new();
archive_read_support_format_ar(a2);
if (archive_read_open_filename(a2, argv[1],
1024*10)) {
warnx("%s", archive_error_string(a2));
filediff(tc, "archive open failed", NULL);
}
/* Main loop */
a1end = 0;
size1 = 0;
size2 = 0;
for (;;) {
/*
* Read header from each archive, compare length.
*/
r = archive_read_next_header(a1, &e1);
if (r == ARCHIVE_EOF)
a1end = 1;
if (r == ARCHIVE_WARN || r == ARCHIVE_RETRY ||
r == ARCHIVE_FATAL) {
warnx("%s", archive_error_string(a1));
filediff(tc, "archive data error", NULL);
}
r = archive_read_next_header(a2, &e2);
if (r == ARCHIVE_EOF) {
if (a1end > 0)
break;
else {
if (checklen)
filediff(tc, "length differ", NULL);
break;
}
}
if (r == ARCHIVE_WARN || r == ARCHIVE_RETRY ||
r == ARCHIVE_FATAL) {
warnx("%s", archive_error_string(a2));
filediff(tc, "archive data error", NULL);
}
if (a1end > 0) {
if (checklen)
filediff(tc, "length differ", NULL);
break;
}
/*
* Check member name if required.
*/
if (checkname) {
if (strcmp(archive_entry_pathname(e1),
archive_entry_pathname(e2)) != 0)
filediff(tc, "member name differ",
archive_entry_pathname(e1));
}
/*
* Compare time if required.
*/
if (checktime) {
if (archive_entry_mtime(e1) !=
archive_entry_mtime(e2))
filediff(tc, "member mtime differ",
archive_entry_pathname(e1));
}
/*
* Compare member size if required.
*/
if (checksize || checkcont) {
size1 = (size_t) archive_entry_size(e1);
size2 = (size_t) archive_entry_size(e2);
if (size1 != size2)
filediff(tc, "member size differ",
archive_entry_pathname(e1));
}
/*
* Compare member content if required.
*/
if (checkcont) {
if ((buf1 = malloc(size1)) == NULL)
filediff(tc, "not enough memory", NULL);
if ((buf2 = malloc(size2)) == NULL)
filediff(tc, "not enough memory", NULL);
if ((size_t) archive_read_data(a1, buf1, size1) !=
size1)
filediff(tc, "archive_read_data failed",
archive_entry_pathname(e1));
if ((size_t) archive_read_data(a2, buf2, size2) !=
size2)
filediff(tc, "archive_read_data failed",
archive_entry_pathname(e1));
if (memcmp(buf1, buf2, size1) != 0)
filediff(tc, "member content differ",
archive_entry_pathname(e1));
free(buf1);
free(buf2);
}
/* Proceed to next header. */
}
/* Passed! */
filesame(tc);
exit(EXIT_SUCCESS);
}
/*
* Handle read modes: 'x', 't' and 'p'.
*/
void
ar_read_archive(struct bsdar *bsdar, int mode)
{
FILE *out;
struct archive *a;
struct archive_entry *entry;
struct stat sb;
struct tm *tp;
const char *bname;
const char *name;
mode_t md;
size_t size;
time_t mtime;
uid_t uid;
gid_t gid;
char **av;
char buf[25];
char find;
int i, flags, r;
assert(mode == 'p' || mode == 't' || mode == 'x');
if ((a = archive_read_new()) == NULL)
bsdar_errc(bsdar, 0, "archive_read_new failed");
archive_read_support_compression_none(a);
archive_read_support_format_ar(a);
AC(archive_read_open_file(a, bsdar->filename, DEF_BLKSZ));
out = bsdar->output;
for (;;) {
r = archive_read_next_header(a, &entry);
if (r == ARCHIVE_WARN || r == ARCHIVE_RETRY ||
r == ARCHIVE_FATAL)
bsdar_warnc(bsdar, 0, "%s", archive_error_string(a));
if (r == ARCHIVE_EOF || r == ARCHIVE_FATAL)
break;
if (r == ARCHIVE_RETRY) {
bsdar_warnc(bsdar, 0, "Retrying...");
continue;
}
if (archive_format(a) == ARCHIVE_FORMAT_AR_BSD)
bsdar->options |= AR_BSD;
else
bsdar->options &= ~AR_BSD;
name = archive_entry_pathname(entry);
/* Skip pseudo members. */
if (bsdar_is_pseudomember(bsdar, name))
continue;
if (bsdar->argc > 0) {
find = 0;
for(i = 0; i < bsdar->argc; i++) {
av = &bsdar->argv[i];
if (*av == NULL)
continue;
if ((bname = basename(*av)) == NULL)
bsdar_errc(bsdar, errno,
"basename failed");
if (strcmp(bname, name) != 0)
continue;
*av = NULL;
find = 1;
break;
}
if (!find)
continue;
}
if (mode == 't') {
if (bsdar->options & AR_V) {
md = archive_entry_mode(entry);
uid = archive_entry_uid(entry);
gid = archive_entry_gid(entry);
size = archive_entry_size(entry);
mtime = archive_entry_mtime(entry);
(void)fprintf(out, "%s %6d/%-6d %8ju ",
bsdar_strmode(md) + 1, uid, gid,
(uintmax_t)size);
tp = localtime(&mtime);
(void)strftime(buf, sizeof(buf),
"%b %e %H:%M %Y", tp);
(void)fprintf(out, "%s %s", buf, name);
} else
(void)fprintf(out, "%s", name);
r = archive_read_data_skip(a);
if (r == ARCHIVE_WARN || r == ARCHIVE_RETRY ||
r == ARCHIVE_FATAL) {
(void)fprintf(out, "\n");
bsdar_warnc(bsdar, 0, "%s",
archive_error_string(a));
}
if (r == ARCHIVE_FATAL)
break;
(void)fprintf(out, "\n");
} else {
/* mode == 'x' || mode = 'p' */
if (mode == 'p') {
if (bsdar->options & AR_V) {
(void)fprintf(out, "\n<%s>\n\n",
name);
fflush(out);
}
r = archive_read_data_into_fd(a, fileno(out));
} else {
/* mode == 'x' */
if (stat(name, &sb) != 0) {
if (errno != ENOENT) {
bsdar_warnc(bsdar, 0,
"stat %s failed",
bsdar->filename);
continue;
}
} else {
/* stat success, file exist */
if (bsdar->options & AR_CC)
continue;
if (bsdar->options & AR_U &&
archive_entry_mtime(entry) <=
sb.st_mtime)
continue;
}
if (bsdar->options & AR_V)
(void)fprintf(out, "x - %s\n", name);
flags = 0;
if (bsdar->options & AR_O)
flags |= ARCHIVE_EXTRACT_TIME;
r = archive_read_extract(a, entry, flags);
}
if (r)
bsdar_warnc(bsdar, 0, "%s",
archive_error_string(a));
}
}
AC(archive_read_close(a));
ACV(archive_read_finish(a));
}
