From 3ad46d07830bba44c479e2d19ce376212e52e9af Mon Sep 17 00:00:00 2001 From: Martin Matuska Date: Wed, 16 Dec 2020 22:25:40 +0000 Subject: MFC r368207,368607: MFC r368207: Update libarchive to 3.5.0 Relevant vendor changes: Issue #1258: add archive_read_support_filter_by_code() PR #1347: mtree digest reader support Issue #1381: skip hardlinks pointing to itself on extraction PR #1387: fix writing of cpio archives with hardlinks without file type PR #1388: fix rdev field in cpio format for device nodes PR #1389: completed support for UTF-8 encoding conversion PR #1405: more formats in archive_read_support_format_by_code() PR #1408: fix uninitialized size in rar5_read_data PR #1409: system extended attribute support PR #1435: support for decompression of symbolic links in zipx archives Issue #1456: memory leak after unsuccessful archive_write_open_filename MFC r368607: Sync libarchive with vendor. Vendor changes: Issue #1461: Unbreak build without lzma Issue #1462: warc reader: Fix build with gcc11 Issue #1463: Fix code compatibility in test_archive_read_support.c Issue #1464: Use built-in strnlen on platforms where not available Issue #1465: warc reader: fix undefined behaviour in deconst() function --- .../test/test_archive_read_next_header_empty.c | 26 +++++-- .../libarchive/test/test_archive_read_support.c | 47 ++++++++++++ .../test/test_archive_string_conversion.c | 79 ++++++++++++++++++- contrib/libarchive/libarchive/test/test_entry.c | 89 +++++++++++++++++++++- .../test/test_read_disk_directory_traversals.c | 2 + .../libarchive/test/test_read_format_mtree.c | 74 +++++++++++++++++- .../test/test_read_format_mtree.mtree.uu | 22 +++++- .../libarchive/test/test_read_format_raw.c | 5 +- .../libarchive/test/test_read_format_zip.c | 32 ++++++++ .../test/test_read_format_zip_7z_lzma.zip.uu | 45 +++++++++++ .../libarchive/test/test_read_set_format.c | 25 ------ .../libarchive/test/test_write_disk_secure.c | 34 ++++++++- .../libarchive/test/test_write_format_cpio.c | 20 +++++ .../libarchive/test/test_write_format_warc.c | 28 +++++-- 14 files changed, 476 insertions(+), 52 deletions(-) create mode 100644 contrib/libarchive/libarchive/test/test_read_format_zip_7z_lzma.zip.uu (limited to 'contrib/libarchive/libarchive/test') diff --git a/contrib/libarchive/libarchive/test/test_archive_read_next_header_empty.c b/contrib/libarchive/libarchive/test/test_archive_read_next_header_empty.c index f650bccce89b..f43cbd934288 100644 --- a/contrib/libarchive/libarchive/test/test_archive_read_next_header_empty.c +++ b/contrib/libarchive/libarchive/test/test_archive_read_next_header_empty.c @@ -44,14 +44,9 @@ test_empty_file1(void) } static void -test_empty_file2(void) +test_empty_file2_check(struct archive* a) { - struct archive* a = archive_read_new(); struct archive_entry* e; - - /* Try opening an empty file with raw and empty handlers. */ - assertEqualInt(ARCHIVE_OK, archive_read_support_format_raw(a)); - assertEqualInt(ARCHIVE_OK, archive_read_support_format_empty(a)); assertEqualInt(0, archive_errno(a)); assertEqualString(NULL, archive_error_string(a)); @@ -66,6 +61,25 @@ test_empty_file2(void) archive_read_free(a); } +static void +test_empty_file2(void) +{ + struct archive* a = archive_read_new(); + + /* Try opening an empty file with raw and empty handlers. */ + assertEqualInt(ARCHIVE_OK, archive_read_support_format_raw(a)); + assertEqualInt(ARCHIVE_OK, archive_read_support_format_empty(a)); + test_empty_file2_check(a); + + a = archive_read_new(); + assertEqualInt(ARCHIVE_OK, archive_read_support_format_by_code(a, ARCHIVE_FORMAT_EMPTY)); + test_empty_file2_check(a); + + a = archive_read_new(); + assertEqualInt(ARCHIVE_OK, archive_read_set_format(a, ARCHIVE_FORMAT_EMPTY)); + test_empty_file2_check(a); +} + static void test_empty_tarfile(void) { diff --git a/contrib/libarchive/libarchive/test/test_archive_read_support.c b/contrib/libarchive/libarchive/test/test_archive_read_support.c index 1619b0729e94..6d213c409bf2 100644 --- a/contrib/libarchive/libarchive/test/test_archive_read_support.c +++ b/contrib/libarchive/libarchive/test/test_archive_read_support.c @@ -35,6 +35,17 @@ typedef struct archive *constructor(void); typedef int enabler(struct archive *); typedef int destructor(struct archive *); +static int format_code = 0; +static int format_code_enabler(struct archive *a) +{ + return archive_read_support_format_by_code(a, format_code); +} + +static int format_code_setter(struct archive *a) +{ + return archive_read_set_format(a, format_code); +} + static void test_success(constructor new_, enabler enable_, destructor free_) { @@ -85,6 +96,42 @@ DEFINE_TEST(test_archive_read_support) test_filter_or_format(archive_read_support_format_xar); test_filter_or_format(archive_read_support_format_zip); + int format_codes[] = { + ARCHIVE_FORMAT_CPIO, + ARCHIVE_FORMAT_CPIO_POSIX, + ARCHIVE_FORMAT_CPIO_BIN_LE, + ARCHIVE_FORMAT_CPIO_BIN_BE, + ARCHIVE_FORMAT_CPIO_SVR4_NOCRC, + ARCHIVE_FORMAT_CPIO_SVR4_CRC, + ARCHIVE_FORMAT_CPIO_AFIO_LARGE, + ARCHIVE_FORMAT_TAR, + ARCHIVE_FORMAT_TAR_USTAR, + ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE, + ARCHIVE_FORMAT_TAR_PAX_RESTRICTED, + ARCHIVE_FORMAT_TAR_GNUTAR, + ARCHIVE_FORMAT_ISO9660, + ARCHIVE_FORMAT_ISO9660_ROCKRIDGE, + ARCHIVE_FORMAT_ZIP, + ARCHIVE_FORMAT_EMPTY, + ARCHIVE_FORMAT_AR, + ARCHIVE_FORMAT_AR_GNU, + ARCHIVE_FORMAT_AR_BSD, + ARCHIVE_FORMAT_MTREE, + ARCHIVE_FORMAT_RAW, + ARCHIVE_FORMAT_XAR, + ARCHIVE_FORMAT_LHA, + ARCHIVE_FORMAT_CAB, + ARCHIVE_FORMAT_RAR, + ARCHIVE_FORMAT_7ZIP, + ARCHIVE_FORMAT_WARC, + ARCHIVE_FORMAT_RAR_V5, + }; + for (unsigned i = 0; i < sizeof(format_codes) / sizeof(int); i++) { + format_code = format_codes[i]; + test_filter_or_format(format_code_enabler); + test_filter_or_format(format_code_setter); + } + test_filter_or_format(archive_read_support_filter_all); test_filter_or_format(archive_read_support_filter_bzip2); test_filter_or_format(archive_read_support_filter_compress); diff --git a/contrib/libarchive/libarchive/test/test_archive_string_conversion.c b/contrib/libarchive/libarchive/test/test_archive_string_conversion.c index e86f97c8a492..fb5359b6f349 100644 --- a/contrib/libarchive/libarchive/test/test_archive_string_conversion.c +++ b/contrib/libarchive/libarchive/test/test_archive_string_conversion.c @@ -445,7 +445,7 @@ test_archive_string_normalization_nfc(const char *testdata) assertEqualInt(0, archive_mstring_copy_wcs(&mstr, wc_nfc)); assertEqualInt(0, archive_mstring_get_mbs_l( - &mstr, &mp, &mplen, t_sconv8)); + a, &mstr, &mp, &mplen, t_sconv8)); failure("WCS NFC(%s) should be UTF-8 NFC:%d" ,nfc, line); assertEqualUTF8String(utf8_nfc, mp); @@ -695,7 +695,7 @@ test_archive_string_normalization_mac_nfd(const char *testdata) assertEqualInt(0, archive_mstring_copy_wcs( &mstr, wc_nfd)); assertEqualInt(0, archive_mstring_get_mbs_l( - &mstr, &mp, &mplen, t_sconv8)); + a, &mstr, &mp, &mplen, t_sconv8)); failure("WCS NFD(%s) should be UTF-8 NFD:%d" ,nfd, line); assertEqualUTF8String(utf8_nfd, mp); @@ -777,6 +777,80 @@ test_archive_string_canonicalization(void) } +static void +check_string(struct archive *a, struct archive_mstring *mstr, struct archive_string_conv *sc, + const char *exp, const wchar_t *wexp) +{ + /* Do all the tests on a copy so that we can have a clear initial state every time */ + struct archive_mstring mstr2; + const char *p = NULL; + const wchar_t *wp = NULL; + size_t len = 0; + + memset(&mstr2, 0, sizeof(mstr2)); + + archive_mstring_copy(&mstr2, mstr); + assertEqualInt(0, archive_mstring_get_mbs(a, &mstr2, &p)); + assertEqualString(exp, p); + p = NULL; + + archive_mstring_copy(&mstr2, mstr); + assertEqualInt(0, archive_mstring_get_utf8(a, &mstr2, &p)); + assertEqualString(exp, p); + p = NULL; + + archive_mstring_copy(&mstr2, mstr); + assertEqualInt(0, archive_mstring_get_wcs(a, &mstr2, &wp)); + assertEqualWString(wexp, wp); + wp = NULL; + + archive_mstring_copy(&mstr2, mstr); + assertEqualInt(0, archive_mstring_get_mbs_l(a, &mstr2, &p, &len, sc)); + assertEqualString(exp, p); + assertEqualInt(len, strlen(exp)); + p = NULL; + len = 0; + + archive_mstring_clean(&mstr2); +} + +/* + * Make sure no matter what the input encoding is, the string can be + * converted too all the output encodings. + */ +static void +test_archive_string_set_get(void) +{ + struct archive *a; + struct archive_mstring mstr; + struct archive_string_conv *sc; + + setlocale(LC_ALL, "en_US.UTF-8"); + + assert((a = archive_read_new()) != NULL); + memset(&mstr, 0, sizeof(mstr)); + + assertA(NULL != (sc = + archive_string_conversion_to_charset(a, "UTF-8", 1))); + failure("Charset name should be UTF-8"); + assertEqualString("UTF-8", + archive_string_conversion_charset_name(sc)); + + assertEqualInt(0, archive_mstring_copy_mbs(&mstr, "AAA")); + check_string(a, &mstr, sc, "AAA", L"AAA"); + assertEqualInt(4, archive_mstring_copy_utf8(&mstr, "BBBB")); + check_string(a, &mstr, sc, "BBBB", L"BBBB"); + assertEqualInt(0, archive_mstring_copy_wcs(&mstr, L"CCC12")); + check_string(a, &mstr, sc, "CCC12", L"CCC12"); + assertEqualInt(0, archive_mstring_copy_mbs_len_l(&mstr, "DDDD-l", 6, sc)); + check_string(a, &mstr, sc, "DDDD-l", L"DDDD-l"); + assertEqualInt(0, archive_mstring_update_utf8(a, &mstr, "EEEEE---H")); + check_string(a, &mstr, sc, "EEEEE---H", L"EEEEE---H"); + + assertEqualInt(ARCHIVE_OK, archive_read_free(a)); + +} + DEFINE_TEST(test_archive_string_conversion) { static const char reffile[] = "test_archive_string_conversion.txt.Z"; @@ -807,4 +881,5 @@ DEFINE_TEST(test_archive_string_conversion) test_archive_string_normalization_nfc(testdata); test_archive_string_normalization_mac_nfd(testdata); test_archive_string_canonicalization(); + test_archive_string_set_get(); } diff --git a/contrib/libarchive/libarchive/test/test_entry.c b/contrib/libarchive/libarchive/test/test_entry.c index 3fb17d3645a1..a5777b148711 100644 --- a/contrib/libarchive/libarchive/test/test_entry.c +++ b/contrib/libarchive/libarchive/test/test_entry.c @@ -177,31 +177,60 @@ DEFINE_TEST(test_entry) /* gname */ archive_entry_set_gname(e, "group"); assertEqualString(archive_entry_gname(e), "group"); + assertEqualString(archive_entry_gname_utf8(e), "group"); + assertEqualWString(archive_entry_gname_w(e), L"group"); wcscpy(wbuff, L"wgroup"); archive_entry_copy_gname_w(e, wbuff); assertEqualWString(archive_entry_gname_w(e), L"wgroup"); memset(wbuff, 0, sizeof(wbuff)); assertEqualWString(archive_entry_gname_w(e), L"wgroup"); + assertEqualString(archive_entry_gname_utf8(e), "wgroup"); + assertEqualString(archive_entry_gname(e), "wgroup"); + archive_entry_set_gname_utf8(e, "group"); + assertEqualString(archive_entry_gname_utf8(e), "group"); + assertEqualWString(archive_entry_gname_w(e), L"group"); + assertEqualString(archive_entry_gname(e), "group"); + archive_entry_update_gname_utf8(e, "group2"); + assertEqualString(archive_entry_gname_utf8(e), "group2"); + assertEqualWString(archive_entry_gname_w(e), L"group2"); + assertEqualString(archive_entry_gname(e), "group2"); /* hardlink */ archive_entry_set_hardlink(e, "hardlinkname"); assertEqualString(archive_entry_hardlink(e), "hardlinkname"); + assertEqualString(archive_entry_hardlink_utf8(e), "hardlinkname"); + assertEqualWString(archive_entry_hardlink_w(e), L"hardlinkname"); strcpy(buff, "hardlinkname2"); archive_entry_copy_hardlink(e, buff); assertEqualString(archive_entry_hardlink(e), "hardlinkname2"); + assertEqualWString(archive_entry_hardlink_w(e), L"hardlinkname2"); + assertEqualString(archive_entry_hardlink_utf8(e), "hardlinkname2"); memset(buff, 0, sizeof(buff)); assertEqualString(archive_entry_hardlink(e), "hardlinkname2"); + assertEqualString(archive_entry_hardlink_utf8(e), "hardlinkname2"); + assertEqualWString(archive_entry_hardlink_w(e), L"hardlinkname2"); archive_entry_copy_hardlink(e, NULL); assertEqualString(archive_entry_hardlink(e), NULL); assertEqualWString(archive_entry_hardlink_w(e), NULL); + assertEqualString(archive_entry_hardlink_utf8(e), NULL); wcscpy(wbuff, L"whardlink"); archive_entry_copy_hardlink_w(e, wbuff); assertEqualWString(archive_entry_hardlink_w(e), L"whardlink"); + assertEqualString(archive_entry_hardlink_utf8(e), "whardlink"); + assertEqualString(archive_entry_hardlink(e), "whardlink"); memset(wbuff, 0, sizeof(wbuff)); assertEqualWString(archive_entry_hardlink_w(e), L"whardlink"); archive_entry_copy_hardlink_w(e, NULL); assertEqualString(archive_entry_hardlink(e), NULL); assertEqualWString(archive_entry_hardlink_w(e), NULL); + archive_entry_set_hardlink_utf8(e, "hardlinkname"); + assertEqualString(archive_entry_hardlink_utf8(e), "hardlinkname"); + assertEqualWString(archive_entry_hardlink_w(e), L"hardlinkname"); + assertEqualString(archive_entry_hardlink(e), "hardlinkname"); + archive_entry_update_hardlink_utf8(e, "hardlinkname2"); + assertEqualString(archive_entry_hardlink_utf8(e), "hardlinkname2"); + assertEqualWString(archive_entry_hardlink_w(e), L"hardlinkname2"); + assertEqualString(archive_entry_hardlink(e), "hardlinkname2"); /* ino */ assert(!archive_entry_ino_is_set(e)); @@ -270,18 +299,38 @@ DEFINE_TEST(test_entry) /* pathname */ archive_entry_set_pathname(e, "path"); assertEqualString(archive_entry_pathname(e), "path"); + assertEqualString(archive_entry_pathname_utf8(e), "path"); + assertEqualWString(archive_entry_pathname_w(e), L"path"); archive_entry_set_pathname(e, "path"); assertEqualString(archive_entry_pathname(e), "path"); + assertEqualWString(archive_entry_pathname_w(e), L"path"); + assertEqualString(archive_entry_pathname_utf8(e), "path"); strcpy(buff, "path2"); archive_entry_copy_pathname(e, buff); assertEqualString(archive_entry_pathname(e), "path2"); + assertEqualWString(archive_entry_pathname_w(e), L"path2"); + assertEqualString(archive_entry_pathname_utf8(e), "path2"); memset(buff, 0, sizeof(buff)); assertEqualString(archive_entry_pathname(e), "path2"); + assertEqualString(archive_entry_pathname_utf8(e), "path2"); + assertEqualWString(archive_entry_pathname_w(e), L"path2"); wcscpy(wbuff, L"wpath"); archive_entry_copy_pathname_w(e, wbuff); assertEqualWString(archive_entry_pathname_w(e), L"wpath"); + assertEqualString(archive_entry_pathname_utf8(e), "wpath"); + assertEqualString(archive_entry_pathname(e), "wpath"); memset(wbuff, 0, sizeof(wbuff)); assertEqualWString(archive_entry_pathname_w(e), L"wpath"); + assertEqualString(archive_entry_pathname(e), "wpath"); + assertEqualString(archive_entry_pathname_utf8(e), "wpath"); + archive_entry_set_pathname_utf8(e, "path"); + assertEqualWString(archive_entry_pathname_w(e), L"path"); + assertEqualString(archive_entry_pathname(e), "path"); + assertEqualString(archive_entry_pathname_utf8(e), "path"); + archive_entry_update_pathname_utf8(e, "path2"); + assertEqualWString(archive_entry_pathname_w(e), L"path2"); + assertEqualString(archive_entry_pathname(e), "path2"); + assertEqualString(archive_entry_pathname_utf8(e), "path2"); /* rdev */ archive_entry_set_rdev(e, 532); @@ -302,19 +351,37 @@ DEFINE_TEST(test_entry) /* symlink */ archive_entry_set_symlink(e, "symlinkname"); assertEqualString(archive_entry_symlink(e), "symlinkname"); + assertEqualString(archive_entry_symlink_utf8(e), "symlinkname"); + assertEqualWString(archive_entry_symlink_w(e), L"symlinkname"); strcpy(buff, "symlinkname2"); archive_entry_copy_symlink(e, buff); assertEqualString(archive_entry_symlink(e), "symlinkname2"); + assertEqualWString(archive_entry_symlink_w(e), L"symlinkname2"); + assertEqualString(archive_entry_symlink_utf8(e), "symlinkname2"); memset(buff, 0, sizeof(buff)); assertEqualString(archive_entry_symlink(e), "symlinkname2"); + assertEqualString(archive_entry_symlink_utf8(e), "symlinkname2"); + assertEqualWString(archive_entry_symlink_w(e), L"symlinkname2"); archive_entry_copy_symlink_w(e, NULL); assertEqualWString(archive_entry_symlink_w(e), NULL); assertEqualString(archive_entry_symlink(e), NULL); + assertEqualString(archive_entry_symlink_utf8(e), NULL); archive_entry_copy_symlink_w(e, L"wsymlink"); assertEqualWString(archive_entry_symlink_w(e), L"wsymlink"); + assertEqualString(archive_entry_symlink_utf8(e), "wsymlink"); + assertEqualString(archive_entry_symlink(e), "wsymlink"); archive_entry_copy_symlink(e, NULL); assertEqualWString(archive_entry_symlink_w(e), NULL); assertEqualString(archive_entry_symlink(e), NULL); + assertEqualString(archive_entry_symlink_utf8(e), NULL); + archive_entry_set_symlink_utf8(e, "symlinkname"); + assertEqualWString(archive_entry_symlink_w(e), L"symlinkname"); + assertEqualString(archive_entry_symlink(e), "symlinkname"); + assertEqualString(archive_entry_symlink_utf8(e), "symlinkname"); + archive_entry_update_symlink_utf8(e, "symlinkname2"); + assertEqualWString(archive_entry_symlink_w(e), L"symlinkname2"); + assertEqualString(archive_entry_symlink(e), "symlinkname2"); + assertEqualString(archive_entry_symlink_utf8(e), "symlinkname2"); /* uid */ archive_entry_set_uid(e, 83); @@ -323,11 +390,27 @@ DEFINE_TEST(test_entry) /* uname */ archive_entry_set_uname(e, "user"); assertEqualString(archive_entry_uname(e), "user"); + assertEqualString(archive_entry_uname_utf8(e), "user"); + assertEqualWString(archive_entry_uname_w(e), L"user"); wcscpy(wbuff, L"wuser"); - archive_entry_copy_gname_w(e, wbuff); - assertEqualWString(archive_entry_gname_w(e), L"wuser"); + archive_entry_copy_uname_w(e, wbuff); + assertEqualWString(archive_entry_uname_w(e), L"wuser"); memset(wbuff, 0, sizeof(wbuff)); - assertEqualWString(archive_entry_gname_w(e), L"wuser"); + assertEqualWString(archive_entry_uname_w(e), L"wuser"); + assertEqualString(archive_entry_uname_utf8(e), "wuser"); + assertEqualString(archive_entry_uname(e), "wuser"); + archive_entry_set_uname_utf8(e, "user"); + assertEqualString(archive_entry_uname_utf8(e), "user"); + assertEqualWString(archive_entry_uname_w(e), L"user"); + assertEqualString(archive_entry_uname(e), "user"); + archive_entry_set_uname_utf8(e, "user"); + assertEqualWString(archive_entry_uname_w(e), L"user"); + assertEqualString(archive_entry_uname(e), "user"); + assertEqualString(archive_entry_uname_utf8(e), "user"); + archive_entry_update_uname_utf8(e, "user2"); + assertEqualWString(archive_entry_uname_w(e), L"user2"); + assertEqualString(archive_entry_uname(e), "user2"); + assertEqualString(archive_entry_uname_utf8(e), "user2"); /* Test fflags interface. */ archive_entry_set_fflags(e, 0x55, 0xAA); diff --git a/contrib/libarchive/libarchive/test/test_read_disk_directory_traversals.c b/contrib/libarchive/libarchive/test/test_read_disk_directory_traversals.c index bbfe91ab8e5e..9efa74281b12 100644 --- a/contrib/libarchive/libarchive/test/test_read_disk_directory_traversals.c +++ b/contrib/libarchive/libarchive/test/test_read_disk_directory_traversals.c @@ -1833,6 +1833,8 @@ test_parent(void) } assertChdir(".."); + assertChmod("lock", 0755); + assertChmod("lock/lock2", 0755); /* Destroy the disk object. */ assertEqualInt(ARCHIVE_OK, archive_read_free(a)); diff --git a/contrib/libarchive/libarchive/test/test_read_format_mtree.c b/contrib/libarchive/libarchive/test/test_read_format_mtree.c index 865dda87463b..7e8b5701540c 100644 --- a/contrib/libarchive/libarchive/test/test_read_format_mtree.c +++ b/contrib/libarchive/libarchive/test/test_read_format_mtree.c @@ -196,8 +196,80 @@ test_read_format_mtree1(void) assertEqualInt(archive_entry_is_encrypted(ae), 0); assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED); + /* md5digest */ + assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); + assertEqualString(archive_entry_pathname(ae), "dir2/md5file"); + assertEqualMem(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_MD5), + "\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04\xe9\x80\x09\x98\xec\xf8\x42\x7e", + 16); + + /* rmd160digest */ + assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); + assertEqualString(archive_entry_pathname(ae), "dir2/rmd160file"); + assertEqualMem(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_RMD160), + "\xda\x39\xa3\xee\x5e\x6b\x4b\x0d\x32\x55\xbf\xef\x95\x60\x18\x90" + "\xaf\xd8\x07\x09", 20); + + /* sha1digest */ + assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); + assertEqualString(archive_entry_pathname(ae), "dir2/sha1file"); + assertEqualMem(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_SHA1), + "\xda\x39\xa3\xee\x5e\x6b\x4b\x0d\x32\x55\xbf\xef\x95\x60\x18\x90" + "\xaf\xd8\x07\x09", 20); + + /* sha256digest */ + assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); + assertEqualString(archive_entry_pathname(ae), "dir2/sha256file"); + assertEqualMem(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_SHA256), + "\xe3\xb0\xc4\x42\x98\xfc\x1c\x14\x9a\xfb\xf4\xc8\x99\x6f\xb9\x24" + "\x27\xae\x41\xe4\x64\x9b\x93\x4c\xa4\x95\x99\x1b\x78\x52\xb8\x55", + 32); + + /* sha384digest */ + assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); + assertEqualString(archive_entry_pathname(ae), "dir2/sha384file"); + assertEqualMem(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_SHA384), + "\x38\xb0\x60\xa7\x51\xac\x96\x38\x4c\xd9\x32\x7e\xb1\xb1\xe3\x6a" + "\x21\xfd\xb7\x11\x14\xbe\x07\x43\x4c\x0c\xc7\xbf\x63\xf6\xe1\xda" + "\x27\x4e\xde\xbf\xe7\x6f\x65\xfb\xd5\x1a\xd2\xf1\x48\x98\xb9\x5b", + 48); + + /* sha512digest */ + assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); + assertEqualString(archive_entry_pathname(ae), "dir2/sha512file"); + assertEqualMem(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_SHA512), + "\xcf\x83\xe1\x35\x7e\xef\xb8\xbd\xf1\x54\x28\x50\xd6\x6d\x80\x07" + "\xd6\x20\xe4\x05\x0b\x57\x15\xdc\x83\xf4\xa9\x21\xd3\x6c\xe9\xce" + "\x47\xd0\xd1\x3c\x5d\x85\xf2\xb0\xff\x83\x18\xd2\x87\x7e\xec\x2f" + "\x63\xb9\x31\xbd\x47\x41\x7a\x81\xa5\x38\x32\x7a\xf9\x27\xda\x3e", + 64); + + /* md5 digest is too short */ + assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae)); + assertEqualString(archive_entry_pathname(ae), "dir2/md5tooshort"); + assertMemoryFilledWith(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_MD5), + 16, 0x00); + + /* md5 digest is too long */ + assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae)); + assertEqualString(archive_entry_pathname(ae), "dir2/md5toolong"); + assertMemoryFilledWith(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_MD5), + 16, 0x00); + + /* md5 digest is uppercase hex */ + assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae)); + assertEqualString(archive_entry_pathname(ae), "dir2/md5caphex"); + assertMemoryFilledWith(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_MD5), + 16, 0x00); + + /* md5 digest is not hex */ + assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae)); + assertEqualString(archive_entry_pathname(ae), "dir2/md5nothex"); + assertMemoryFilledWith(archive_entry_digest(ae, ARCHIVE_ENTRY_DIGEST_MD5), + 16, 0x00); + assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae)); - assertEqualInt(20, archive_file_count(a)); + assertEqualInt(30, archive_file_count(a)); assertEqualInt(ARCHIVE_OK, archive_read_close(a)); assertEqualInt(ARCHIVE_OK, archive_read_free(a)); } diff --git a/contrib/libarchive/libarchive/test/test_read_format_mtree.mtree.uu b/contrib/libarchive/libarchive/test/test_read_format_mtree.mtree.uu index a2e47520d353..d45431b72ec9 100644 --- a/contrib/libarchive/libarchive/test/test_read_format_mtree.mtree.uu +++ b/contrib/libarchive/libarchive/test/test_read_format_mtree.mtree.uu @@ -16,6 +16,26 @@ M<&4]9FEL92!S:7IE/3DR,C,S-S(P,S8X-30W-S4X,#<*9&ER,B]T;V]B:6=F M:6QE('1Y<&4]9FEL92!S:7IE/3DR,C,S-S(P,S8X-30W-S4X,#@*9&ER,B]V M97)Y;VQD9FEL92!T>7!E/69I;&4@=&EM93TM.3(R,S,W,C`S-C@U-#7!E/69I;&4@"!T>7!E/69I;&4@ +K;60U9&EG97-T/7$T,60X8V0Y.&8P,&(R,#1E.3@P,#DY.&5C9C@T,C=E"@`` ` end diff --git a/contrib/libarchive/libarchive/test/test_read_format_raw.c b/contrib/libarchive/libarchive/test/test_read_format_raw.c index 1c49c7880018..58a341c02226 100644 --- a/contrib/libarchive/libarchive/test/test_read_format_raw.c +++ b/contrib/libarchive/libarchive/test/test_read_format_raw.c @@ -72,7 +72,7 @@ DEFINE_TEST(test_read_format_raw) extract_reference_file(reffile2); assert((a = archive_read_new()) != NULL); assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); - assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_raw(a)); + assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_by_code(a, ARCHIVE_FORMAT_RAW)); assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, reffile2, 1)); @@ -100,8 +100,7 @@ DEFINE_TEST(test_read_format_raw) extract_reference_file(reffile3); assert((a = archive_read_new()) != NULL); assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a)); - assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_raw(a)); - assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); + assertEqualIntA(a, ARCHIVE_OK, archive_read_set_format(a, ARCHIVE_FORMAT_RAW)); assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, reffile3, 1)); diff --git a/contrib/libarchive/libarchive/test/test_read_format_zip.c b/contrib/libarchive/libarchive/test/test_read_format_zip.c index ab99b0a8d92d..3bb4d7467ac6 100644 --- a/contrib/libarchive/libarchive/test/test_read_format_zip.c +++ b/contrib/libarchive/libarchive/test/test_read_format_zip.c @@ -966,3 +966,35 @@ DEFINE_TEST(test_read_format_zip_lzma_stream_end_blockread) assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); } + +DEFINE_TEST(test_read_format_zip_7z_lzma) +{ + const char *refname = "test_read_format_zip_7z_lzma.zip"; + struct archive_entry *ae; + struct archive *a; + + assert((a = archive_read_new()) != NULL); + if (ARCHIVE_OK != archive_read_support_filter_lzma(a)) { + skipping("lzma reading not fully supported on this platform"); + assertEqualInt(ARCHIVE_OK, archive_read_free(a)); + return; + } + extract_reference_file(refname); + + assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a)); + assertEqualIntA(a, ARCHIVE_OK, + archive_read_open_filename(a, refname, 10240)); + //read directories + assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); + assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); + assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); + assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); + //read symlink + assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae)); + assertEqualInt(AE_IFLNK, archive_entry_filetype(ae)); + assertEqualString("../samples/abc_measurement_analysis_sample" + "/src/abc_measurement_analysis_sample.py", + archive_entry_symlink(ae)); + assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); + assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a)); +} diff --git a/contrib/libarchive/libarchive/test/test_read_format_zip_7z_lzma.zip.uu b/contrib/libarchive/libarchive/test/test_read_format_zip_7z_lzma.zip.uu new file mode 100644 index 000000000000..8ae8df41eaae --- /dev/null +++ b/contrib/libarchive/libarchive/test/test_read_format_zip_7z_lzma.zip.uu @@ -0,0 +1,45 @@ +begin 644 test_read_format_zip_7z_lzma.zip +M4$L#!`H#`````.$#)%$````````````````,````7VENA79\GCDS+I*=O.=!+"5(),_1O%5^1102P,$"@,`````]0,D +M40```````````````"P```!?:6YS=&%L;&1I7-I00]!0!=````!``1B$)'BB,SPW````7VEN7-I7-I7-I7-I