/*
* Verify that KOI8-R filenames are not translated to Unicode and UTF-8
* when using hdrcharset=BINARY option.
*/
static void
test_pax_filename_encoding_KOI8R_BINARY(void)
{
struct archive *a;
struct archive_entry *entry;
char buff[4096];
size_t used;
if (NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
skipping("KOI8-R locale not available on this system.");
return;
}
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_pax(a));
/* BINARY mode should be accepted. */
assertEqualInt(ARCHIVE_OK,
archive_write_set_options(a, "hdrcharset=BINARY"));
assertEqualInt(ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
entry = archive_entry_new2(a);
archive_entry_set_pathname(entry, "\xD0\xD2\xC9");
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_size(entry, 0);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* "hdrcharset=BINARY" pax attribute should be written. */
assertEqualMem(buff + 512, "21 hdrcharset=BINARY\x0A", 21);
/* Above three characters in KOI8-R should not translate to any
* character-set. */
assertEqualMem(buff + 512+21, "12 path=\xD0\xD2\xC9\x0A", 12);
}
static void
verify_zip_filesize(uint64_t size, int expected)
{
struct archive *a;
struct archive_entry *ae;
char buff[256];
size_t used;
/* Zip format: Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a));
/* Disable Zip64 extensions. */
assertEqualIntA(a, ARCHIVE_OK,
archive_write_set_format_option(a, "zip", "zip64", NULL));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_pathname(ae, "test");
archive_entry_set_mode(ae, AE_IFREG | 0644);
archive_entry_set_size(ae, size);
assertEqualInt(expected, archive_write_header(a, ae));
archive_entry_free(ae);
/* Don't actually write 4GB! ;-) */
assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
}
static void
test_big_entries(int (*set_format)(struct archive *), int64_t size, int expected)
{
struct archive_entry *ae;
struct archive *a;
size_t buffsize = 1000000;
size_t used;
char *buff;
buff = malloc(buffsize);
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertA(0 == (*set_format)(a));
assertA(0 == archive_write_add_filter_none(a));
assertA(0 == archive_write_open_memory(a, buff, buffsize, &used));
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, "file");
archive_entry_set_size(ae, size);
archive_entry_set_filetype(ae, AE_IFREG);
assertEqualInt(expected, archive_write_header(a, ae));
if (expected != ARCHIVE_OK)
assert(archive_error_string(a) != NULL);
archive_entry_free(ae);
archive_write_free(a);
free(buff);
}
/*
* Verify that CP932/SJIS filenames are correctly translated to Unicode and UTF-8.
*/
static void
test_pax_filename_encoding_CP932(void)
{
struct archive *a;
struct archive_entry *entry;
char buff[4096];
size_t used;
if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
skipping("eucJP locale not available on this system.");
return;
}
/* Check if the paltform completely supports the string conversion. */
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_pax(a));
if (archive_write_set_options(a, "hdrcharset=UTF-8") != ARCHIVE_OK) {
skipping("This system cannot convert character-set"
" from CP932/SJIS to UTF-8.");
archive_write_free(a);
return;
}
archive_write_free(a);
/* Re-create a write archive object since filenames should be written
* in UTF-8 by default. */
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_pax(a));
assertEqualInt(ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
entry = archive_entry_new2(a);
archive_entry_set_pathname(entry, "\x95\x5C.txt");
/* Check the Unicode version. */
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_size(entry, 0);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Check UTF-8 version. */
assertEqualMem(buff + 512, "16 path=\xE8\xA1\xA8.txt\x0A", 16);
}
/*
* Verify that CP1251 filenames are correctly translated to Unicode and UTF-8.
*/
static void
test_pax_filename_encoding_CP1251(void)
{
struct archive *a;
struct archive_entry *entry;
char buff[4096];
size_t used;
if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
skipping("KOI8-R locale not available on this system.");
return;
}
/* Check if the paltform completely supports the string conversion. */
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_pax(a));
if (archive_write_set_options(a, "hdrcharset=UTF-8") != ARCHIVE_OK) {
skipping("This system cannot convert character-set"
" from KOI8-R to UTF-8.");
archive_write_free(a);
return;
}
archive_write_free(a);
/* Re-create a write archive object since filenames should be written
* in UTF-8 by default. */
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_pax(a));
assertEqualInt(ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
entry = archive_entry_new2(a);
archive_entry_set_pathname(entry, "\xef\xf0\xe8");
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_size(entry, 0);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Above three characters in KOI8-R should translate to the following
* three characters (two bytes each) in UTF-8. */
assertEqualMem(buff + 512, "15 path=\xD0\xBF\xD1\x80\xD0\xB8\x0A", 15);
}
int test1()
{
struct archive *a = archive_write_new();
int ret = archive_write_set_format_zip(a);
unsigned char buffer[100];
int size;
ret = archive_write_open_memory(a, buffer, 100, &size);
// add a file
struct archive_entry *entry = archive_entry_new();
archive_entry_set_pathname(entry, "hello.txt");
archive_entry_set_size(entry, 5);
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_perm(entry, 0644);
ret = archive_write_header(a, entry);
printf("archive_write_header: ret=%d\n", ret);
la_ssize_t n = archive_write_data(a, "world", 5);
printf("archive_write_data: n=%d, error=%s\n", n, archive_error_string(a));
// ad another file
//
archive_entry_clear(entry);
archive_entry_set_pathname(entry, "somedir/yo.txt");
archive_entry_set_size(entry, 5);
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_perm(entry, 0644);
archive_write_header(a, entry);
n = archive_write_data(a, "12345", 5);
printf("archive_write_data: n=%d, error=%s\n", n, archive_error_string(a));
archive_entry_free(entry);
ret = archive_write_free(a);
printf("archive_write_free: ret=%d, error=%s\n", ret, archive_error_string(a));
printf("size=%d\n", size);
write(1, buffer, size);
}
/*
* Do not translate CP1251 into CP866 if non Windows platform.
*/
static void
test_zip_filename_encoding_ru_RU_CP1251(void)
{
struct archive *a;
struct archive_entry *entry;
char buff[4096];
size_t used;
if (NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
skipping("Russian_Russia locale not available on this system.");
return;
}
/*
* Verify that CP1251 filenames are not translated into any
* other character-set, in particular, CP866.
*/
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_zip(a));
assertEqualInt(ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
entry = archive_entry_new2(a);
/* Set a CP1251 filename. */
archive_entry_set_pathname(entry, "\xEF\xF0\xE8");
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_size(entry, 0);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* A bit 11 of general purpose flag should be 0,
* which indicates the filename charset is unknown. */
assertEqualInt(0, buff[7]);
/* Above three characters in CP1251 should not translate into
* any other character-set. */
assertEqualMem(buff + 30, "\xEF\xF0\xE8", 3);
}
/*
* Create an entry starting from a wide-character Unicode pathname,
* read it back into "C" locale, which doesn't support the name.
* TODO: Figure out the "right" behavior here.
*/
static void
test_pax_filename_encoding_3(void)
{
wchar_t badname[] = L"xxxAyyyBzzz";
const char badname_utf8[] = "xxx\xE1\x88\xB4yyy\xE5\x99\xB8zzz";
struct archive *a;
struct archive_entry *entry;
char buff[65536];
size_t used;
badname[3] = 0x1234;
badname[7] = 0x5678;
/* If it doesn't exist, just warn and return. */
if (NULL == setlocale(LC_ALL, "C")) {
skipping("Can't set \"C\" locale, so can't exercise "
"certain character-conversion failures");
return;
}
/* If wctomb is broken, warn and return. */
if (wctomb(buff, 0x1234) > 0) {
skipping("Cannot test conversion failures because \"C\" "
"locale on this system has no invalid characters.");
return;
}
/* If wctomb is broken, warn and return. */
if (wctomb(buff, 0x1234) > 0) {
skipping("Cannot test conversion failures because \"C\" "
"locale on this system has no invalid characters.");
return;
}
/* Skip test if archive_entry_update_pathname_utf8() is broken. */
/* In particular, this is currently broken on Win32 because
* setlocale() does not set the default encoding for CP_ACP. */
entry = archive_entry_new();
if (archive_entry_update_pathname_utf8(entry, badname_utf8)) {
archive_entry_free(entry);
skipping("Cannot test conversion failures.");
return;
}
archive_entry_free(entry);
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, 0, archive_write_set_format_pax(a));
assertEqualIntA(a, 0, archive_write_add_filter_none(a));
assertEqualIntA(a, 0, archive_write_set_bytes_per_block(a, 0));
assertEqualInt(0,
archive_write_open_memory(a, buff, sizeof(buff), &used));
assert((entry = archive_entry_new()) != NULL);
/* Set pathname to non-convertible wide value. */
archive_entry_copy_pathname_w(entry, badname);
archive_entry_set_filetype(entry, AE_IFREG);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assert((entry = archive_entry_new()) != NULL);
archive_entry_copy_pathname_w(entry, L"abc");
/* Set gname to non-convertible wide value. */
archive_entry_copy_gname_w(entry, badname);
archive_entry_set_filetype(entry, AE_IFREG);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assert((entry = archive_entry_new()) != NULL);
archive_entry_copy_pathname_w(entry, L"abc");
/* Set uname to non-convertible wide value. */
archive_entry_copy_uname_w(entry, badname);
archive_entry_set_filetype(entry, AE_IFREG);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assert((entry = archive_entry_new()) != NULL);
archive_entry_copy_pathname_w(entry, L"abc");
/* Set hardlink to non-convertible wide value. */
archive_entry_copy_hardlink_w(entry, badname);
archive_entry_set_filetype(entry, AE_IFREG);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assert((entry = archive_entry_new()) != NULL);
archive_entry_copy_pathname_w(entry, L"abc");
/* Set symlink to non-convertible wide value. */
archive_entry_copy_symlink_w(entry, badname);
archive_entry_set_filetype(entry, AE_IFLNK);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now read the entries back.
*/
assert((a = archive_read_new()) != NULL);
assertEqualInt(0, archive_read_support_format_tar(a));
assertEqualInt(0, archive_read_open_memory(a, buff, used));
failure("A non-convertible pathname should cause a warning.");
assertEqualInt(ARCHIVE_WARN, archive_read_next_header(a, &entry));
assertEqualWString(badname, archive_entry_pathname_w(entry));
failure("If native locale can't convert, we should get UTF-8 back.");
assertEqualString(badname_utf8, archive_entry_pathname(entry));
failure("A non-convertible gname should cause a warning.");
assertEqualInt(ARCHIVE_WARN, archive_read_next_header(a, &entry));
assertEqualWString(badname, archive_entry_gname_w(entry));
failure("If native locale can't convert, we should get UTF-8 back.");
assertEqualString(badname_utf8, archive_entry_gname(entry));
failure("A non-convertible uname should cause a warning.");
assertEqualInt(ARCHIVE_WARN, archive_read_next_header(a, &entry));
assertEqualWString(badname, archive_entry_uname_w(entry));
failure("If native locale can't convert, we should get UTF-8 back.");
assertEqualString(badname_utf8, archive_entry_uname(entry));
failure("A non-convertible hardlink should cause a warning.");
assertEqualInt(ARCHIVE_WARN, archive_read_next_header(a, &entry));
assertEqualWString(badname, archive_entry_hardlink_w(entry));
failure("If native locale can't convert, we should get UTF-8 back.");
assertEqualString(badname_utf8, archive_entry_hardlink(entry));
failure("A non-convertible symlink should cause a warning.");
assertEqualInt(ARCHIVE_WARN, archive_read_next_header(a, &entry));
assertEqualWString(badname, archive_entry_symlink_w(entry));
assertEqualWString(NULL, archive_entry_hardlink_w(entry));
failure("If native locale can't convert, we should get UTF-8 back.");
assertEqualString(badname_utf8, archive_entry_symlink(entry));
assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &entry));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/*
* Set the locale and write a pathname containing invalid characters.
* This should work; the underlying implementation should automatically
* fall back to storing the pathname in binary.
*/
static void
test_pax_filename_encoding_2(void)
{
char filename[] = "abc\314\214mno\374xyz";
struct archive *a;
struct archive_entry *entry;
char buff[65536];
char longname[] = "abc\314\214mno\374xyz"
"/abc\314\214mno\374xyz/abcdefghijklmnopqrstuvwxyz"
"/abc\314\214mno\374xyz/abcdefghijklmnopqrstuvwxyz"
"/abc\314\214mno\374xyz/abcdefghijklmnopqrstuvwxyz"
"/abc\314\214mno\374xyz/abcdefghijklmnopqrstuvwxyz"
"/abc\314\214mno\374xyz/abcdefghijklmnopqrstuvwxyz"
"/abc\314\214mno\374xyz/abcdefghijklmnopqrstuvwxyz"
;
size_t used;
/*
* We need a starting locale which has invalid sequences.
* en_US.UTF-8 seems to be commonly supported.
*/
/* If it doesn't exist, just warn and return. */
if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
skipping("invalid encoding tests require a suitable locale;"
" en_US.UTF-8 not available on this system");
return;
}
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, 0, archive_write_set_format_pax(a));
assertEqualIntA(a, 0, archive_write_add_filter_none(a));
assertEqualIntA(a, 0, archive_write_set_bytes_per_block(a, 0));
assertEqualInt(0,
archive_write_open_memory(a, buff, sizeof(buff), &used));
assert((entry = archive_entry_new()) != NULL);
/* Set pathname, gname, uname, hardlink to nonconvertible values. */
archive_entry_copy_pathname(entry, filename);
archive_entry_copy_gname(entry, filename);
archive_entry_copy_uname(entry, filename);
archive_entry_copy_hardlink(entry, filename);
archive_entry_set_filetype(entry, AE_IFREG);
failure("This should generate a warning for nonconvertible names.");
assertEqualInt(ARCHIVE_WARN, archive_write_header(a, entry));
archive_entry_free(entry);
assert((entry = archive_entry_new()) != NULL);
/* Set path, gname, uname, and symlink to nonconvertible values. */
archive_entry_copy_pathname(entry, filename);
archive_entry_copy_gname(entry, filename);
archive_entry_copy_uname(entry, filename);
archive_entry_copy_symlink(entry, filename);
archive_entry_set_filetype(entry, AE_IFLNK);
failure("This should generate a warning for nonconvertible names.");
assertEqualInt(ARCHIVE_WARN, archive_write_header(a, entry));
archive_entry_free(entry);
assert((entry = archive_entry_new()) != NULL);
/* Set pathname to a very long nonconvertible value. */
archive_entry_copy_pathname(entry, longname);
archive_entry_set_filetype(entry, AE_IFREG);
failure("This should generate a warning for nonconvertible names.");
assertEqualInt(ARCHIVE_WARN, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now read the entries back.
*/
assert((a = archive_read_new()) != NULL);
assertEqualInt(0, archive_read_support_format_tar(a));
assertEqualInt(0, archive_read_open_memory(a, buff, used));
assertEqualInt(0, archive_read_next_header(a, &entry));
assertEqualString(filename, archive_entry_pathname(entry));
assertEqualString(filename, archive_entry_gname(entry));
assertEqualString(filename, archive_entry_uname(entry));
assertEqualString(filename, archive_entry_hardlink(entry));
assertEqualInt(0, archive_read_next_header(a, &entry));
assertEqualString(filename, archive_entry_pathname(entry));
assertEqualString(filename, archive_entry_gname(entry));
assertEqualString(filename, archive_entry_uname(entry));
assertEqualString(filename, archive_entry_symlink(entry));
assertEqualInt(0, archive_read_next_header(a, &entry));
assertEqualString(longname, archive_entry_pathname(entry));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
static void
test_write_format_mtree_sub(int use_set, int dironly)
{
struct archive_entry *ae;
struct archive* a;
size_t used;
int i;
/* Create a mtree format archive. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
if (use_set)
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_option(a, NULL, "use-set", "1"));
if (dironly)
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_option(a, NULL, "dironly", "1"));
assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff)-1, &used));
/* Write entries */
for (i = 0; entries[i].path != NULL; i++) {
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, entries[i].mtime, 0);
assert(entries[i].mtime == archive_entry_mtime(ae));
archive_entry_set_mode(ae, entries[i].mode);
assert(entries[i].mode == archive_entry_mode(ae));
archive_entry_set_uid(ae, entries[i].uid);
assert(entries[i].uid == archive_entry_uid(ae));
archive_entry_set_gid(ae, entries[i].gid);
assert(entries[i].gid == archive_entry_gid(ae));
archive_entry_copy_pathname(ae, entries[i].path);
if ((entries[i].mode & AE_IFMT) != S_IFDIR)
archive_entry_set_size(ae, 8);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
if ((entries[i].mode & AE_IFMT) != S_IFDIR)
assertEqualIntA(a, 8,
archive_write_data(a, "Hello012", 15));
archive_entry_free(ae);
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
if (use_set) {
const char *p;
buff[used] = '\0';
assert(NULL != (p = strstr(buff, "\n/set ")));
if (p != NULL) {
char *r;
const char *o;
p++;
r = strchr(p, '\n');
if (r != NULL)
*r = '\0';
if (dironly)
o = "/set type=dir uid=1001 gid=1001 mode=755";
else
o = "/set type=file uid=1001 gid=1001 mode=644";
assertEqualString(o, p);
if (r != NULL)
*r = '\n';
}
}
/*
* Read the data and check it.
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
/* Read entries */
for (i = 0; entries[i].path != NULL; i++) {
if (dironly && (entries[i].mode & AE_IFMT) != S_IFDIR)
continue;
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(entries[i].mtime, archive_entry_mtime(ae));
assertEqualInt(entries[i].mode, archive_entry_mode(ae));
assertEqualInt(entries[i].uid, archive_entry_uid(ae));
assertEqualInt(entries[i].gid, archive_entry_gid(ae));
assertEqualString(entries[i].path, archive_entry_pathname(ae));
if ((entries[i].mode & AE_IFMT) != S_IFDIR)
assertEqualInt(8, archive_entry_size(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
static void
test_write_format_mtree_sub(int use_set)
{
struct archive_entry *ae;
struct archive* a;
size_t used;
int i;
/* Create a mtree format archive. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
if (use_set)
assertEqualIntA(a, ARCHIVE_OK,
archive_write_set_options(a, "use-set,!all,flags,type"));
else
assertEqualIntA(a, ARCHIVE_OK,
archive_write_set_options(a, "!all,flags,type"));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff)-1, &used));
/* Write entries */
for (i = 0; entries[i].path != NULL; i++) {
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_fflags(ae, entries[i].fflags, 0);
archive_entry_copy_pathname(ae, entries[i].path);
archive_entry_set_size(ae, 0);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
if (use_set) {
const char *p;
buff[used] = '\0';
assert(NULL != (p = strstr(buff, "\n/set ")));
if (p != NULL) {
char *r;
const char *o;
p++;
r = strchr(p, '\n');
if (r != NULL)
*r = '\0';
o = "/set type=file flags=uchg,nodump";
assertEqualString(o, p);
if (r != NULL)
*r = '\n';
}
}
/*
* Read the data and check it.
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
/* Read entries */
for (i = 0; entries[i].path != NULL; i++) {
unsigned long fset, fclr;
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
archive_entry_fflags(ae, &fset, &fclr);
assertEqualInt((int)entries[i].fflags, (int)fset);
assertEqualInt(0, (int)fclr);
assertEqualString(entries[i].path, archive_entry_pathname(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
static void
test_format(int (*set_format)(struct archive *))
{
char filedata[64];
struct archive_entry *ae;
struct archive *a;
char *p;
size_t used;
size_t buffsize = 1000000;
char *buff;
int damaged = 0;
buff = malloc(buffsize);
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertA(0 == (*set_format)(a));
assertA(0 == archive_write_set_compression_none(a));
assertA(0 == archive_write_open_memory(a, buff, buffsize, &used));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 10);
assert(1 == archive_entry_mtime(ae));
assert(10 == archive_entry_mtime_nsec(ae));
p = strdup("file");
archive_entry_copy_pathname(ae, p);
strcpy(p, "XXXX");
free(p);
assertEqualString("file", archive_entry_pathname(ae));
archive_entry_set_mode(ae, S_IFREG | 0755);
assert((S_IFREG | 0755) == archive_entry_mode(ae));
archive_entry_set_size(ae, 8);
assertA(0 == archive_write_header(a, ae));
archive_entry_free(ae);
assertA(8 == archive_write_data(a, "12345678", 9));
/*
* Write another file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 10);
assert(1 == archive_entry_mtime(ae));
assert(10 == archive_entry_mtime_nsec(ae));
p = strdup("file2");
archive_entry_copy_pathname(ae, p);
strcpy(p, "XXXX");
free(p);
assertEqualString("file2", archive_entry_pathname(ae));
archive_entry_set_mode(ae, S_IFREG | 0755);
assert((S_IFREG | 0755) == archive_entry_mode(ae));
archive_entry_set_size(ae, 4);
assertA(0 == archive_write_header(a, ae));
archive_entry_free(ae);
assertA(4 == archive_write_data(a, "1234", 5));
/*
* Write a directory to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 11, 110);
archive_entry_copy_pathname(ae, "dir");
archive_entry_set_mode(ae, S_IFDIR | 0755);
archive_entry_set_size(ae, 512);
assertA(0 == archive_write_header(a, ae));
assertEqualInt(0, archive_entry_size(ae));
archive_entry_free(ae);
assertEqualIntA(a, 0, archive_write_data(a, "12345678", 9));
/* Close out the archive. */
assertA(0 == archive_write_close(a));
#if ARCHIVE_API_VERSION > 1
assertA(0 == archive_write_finish(a));
#else
archive_write_finish(a);
#endif
/*
* Damage the second entry to test the search-ahead recovery.
*/
{
int i;
for (i = 80; i < 150; i++) {
if (memcmp(buff + i, "07070", 5) == 0) {
damaged = 1;
buff[i] = 'X';
break;
}
}
}
failure("Unable to locate the second header for damage-recovery test.");
assert(damaged = 1);
/*
* Now, read the data back.
*/
assert((a = archive_read_new()) != NULL);
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_support_compression_all(a));
assertA(0 == archive_read_open_memory(a, buff, used));
assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(ae));
/* Not the same as above: cpio doesn't store hi-res times. */
assert(0 == archive_entry_mtime_nsec(ae));
assert(0 == archive_entry_atime(ae));
assert(0 == archive_entry_ctime(ae));
assertEqualString("file", archive_entry_pathname(ae));
assertEqualInt((S_IFREG | 0755), archive_entry_mode(ae));
assertEqualInt(8, archive_entry_size(ae));
assertA(8 == archive_read_data(a, filedata, 10));
assert(0 == memcmp(filedata, "12345678", 8));
/*
* Read the second file back.
*/
if (!damaged) {
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(ae));
/* Not the same as above: cpio doesn't store hi-res times. */
assert(0 == archive_entry_mtime_nsec(ae));
assert(0 == archive_entry_atime(ae));
assert(0 == archive_entry_ctime(ae));
assertEqualString("file2", archive_entry_pathname(ae));
assert((S_IFREG | 0755) == archive_entry_mode(ae));
assertEqualInt(4, archive_entry_size(ae));
assertEqualIntA(a, 4, archive_read_data(a, filedata, 10));
assert(0 == memcmp(filedata, "1234", 4));
}
/*
* Read the dir entry back.
*/
assertEqualIntA(a,
damaged ? ARCHIVE_WARN : ARCHIVE_OK,
archive_read_next_header(a, &ae));
assertEqualInt(11, archive_entry_mtime(ae));
assert(0 == archive_entry_mtime_nsec(ae));
assert(0 == archive_entry_atime(ae));
assert(0 == archive_entry_ctime(ae));
assertEqualString("dir", archive_entry_pathname(ae));
assertEqualInt((S_IFDIR | 0755), archive_entry_mode(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualIntA(a, 0, archive_read_data(a, filedata, 10));
/* Verify the end of the archive. */
assertEqualIntA(a, 1, archive_read_next_header(a, &ae));
assert(0 == archive_read_close(a));
#if ARCHIVE_API_VERSION > 1
assert(0 == archive_read_finish(a));
#else
archive_read_finish(a);
#endif
free(buff);
}
/*
* Test writing an empty file.
*/
static void
test_only_empty_file(void)
{
struct archive *a;
struct archive_entry *ae;
size_t buffsize = 1000;
char *buff;
size_t used;
buff = malloc(buffsize);
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_7zip(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_open_memory(a, buff, buffsize, &used));
/*
* Write an empty file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 10);
assertEqualInt(1, archive_entry_mtime(ae));
assertEqualInt(10, archive_entry_mtime_nsec(ae));
archive_entry_set_atime(ae, 2, 20);
assertEqualInt(2, archive_entry_atime(ae));
assertEqualInt(20, archive_entry_atime_nsec(ae));
archive_entry_set_ctime(ae, 0, 100);
assertEqualInt(0, archive_entry_ctime(ae));
assertEqualInt(100, archive_entry_ctime_nsec(ae));
archive_entry_copy_pathname(ae, "empty");
assertEqualString("empty", archive_entry_pathname(ae));
archive_entry_set_mode(ae, AE_IFREG | 0755);
assertEqualInt((S_IFREG | 0755), archive_entry_mode(ae));
assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
/* Close out the archive. */
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Verify the archive file size. */
assertEqualInt(102, used);
/* Verify the initial header. */
assertEqualMem(buff,
"\x37\x7a\xbc\xaf\x27\x1c\x00\x03"
"\x00\x5b\x58\x25\x00\x00\x00\x00"
"\x00\x00\x00\x00\x46\x00\x00\x00"
"\x00\x00\x00\x00\x8f\xce\x1d\xf3", 32);
/*
* Now, read the data back.
*/
/* With the test memory reader -- seeking mode. */
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7));
/*
* Read and verify an empty file.
*/
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(ae));
assertEqualInt(0, archive_entry_mtime_nsec(ae));
assertEqualInt(2, archive_entry_atime(ae));
assertEqualInt(0, archive_entry_atime_nsec(ae));
assertEqualInt(0, archive_entry_ctime(ae));
assertEqualInt(100, archive_entry_ctime_nsec(ae));
assertEqualString("empty", archive_entry_pathname(ae));
assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
assertEqualInt(0, archive_entry_size(ae));
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
/* Verify archive format. */
assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a));
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
free(buff);
}
static void
test_large(const char *compression_type)
{
struct archive_entry *ae;
struct archive *a;
size_t used;
size_t buffsize = LARGE_SIZE + 1024 * 256;
size_t datasize = LARGE_SIZE;
char *buff, *filedata, *filedata2;
unsigned i;
assert((buff = malloc(buffsize)) != NULL);
assert((filedata = malloc(datasize)) != NULL);
assert((filedata2 = malloc(datasize)) != NULL);
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
if (a == NULL || buff == NULL || filedata == NULL || filedata2 == NULL) {
archive_write_free(a);
free(buff);
free(filedata);
free(filedata2);
return;
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_7zip(a));
if (compression_type != NULL &&
ARCHIVE_OK != archive_write_set_format_option(a, "7zip",
"compression", compression_type)) {
skipping("%s writing not fully supported on this platform",
compression_type);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
free(buff);
free(filedata);
free(filedata2);
return;
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_open_memory(a, buff, buffsize, &used));
/*
* Write a large file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 100);
assertEqualInt(1, archive_entry_mtime(ae));
assertEqualInt(100, archive_entry_mtime_nsec(ae));
archive_entry_copy_pathname(ae, "file");
assertEqualString("file", archive_entry_pathname(ae));
archive_entry_set_mode(ae, AE_IFREG | 0755);
assertEqualInt((AE_IFREG | 0755), archive_entry_mode(ae));
archive_entry_set_size(ae, datasize);
assertEqualInt(0, archive_write_header(a, ae));
archive_entry_free(ae);
if (strcmp(compression_type, "ppmd") == 0) {
/* NOTE: PPMd cannot handle random data correctly.*/
memset(filedata, 'a', datasize);
} else {
for (i = 0; i < datasize; i++)
filedata[i] = (char)rand();
}
assertEqualInt(datasize, archive_write_data(a, filedata, datasize));
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Verify the initial header. */
assertEqualMem(buff, "\x37\x7a\xbc\xaf\x27\x1c\x00\x03", 8);
/*
* Now, read the data back.
*/
/* With the test memory reader -- seeking mode. */
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7));
/*
* Read and verify a large file.
*/
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(ae));
assertEqualInt(100, archive_entry_mtime_nsec(ae));
assertEqualInt(0, archive_entry_atime(ae));
assertEqualInt(0, archive_entry_ctime(ae));
assertEqualString("file", archive_entry_pathname(ae));
assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
assertEqualInt(datasize, archive_entry_size(ae));
assertEqualIntA(a, datasize, archive_read_data(a, filedata2, datasize));
assertEqualMem(filedata, filedata2, datasize);
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
/* Verify archive format. */
assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a));
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
free(buff);
free(filedata);
free(filedata2);
}
static void
test_filename(const char *prefix, int dlen, int flen)
{
char buff[8192];
char filename[400];
char dirname[400];
struct archive_entry *ae;
struct archive *a;
size_t used;
char *p;
int i;
p = filename;
if (prefix) {
strcpy(filename, prefix);
p += strlen(p);
}
if (dlen > 0) {
for (i = 0; i < dlen; i++)
*p++ = 'a';
*p++ = '/';
}
for (i = 0; i < flen; i++)
*p++ = 'b';
*p = '\0';
strcpy(dirname, filename);
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertA(0 == archive_write_set_format_pax_restricted(a));
assertA(0 == archive_write_set_compression_none(a));
assertA(0 == archive_write_set_bytes_per_block(a,0));
assertA(0 == archive_write_open_memory(a, buff, sizeof(buff), &used));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, filename);
archive_entry_set_mode(ae, S_IFREG | 0755);
failure("Pathname %d/%d", dlen, flen);
assertA(0 == archive_write_header(a, ae));
archive_entry_free(ae);
/*
* Write a dir to it (without trailing '/').
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, dirname);
archive_entry_set_mode(ae, S_IFDIR | 0755);
failure("Dirname %d/%d", dlen, flen);
assertA(0 == archive_write_header(a, ae));
archive_entry_free(ae);
/* Tar adds a '/' to directory names. */
strcat(dirname, "/");
/*
* Write a dir to it (with trailing '/').
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, dirname);
archive_entry_set_mode(ae, S_IFDIR | 0755);
failure("Dirname %d/%d", dlen, flen);
assertA(0 == archive_write_header(a, ae));
archive_entry_free(ae);
/* Close out the archive. */
assertA(0 == archive_write_close(a));
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_write_finish(a);
#else
assertA(0 == archive_write_finish(a));
#endif
/*
* Now, read the data back.
*/
assert((a = archive_read_new()) != NULL);
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_support_compression_all(a));
assertA(0 == archive_read_open_memory(a, buff, used));
/* Read the file and check the filename. */
assertA(0 == archive_read_next_header(a, &ae));
#if ARCHIVE_VERSION_NUMBER < 1009000
skipping("Leading '/' preserved on long filenames");
#else
assertEqualString(filename, archive_entry_pathname(ae));
#endif
assertEqualInt((S_IFREG | 0755), archive_entry_mode(ae));
/*
* Read the two dirs and check the names.
*
* Both dirs should read back with the same name, since
* tar should add a trailing '/' to any dir that doesn't
* already have one. We only report the first such failure
* here.
*/
assertA(0 == archive_read_next_header(a, &ae));
#if ARCHIVE_VERSION_NUMBER < 1009000
skipping("Trailing '/' preserved on dirnames");
#else
assertEqualString(dirname, archive_entry_pathname(ae));
#endif
assert((S_IFDIR | 0755) == archive_entry_mode(ae));
assertA(0 == archive_read_next_header(a, &ae));
#if ARCHIVE_VERSION_NUMBER < 1009000
skipping("Trailing '/' added to dir names");
#else
assertEqualString(dirname, archive_entry_pathname(ae));
#endif
assert((S_IFDIR | 0755) == archive_entry_mode(ae));
/* Verify the end of the archive. */
assert(1 == archive_read_next_header(a, &ae));
assert(0 == archive_read_close(a));
#if ARCHIVE_VERSION_NUMBER < 2000000
archive_read_finish(a);
#else
assert(0 == archive_read_finish(a));
#endif
}
static void
test_format(int (*set_format)(struct archive *))
{
char filedata[64];
struct archive_entry *ae;
struct archive *a;
char *p;
size_t used;
size_t buffsize = 1000000;
char *buff;
int damaged = 0;
buff = malloc(buffsize);
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertA(0 == (*set_format)(a));
assertA(0 == archive_write_add_filter_none(a));
assertA(0 == archive_write_open_memory(a, buff, buffsize, &used));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 10);
assert(1 == archive_entry_mtime(ae));
assert(10 == archive_entry_mtime_nsec(ae));
p = strdup("file");
archive_entry_copy_pathname(ae, p);
strcpy(p, "XXXX");
free(p);
assertEqualString("file", archive_entry_pathname(ae));
archive_entry_set_mode(ae, S_IFREG | 0755);
assert((S_IFREG | 0755) == archive_entry_mode(ae));
archive_entry_set_size(ae, 8);
assertA(0 == archive_write_header(a, ae));
archive_entry_free(ae);
assertA(8 == archive_write_data(a, "12345678", 9));
/*
* Write another file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 10);
assert(1 == archive_entry_mtime(ae));
assert(10 == archive_entry_mtime_nsec(ae));
p = strdup("file2");
archive_entry_copy_pathname(ae, p);
strcpy(p, "XXXX");
free(p);
assertEqualString("file2", archive_entry_pathname(ae));
archive_entry_set_mode(ae, S_IFREG | 0755);
assert((S_IFREG | 0755) == archive_entry_mode(ae));
archive_entry_set_size(ae, 4);
assertA(0 == archive_write_header(a, ae));
archive_entry_free(ae);
assertA(4 == archive_write_data(a, "1234", 5));
/*
* Write a file with a name, filetype, and size.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, "name");
archive_entry_set_size(ae, 0);
archive_entry_set_filetype(ae, AE_IFREG);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae));
assert(archive_error_string(a) == NULL);
archive_entry_free(ae);
/*
* Write a file with a name and filetype but no size.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, "name");
archive_entry_unset_size(ae);
archive_entry_set_filetype(ae, AE_IFREG);
assertEqualInt(ARCHIVE_FAILED, archive_write_header(a, ae));
assert(archive_error_string(a) != NULL);
archive_entry_free(ae);
/*
* Write a file with a name and size but no filetype.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, "name");
archive_entry_set_size(ae, 0);
assertEqualInt(ARCHIVE_FAILED, archive_write_header(a, ae));
assert(archive_error_string(a) != NULL);
archive_entry_free(ae);
/*
* Write a file with a size and filetype but no name.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_size(ae, 0);
archive_entry_set_filetype(ae, AE_IFREG);
assertEqualInt(ARCHIVE_FAILED, archive_write_header(a, ae));
assert(archive_error_string(a) != NULL);
archive_entry_free(ae);
/*
* Write a directory to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 11, 110);
archive_entry_copy_pathname(ae, "dir");
archive_entry_set_mode(ae, S_IFDIR | 0755);
archive_entry_set_size(ae, 512);
assertA(0 == archive_write_header(a, ae));
assertEqualInt(0, archive_entry_size(ae));
archive_entry_free(ae);
assertEqualIntA(a, 0, archive_write_data(a, "12345678", 9));
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Damage the second entry to test the search-ahead recovery.
* TODO: Move the damage-recovery checking to a separate test;
* it doesn't really belong in this write test.
*/
{
int i;
for (i = 80; i < 150; i++) {
if (memcmp(buff + i, "07070", 5) == 0) {
damaged = 1;
buff[i] = 'X';
break;
}
}
}
failure("Unable to locate the second header for damage-recovery test.");
assert(damaged == 1);
/*
* Now, read the data back.
*/
assert((a = archive_read_new()) != NULL);
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_support_filter_all(a));
assertA(0 == archive_read_open_memory(a, buff, used));
if (!assertEqualIntA(a, 0, archive_read_next_header(a, &ae))) {
archive_read_free(a);
return;
}
assertEqualInt(1, archive_entry_mtime(ae));
/* Not the same as above: cpio doesn't store hi-res times. */
assert(0 == archive_entry_mtime_nsec(ae));
assert(0 == archive_entry_atime(ae));
assert(0 == archive_entry_ctime(ae));
assertEqualString("file", archive_entry_pathname(ae));
assertEqualInt((S_IFREG | 0755), archive_entry_mode(ae));
assertEqualInt(8, archive_entry_size(ae));
assertA(8 == archive_read_data(a, filedata, 10));
assertEqualMem(filedata, "12345678", 8);
/*
* The second file can't be read because we damaged its header.
*/
/*
* Read the third file back.
* ARCHIVE_WARN here because the damaged entry was skipped.
*/
assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
assertEqualString("name", archive_entry_pathname(ae));
/*
* Read the dir entry back.
*/
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(11, archive_entry_mtime(ae));
assert(0 == archive_entry_mtime_nsec(ae));
assert(0 == archive_entry_atime(ae));
assert(0 == archive_entry_ctime(ae));
assertEqualString("dir", archive_entry_pathname(ae));
assertEqualInt((S_IFDIR | 0755), archive_entry_mode(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualIntA(a, 0, archive_read_data(a, filedata, 10));
/* Verify the end of the archive. */
assertEqualIntA(a, 1, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
free(buff);
}
static void
test_basic2(const char *compression_type)
{
char filedata[64];
struct archive_entry *ae;
struct archive *a;
size_t used;
size_t buffsize = 1000;
char *buff;
buff = malloc(buffsize);
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_7zip(a));
if (compression_type != NULL &&
ARCHIVE_OK != archive_write_set_format_option(a, "7zip",
"compression", compression_type)) {
skipping("%s writing not fully supported on this platform",
compression_type);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
free(buff);
return;
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_open_memory(a, buff, buffsize, &used));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 100);
assertEqualInt(1, archive_entry_mtime(ae));
assertEqualInt(100, archive_entry_mtime_nsec(ae));
archive_entry_copy_pathname(ae, "file");
assertEqualString("file", archive_entry_pathname(ae));
archive_entry_set_mode(ae, AE_IFREG | 0755);
assertEqualInt((AE_IFREG | 0755), archive_entry_mode(ae));
archive_entry_set_size(ae, 8);
assertEqualInt(0, archive_write_header(a, ae));
archive_entry_free(ae);
assertEqualInt(8, archive_write_data(a, "12345678", 9));
assertEqualInt(0, archive_write_data(a, "1", 1));
/*
* Write another file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 10);
assertEqualInt(1, archive_entry_mtime(ae));
assertEqualInt(10, archive_entry_mtime_nsec(ae));
archive_entry_copy_pathname(ae, "file2");
assertEqualString("file2", archive_entry_pathname(ae));
archive_entry_set_mode(ae, AE_IFREG | 0755);
assertEqualInt((AE_IFREG | 0755), archive_entry_mode(ae));
archive_entry_set_size(ae, 4);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
assertEqualInt(4, archive_write_data(a, "1234", 5));
/*
* Write a directory to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 11, 100);
archive_entry_copy_pathname(ae, "dir");
archive_entry_set_mode(ae, AE_IFDIR | 0755);
archive_entry_set_size(ae, 512);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
failure("size should be zero so that applications know not to write");
assertEqualInt(0, archive_entry_size(ae));
archive_entry_free(ae);
assertEqualIntA(a, 0, archive_write_data(a, "12345678", 9));
/*
* Write a sub directory to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 11, 200);
archive_entry_copy_pathname(ae, "dir/subdir");
archive_entry_set_mode(ae, AE_IFDIR | 0755);
archive_entry_set_size(ae, 512);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
failure("size should be zero so that applications know not to write");
assertEqualInt(0, archive_entry_size(ae));
archive_entry_free(ae);
assertEqualIntA(a, 0, archive_write_data(a, "12345678", 9));
/*
* Write a sub sub-directory to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 11, 300);
archive_entry_copy_pathname(ae, "dir/subdir/subdir");
archive_entry_set_mode(ae, AE_IFDIR | 0755);
archive_entry_set_size(ae, 512);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
failure("size should be zero so that applications know not to write");
assertEqualInt(0, archive_entry_size(ae));
archive_entry_free(ae);
assertEqualIntA(a, 0, archive_write_data(a, "12345678", 9));
/* Close out the archive. */
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Verify the initial header. */
assertEqualMem(buff, "\x37\x7a\xbc\xaf\x27\x1c\x00\x03", 8);
/*
* Now, read the data back.
*/
/* With the test memory reader -- seeking mode. */
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK, read_open_memory_seek(a, buff, used, 7));
/*
* Read and verify first file.
*/
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(ae));
assertEqualInt(100, archive_entry_mtime_nsec(ae));
assertEqualInt(0, archive_entry_atime(ae));
assertEqualInt(0, archive_entry_ctime(ae));
assertEqualString("file", archive_entry_pathname(ae));
assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
assertEqualInt(8, archive_entry_size(ae));
assertEqualIntA(a, 8,
archive_read_data(a, filedata, sizeof(filedata)));
assertEqualMem(filedata, "12345678", 8);
/*
* Read the second file back.
*/
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(ae));
assertEqualInt(0, archive_entry_mtime_nsec(ae));
assertEqualInt(0, archive_entry_atime(ae));
assertEqualInt(0, archive_entry_ctime(ae));
assertEqualString("file2", archive_entry_pathname(ae));
assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
assertEqualInt(4, archive_entry_size(ae));
assertEqualIntA(a, 4,
archive_read_data(a, filedata, sizeof(filedata)));
assertEqualMem(filedata, "1234", 4);
/*
* Read the sub sub-dir entry back.
*/
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(11, archive_entry_mtime(ae));
assertEqualInt(300, archive_entry_mtime_nsec(ae));
assertEqualInt(0, archive_entry_atime(ae));
assertEqualInt(0, archive_entry_ctime(ae));
assertEqualString("dir/subdir/subdir/", archive_entry_pathname(ae));
assertEqualInt(AE_IFDIR | 0755, archive_entry_mode(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualIntA(a, 0, archive_read_data(a, filedata, 10));
/*
* Read the sub dir entry back.
*/
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(11, archive_entry_mtime(ae));
assertEqualInt(200, archive_entry_mtime_nsec(ae));
assertEqualInt(0, archive_entry_atime(ae));
assertEqualInt(0, archive_entry_ctime(ae));
assertEqualString("dir/subdir/", archive_entry_pathname(ae));
assertEqualInt(AE_IFDIR | 0755, archive_entry_mode(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualIntA(a, 0, archive_read_data(a, filedata, 10));
/*
* Read the dir entry back.
*/
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(11, archive_entry_mtime(ae));
assertEqualInt(100, archive_entry_mtime_nsec(ae));
assertEqualInt(0, archive_entry_atime(ae));
assertEqualInt(0, archive_entry_ctime(ae));
assertEqualString("dir/", archive_entry_pathname(ae));
assertEqualInt(AE_IFDIR | 0755, archive_entry_mode(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualIntA(a, 0, archive_read_data(a, filedata, 10));
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
/* Verify archive format. */
assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a));
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
free(buff);
}
static void
test_zip_filename_encoding_UTF8(void)
{
struct archive *a;
struct archive_entry *entry;
char buff[4096];
size_t used;
if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
skipping("en_US.UTF-8 locale not available on this system.");
return;
}
/*
* Verify that UTF-8 filenames are correctly stored with
* hdrcharset=UTF-8 option.
*/
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_zip(a));
if (archive_write_set_options(a, "hdrcharset=UTF-8") != ARCHIVE_OK) {
skipping("This system cannot convert character-set"
" for UTF-8.");
archive_write_free(a);
return;
}
assertEqualInt(ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
entry = archive_entry_new2(a);
/* Set a UTF-8 filename. */
archive_entry_set_pathname(entry, "\xD0\xBF\xD1\x80\xD0\xB8");
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_size(entry, 0);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* A bit 11 of general purpose flag should be 0x08,
* which indicates the filename charset is UTF-8. */
assertEqualInt(0x08, buff[7]);
assertEqualMem(buff + 30, "\xD0\xBF\xD1\x80\xD0\xB8", 6);
/*
* Verify that UTF-8 filenames are correctly stored without
* hdrcharset=UTF-8 option.
*/
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_zip(a));
assertEqualInt(ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
entry = archive_entry_new2(a);
/* Set a UTF-8 filename. */
archive_entry_set_pathname(entry, "\xD0\xBF\xD1\x80\xD0\xB8");
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_size(entry, 0);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* A bit 11 of general purpose flag should be 0x08,
* which indicates the filename charset is UTF-8. */
assertEqualInt(0x08, buff[7]);
assertEqualMem(buff + 30, "\xD0\xBF\xD1\x80\xD0\xB8", 6);
/*
* Verify that A bit 11 of general purpose flag is not set
* when ASCII filenames are stored.
*/
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_zip(a));
assertEqualInt(ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
entry = archive_entry_new2(a);
/* Set an ASCII filename. */
archive_entry_set_pathname(entry, "abcABC");
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_size(entry, 0);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* A bit 11 of general purpose flag should be 0,
* which indicates the filename charset is unknown. */
assertEqualInt(0, buff[7]);
assertEqualMem(buff + 30, "abcABC", 6);
}
static void
test_zip_filename_encoding_KOI8R(void)
{
struct archive *a;
struct archive_entry *entry;
char buff[4096];
size_t used;
if (NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
skipping("KOI8-R locale not available on this system.");
return;
}
/*
* Verify that KOI8-R filenames are correctly translated to UTF-8.
*/
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_zip(a));
if (archive_write_set_options(a, "hdrcharset=UTF-8") != ARCHIVE_OK) {
skipping("This system cannot convert character-set"
" from KOI8-R to UTF-8.");
archive_write_free(a);
return;
}
assertEqualInt(ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
entry = archive_entry_new2(a);
/* Set a KOI8-R filename. */
archive_entry_set_pathname(entry, "\xD0\xD2\xC9");
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_size(entry, 0);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* A bit 11 of general purpose flag should be 0x08,
* which indicates the filename charset is UTF-8. */
assertEqualInt(0x08, buff[7]);
/* Above three characters in KOI8-R should translate to the following
* three characters (two bytes each) in UTF-8. */
assertEqualMem(buff + 30, "\xD0\xBF\xD1\x80\xD0\xB8", 6);
/*
* Verify that KOI8-R filenames are not translated to UTF-8.
*/
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_zip(a));
assertEqualInt(ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
entry = archive_entry_new2(a);
/* Set a KOI8-R filename. */
archive_entry_set_pathname(entry, "\xD0\xD2\xC9");
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_size(entry, 0);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* A bit 11 of general purpose flag should be 0,
* which indicates the filename charset is unknown. */
assertEqualInt(0, buff[7]);
/* Above three characters in KOI8-R should not translate to
* any character-set. */
assertEqualMem(buff + 30, "\xD0\xD2\xC9", 3);
/*
* Verify that A bit 11 of general purpose flag is not set
* when ASCII filenames are stored even if hdrcharset=UTF-8
* is specified.
*/
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_zip(a));
if (archive_write_set_options(a, "hdrcharset=UTF-8") != ARCHIVE_OK) {
skipping("This system cannot convert character-set"
" from KOI8-R to UTF-8.");
archive_write_free(a);
return;
}
assertEqualInt(ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
entry = archive_entry_new2(a);
/* Set an ASCII filename. */
archive_entry_set_pathname(entry, "abcABC");
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_size(entry, 0);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* A bit 11 of general purpose flag should be 0,
* which indicates the filename charset is unknown. */
assertEqualInt(0, buff[7]);
assertEqualMem(buff + 30, "abcABC", 6);
}
static void
test_format_by_name(const char *format_name, const char *compression_type,
int format_id, int dot_stored, const void *image, size_t image_size)
{
struct archive_entry *ae;
struct archive *a;
size_t used;
size_t buffsize = 1024 * 1024;
char *buff;
int r;
assert((buff = malloc(buffsize)) != NULL);
if (buff == NULL)
return;
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
r = archive_write_set_format_by_name(a, format_name);
if (r == ARCHIVE_WARN) {
skipping("%s format not fully supported on this platform",
compression_type);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
free(buff);
return;
}
assertEqualIntA(a, ARCHIVE_OK, r);
if (compression_type != NULL &&
ARCHIVE_OK != archive_write_set_format_option(a, format_name,
"compression", compression_type)) {
skipping("%s writing not fully supported on this platform",
compression_type);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
free(buff);
return;
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_open_memory(a, buff, buffsize, &used));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 0);
assertEqualInt(1, archive_entry_mtime(ae));
archive_entry_set_ctime(ae, 1, 0);
assertEqualInt(1, archive_entry_ctime(ae));
archive_entry_set_atime(ae, 1, 0);
assertEqualInt(1, archive_entry_atime(ae));
archive_entry_copy_pathname(ae, "file");
assertEqualString("file", archive_entry_pathname(ae));
archive_entry_set_mode(ae, AE_IFREG | 0755);
assertEqualInt((AE_IFREG | 0755), archive_entry_mode(ae));
archive_entry_set_size(ae, 8);
assertEqualInt(0, archive_write_header(a, ae));
archive_entry_free(ae);
assertEqualInt(8, archive_write_data(a, "12345678", 8));
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
if (image && image_size > 0) {
assertEqualMem(buff, image, image_size);
}
if (format_id > 0) {
/*
* Now, read the data back.
*/
/* With the test memory reader -- seeking mode. */
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK,
read_open_memory_seek(a, buff, used, 7));
if (dot_stored & 1) {
assertEqualIntA(a, ARCHIVE_OK,
archive_read_next_header(a, &ae));
assertEqualString(".", archive_entry_pathname(ae));
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
}
/*
* Read and verify the file.
*/
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(ae));
if (dot_stored & 2) {
assertEqualString("./file", archive_entry_pathname(ae));
} else {
assertEqualString("file", archive_entry_pathname(ae));
}
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
assertEqualInt(8, archive_entry_size(ae));
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
/* Verify archive format. */
assertEqualIntA(a, ARCHIVE_FILTER_NONE,
archive_filter_code(a, 0));
assertEqualIntA(a, format_id, archive_format(a));
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
free(buff);
}
/*
* Other archiver applications on Windows translate CP1251 filenames
* into CP866 filenames and store it in the zip file.
* Test above behavior works well.
*/
static void
test_zip_filename_encoding_Russian_Russia(void)
{
struct archive *a;
struct archive_entry *entry;
char buff[4096];
size_t used;
if (NULL == setlocale(LC_ALL, "Russian_Russia")) {
skipping("Russian_Russia locale not available on this system.");
return;
}
/*
* Verify that Russian_Russia(CP1251) filenames are correctly translated
* to UTF-8.
*/
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_zip(a));
if (archive_write_set_options(a, "hdrcharset=UTF-8") != ARCHIVE_OK) {
skipping("This system cannot convert character-set"
" from Russian_Russia.CP1251 to UTF-8.");
archive_write_free(a);
return;
}
assertEqualInt(ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
entry = archive_entry_new2(a);
/* Set a CP1251 filename. */
archive_entry_set_pathname(entry, "\xEF\xF0\xE8");
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_size(entry, 0);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* A bit 11 of general purpose flag should be 0x08,
* which indicates the filename charset is UTF-8. */
assertEqualInt(0x08, buff[7]);
/* Above three characters in CP1251 should translate to the following
* three characters (two bytes each) in UTF-8. */
assertEqualMem(buff + 30, "\xD0\xBF\xD1\x80\xD0\xB8", 6);
/*
* Verify that Russian_Russia(CP1251) filenames are correctly translated
* to CP866.
*/
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_zip(a));
assertEqualInt(ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
entry = archive_entry_new2(a);
/* Set a CP1251 filename. */
archive_entry_set_pathname(entry, "\xEF\xF0\xE8");
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_size(entry, 0);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* A bit 11 of general purpose flag should be 0,
* which indicates the filename charset is unknown. */
assertEqualInt(0, buff[7]);
/* Above three characters in CP1251 should translate to the following
* three characters in CP866. */
assertEqualMem(buff + 30, "\xAF\xE0\xA8", 3);
}
static void
test_zip_filename_encoding_CP932(void)
{
struct archive *a;
struct archive_entry *entry;
char buff[4096];
size_t used;
if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
skipping("CP932/SJIS locale not available on this system.");
return;
}
/*
* Verify that EUC-JP filenames are correctly translated to UTF-8.
*/
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_zip(a));
if (archive_write_set_options(a, "hdrcharset=UTF-8") != ARCHIVE_OK) {
skipping("This system cannot convert character-set"
" from CP932/SJIS to UTF-8.");
archive_write_free(a);
return;
}
assertEqualInt(ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
entry = archive_entry_new2(a);
/* Set a CP932/SJIS filename. */
archive_entry_set_pathname(entry, "\x95\x5C.txt");
/* Check the Unicode version. */
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_size(entry, 0);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* A bit 11 of general purpose flag should be 0x08,
* which indicates the filename charset is UTF-8. */
assertEqualInt(0x08, buff[7]);
/* Check UTF-8 version. */
assertEqualMem(buff + 30, "\xE8\xA1\xA8.txt", 7);
/*
* Verify that CP932/SJIS filenames are not translated to UTF-8.
*/
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_zip(a));
assertEqualInt(ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
entry = archive_entry_new2(a);
/* Set a CP932/SJIS filename. */
archive_entry_set_pathname(entry, "\x95\x5C.txt");
/* Check the Unicode version. */
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_size(entry, 0);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* A bit 11 of general purpose flag should be 0,
* which indicates the filename charset is unknown. */
assertEqualInt(0, buff[7]);
/* Above three characters in CP932/SJIS should not translate to
* any character-set. */
assertEqualMem(buff + 30, "\x95\x5C.txt", 6);
/*
* Verify that A bit 11 of general purpose flag is not set
* when ASCII filenames are stored even if hdrcharset=UTF-8
* is specified.
*/
a = archive_write_new();
assertEqualInt(ARCHIVE_OK, archive_write_set_format_zip(a));
if (archive_write_set_options(a, "hdrcharset=UTF-8") != ARCHIVE_OK) {
skipping("This system cannot convert character-set"
" from CP932/SJIS to UTF-8.");
archive_write_free(a);
return;
}
assertEqualInt(ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
entry = archive_entry_new2(a);
/* Set an ASCII filename. */
archive_entry_set_pathname(entry, "abcABC");
/* Check the Unicode version. */
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_size(entry, 0);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* A bit 11 of general purpose flag should be 0,
* which indicates the filename charset is unknown. */
assertEqualInt(0, buff[7]);
assertEqualMem(buff + 30, "abcABC", 6);
}
static void
test_1(void)
{
struct archive_entry *ae;
struct archive *a;
size_t used;
size_t blocksize;
int64_t offset, length;
char *buff2;
size_t buff2_size = 0x13000;
char buff3[1024];
long i;
assert((buff2 = malloc(buff2_size)) != NULL);
/* Repeat the following for a variety of odd blocksizes. */
for (blocksize = 1; blocksize < 100000; blocksize += blocksize + 3) {
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK,
archive_write_set_format_pax(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_set_compression_none(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_set_bytes_per_block(a, (int)blocksize));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_set_bytes_in_last_block(a, (int)blocksize));
assertEqualInt(blocksize,
archive_write_get_bytes_in_last_block(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_open_memory(a, buff, sizeof(buff), &used));
assertEqualInt(blocksize,
archive_write_get_bytes_in_last_block(a));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 10);
assertEqualInt(1, archive_entry_mtime(ae));
assertEqualInt(10, archive_entry_mtime_nsec(ae));
archive_entry_copy_pathname(ae, "file");
assertEqualString("file", archive_entry_pathname(ae));
archive_entry_set_mode(ae, S_IFREG | 0755);
assertEqualInt(S_IFREG | 0755, archive_entry_mode(ae));
archive_entry_set_size(ae, 0x81000);
archive_entry_sparse_add_entry(ae, 0x10000, 0x1000);
archive_entry_sparse_add_entry(ae, 0x80000, 0x1000);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
memset(buff2, 'a', buff2_size);
for (i = 0; i < 0x81000;) {
size_t ws = buff2_size;
if (i + ws > 0x81000)
ws = 0x81000 - i;
assertEqualInt(ws,
archive_write_data(a, buff2, ws));
i += ws;
}
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* This calculation gives "the smallest multiple of
* the block size that is at least 11264 bytes". */
failure("blocksize=%d", blocksize);
assertEqualInt(((11264 - 1)/blocksize+1)*blocksize, used);
/*
* Now, read the data back.
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, buff, used));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(ae));
assertEqualInt(10, archive_entry_mtime_nsec(ae));
assertEqualInt(0, archive_entry_atime(ae));
assertEqualInt(0, archive_entry_ctime(ae));
assertEqualString("file", archive_entry_pathname(ae));
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
assertEqualInt(0x81000, archive_entry_size(ae));
/* Verify sparse information. */
assertEqualInt(2, archive_entry_sparse_reset(ae));
assertEqualInt(0,
archive_entry_sparse_next(ae, &offset, &length));
assertEqualInt(0x10000, offset);
assertEqualInt(0x1000, length);
assertEqualInt(0,
archive_entry_sparse_next(ae, &offset, &length));
assertEqualInt(0x80000, offset);
assertEqualInt(0x1000, length);
/* Verify file contents. */
memset(buff3, 0, sizeof(buff3));
for (i = 0; i < 0x10000; i += 1024) {
assertEqualInt(1024, archive_read_data(a, buff2, 1024));
failure("Read data(0x%lx - 0x%lx) should be all zero",
i, i + 1024);
assertEqualMem(buff2, buff3, 1024);
}
memset(buff3, 'a', sizeof(buff3));
for (i = 0x10000; i < 0x11000; i += 1024) {
assertEqualInt(1024, archive_read_data(a, buff2, 1024));
failure("Read data(0x%lx - 0x%lx) should be all 'a'",
i, i + 1024);
assertEqualMem(buff2, buff3, 1024);
}
memset(buff3, 0, sizeof(buff3));
for (i = 0x11000; i < 0x80000; i += 1024) {
assertEqualInt(1024, archive_read_data(a, buff2, 1024));
failure("Read data(0x%lx - 0x%lx) should be all zero",
i, i + 1024);
assertEqualMem(buff2, buff3, 1024);
}
memset(buff3, 'a', sizeof(buff3));
for (i = 0x80000; i < 0x81000; i += 1024) {
assertEqualInt(1024, archive_read_data(a, buff2, 1024));
failure("Read data(0x%lx - 0x%lx) should be all 'a'",
i, i + 1024);
assertEqualMem(buff2, buff3, 1024);
}
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF,
archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
free(buff2);
}
static void
test_format(int (*set_format)(struct archive *))
{
char filedata[64];
struct archive_entry *ae;
struct archive *a;
size_t used;
size_t buffsize = 1000000;
char *buff;
const char *err;
buff = malloc(buffsize);
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, (*set_format)(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_pathname(ae, "test");
archive_entry_set_filetype(ae, AE_IFREG);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
assertEqualIntA(a, 9, archive_write_data(a, "12345678", 9));
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Read from it.
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_raw(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_none(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualIntA(a, 9, archive_read_data(a, filedata, 10));
assertEqualMem(filedata, "12345678", 9);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/* Create a new archive */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, (*set_format)(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used));
/* write first file: that should succeed */
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_pathname(ae, "test");
archive_entry_set_filetype(ae, AE_IFREG);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
assertEqualIntA(a, 9, archive_write_data(a, "12345678", 9));
/* write second file: this should fail */
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_pathname(ae, "test2");
archive_entry_set_filetype(ae, AE_IFREG);
assertEqualIntA(a, ARCHIVE_FATAL, archive_write_header(a, ae));
err = archive_error_string(a);
assertEqualMem(err, "Raw format only supports one entry per archive", 47);
archive_entry_free(ae);
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Create a new archive */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, (*set_format)(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_add_filter_none(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used));
/* write a directory: this should fail */
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, "dir");
archive_entry_set_filetype(ae, AE_IFDIR);
archive_entry_set_size(ae, 512);
assertEqualIntA(a, ARCHIVE_FATAL, archive_write_header(a, ae));
err = archive_error_string(a);
assertEqualMem(err, "Raw format only supports filetype AE_IFREG", 43);
archive_entry_free(ae);
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
free(buff);
}
static void
test_filter_by_name(const char *filter_name, int filter_code,
int (*can_filter_prog)(void))
{
struct archive_entry *ae;
struct archive *a;
size_t used;
size_t buffsize = 1024 * 128;
char *buff;
int r;
assert((buff = malloc(buffsize)) != NULL);
if (buff == NULL)
return;
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
r = archive_write_add_filter_by_name(a, filter_name);
if (r == ARCHIVE_WARN) {
if (!can_filter_prog()) {
skipping("%s filter not suported on this platform",
filter_name);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
free(buff);
return;
}
} else if (r == ARCHIVE_FATAL &&
(strcmp(archive_error_string(a),
"lzma compression not supported on this platform") == 0 ||
strcmp(archive_error_string(a),
"xz compression not supported on this platform") == 0)) {
skipping("%s filter not suported on this platform", filter_name);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
free(buff);
return;
} else {
if (!assertEqualIntA(a, ARCHIVE_OK, r)) {
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
free(buff);
return;
}
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_bytes_per_block(a, 10));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_open_memory(a, buff, buffsize, &used));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 0);
assertEqualInt(1, archive_entry_mtime(ae));
archive_entry_set_ctime(ae, 1, 0);
assertEqualInt(1, archive_entry_ctime(ae));
archive_entry_set_atime(ae, 1, 0);
assertEqualInt(1, archive_entry_atime(ae));
archive_entry_copy_pathname(ae, "file");
assertEqualString("file", archive_entry_pathname(ae));
archive_entry_set_mode(ae, AE_IFREG | 0755);
assertEqualInt((AE_IFREG | 0755), archive_entry_mode(ae));
archive_entry_set_size(ae, 8);
assertEqualInt(0, archive_write_header(a, ae));
archive_entry_free(ae);
assertEqualInt(8, archive_write_data(a, "12345678", 8));
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now, read the data back.
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
/*
* Read and verify the file.
*/
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(ae));
assertEqualString("file", archive_entry_pathname(ae));
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
assertEqualInt(8, archive_entry_size(ae));
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
/* Verify archive format. */
assertEqualIntA(a, filter_code, archive_filter_code(a, 0));
assertEqualIntA(a, ARCHIVE_FORMAT_TAR_USTAR, archive_format(a));
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
free(buff);
}
static void
test_options(const char *options)
{
struct archive_entry *ae;
struct archive* a;
char *buff, *data;
size_t buffsize, datasize;
char path[16];
size_t used1;
int i, r, use_prog = 0, filecount;
assert((a = archive_write_new()) != NULL);
r = archive_write_add_filter_lz4(a);
if (archive_liblz4_version() == NULL) {
if (!canLz4()) {
skipping("lz4 writing not supported on this platform");
assertEqualInt(ARCHIVE_WARN, r);
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
return;
} else {
assertEqualInt(ARCHIVE_WARN, r);
use_prog = 1;
}
} else {
assertEqualInt(ARCHIVE_OK, r);
}
buffsize = 2000000;
assert(NULL != (buff = (char *)malloc(buffsize)));
datasize = 10000;
assert(NULL != (data = (char *)calloc(1, datasize)));
filecount = 10;
/*
* Write a filecount files and read them all back.
*/
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
archive_write_add_filter_lz4(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_set_options(a, options));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_set_bytes_per_block(a, 1024));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_set_bytes_in_last_block(a, 1024));
assertEqualInt(ARCHIVE_FILTER_LZ4, archive_filter_code(a, 0));
assertEqualString("lz4", archive_filter_name(a, 0));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_open_memory(a, buff, buffsize, &used1));
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_filetype(ae, AE_IFREG);
archive_entry_set_size(ae, datasize);
for (i = 0; i < filecount; i++) {
sprintf(path, "file%03d", i);
archive_entry_copy_pathname(ae, path);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
assertA(datasize
== (size_t)archive_write_data(a, data, datasize));
}
archive_entry_free(ae);
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
r = archive_read_support_filter_lz4(a);
if (r == ARCHIVE_WARN) {
skipping("Can't verify lz4 writing by reading back;"
" lz4 reading not fully supported on this platform");
} else {
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_memory(a, buff, used1));
for (i = 0; i < filecount; i++) {
sprintf(path, "file%03d", i);
if (!assertEqualInt(ARCHIVE_OK,
archive_read_next_header(a, &ae)))
break;
assertEqualString(path, archive_entry_pathname(ae));
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Clean up.
*/
free(data);
free(buff);
}
static void
test_filename(const char *prefix, int dlen, int flen)
{
char buff[8192];
char filename[400];
char dirname[400];
struct archive_entry *ae;
struct archive *a;
size_t used;
int separator = 0;
int i = 0;
if (prefix != NULL) {
strcpy(filename, prefix);
i = (int)strlen(prefix);
}
if (dlen > 0) {
for (; i < dlen; i++)
filename[i] = 'a';
filename[i++] = '/';
separator = 1;
}
for (; i < dlen + flen + separator; i++)
filename[i] = 'b';
filename[i] = '\0';
strcpy(dirname, filename);
/* Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertA(0 == archive_write_set_format_ustar(a));
assertA(0 == archive_write_add_filter_none(a));
assertA(0 == archive_write_set_bytes_per_block(a,0));
assertA(0 == archive_write_open_memory(a, buff, sizeof(buff), &used));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, filename);
archive_entry_set_mode(ae, S_IFREG | 0755);
failure("dlen=%d, flen=%d", dlen, flen);
if (flen > 100) {
assertEqualIntA(a, ARCHIVE_FAILED, archive_write_header(a, ae));
} else {
assertEqualIntA(a, 0, archive_write_header(a, ae));
}
archive_entry_free(ae);
/*
* Write a dir to it (without trailing '/').
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, dirname);
archive_entry_set_mode(ae, S_IFDIR | 0755);
failure("dlen=%d, flen=%d", dlen, flen);
if (flen >= 100) {
assertEqualIntA(a, ARCHIVE_FAILED, archive_write_header(a, ae));
} else {
assertEqualIntA(a, 0, archive_write_header(a, ae));
}
archive_entry_free(ae);
/* Tar adds a '/' to directory names. */
strcat(dirname, "/");
/*
* Write a dir to it (with trailing '/').
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, dirname);
archive_entry_set_mode(ae, S_IFDIR | 0755);
failure("dlen=%d, flen=%d", dlen, flen);
if (flen >= 100) {
assertEqualIntA(a, ARCHIVE_FAILED, archive_write_header(a, ae));
} else {
assertEqualIntA(a, 0, archive_write_header(a, ae));
}
archive_entry_free(ae);
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now, read the data back.
*/
assert((a = archive_read_new()) != NULL);
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_support_filter_all(a));
assertA(0 == archive_read_open_memory(a, buff, used));
if (flen <= 100) {
/* Read the file and check the filename. */
assertA(0 == archive_read_next_header(a, &ae));
failure("dlen=%d, flen=%d", dlen, flen);
assertEqualString(filename, archive_entry_pathname(ae));
assertEqualInt((S_IFREG | 0755), archive_entry_mode(ae));
}
/*
* Read the two dirs and check the names.
*
* Both dirs should read back with the same name, since
* tar should add a trailing '/' to any dir that doesn't
* already have one.
*/
if (flen <= 99) {
assertA(0 == archive_read_next_header(a, &ae));
assert((S_IFDIR | 0755) == archive_entry_mode(ae));
failure("dlen=%d, flen=%d", dlen, flen);
assertEqualString(dirname, archive_entry_pathname(ae));
}
if (flen <= 99) {
assertA(0 == archive_read_next_header(a, &ae));
assert((S_IFDIR | 0755) == archive_entry_mode(ae));
assertEqualString(dirname, archive_entry_pathname(ae));
}
/* Verify the end of the archive. */
failure("This fails if entries were written that should not have been written. dlen=%d, flen=%d", dlen, flen);
assertEqualInt(1, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
static int
create_iso_image(unsigned char *buff, size_t buffsize, size_t *used,
const char *opt)
{
struct archive *a;
int i, l, fcnt;
const int lens[] = {
0, 1, 3, 5, 7, 8, 9, 29, 30, 31, 32,
62, 63, 64, 65, 101, 102, 103, 104,
191, 192, 193, 194, 204, 205, 206, 207, 208,
252, 253, 254, 255,
-1 };
char fname1[256];
char fname2[256];
char sym1[2];
char sym128[129];
char sym255[256];
/* ISO9660 format: Create a new archive in memory. */
assert((a = archive_write_new()) != NULL);
assertA(0 == archive_write_set_format_iso9660(a));
assertA(0 == archive_write_add_filter_none(a));
assertA(0 == archive_write_set_option(a, NULL, "pad", NULL));
if (opt)
assertA(0 == archive_write_set_options(a, opt));
assertA(0 == archive_write_set_bytes_per_block(a, 1));
assertA(0 == archive_write_set_bytes_in_last_block(a, 1));
assertA(0 == archive_write_open_memory(a, buff, buffsize, used));
sym1[0] = 'x';
sym1[1] = '\0';
for (i = 0; i < (int)sizeof(sym128)-2; i++)
sym128[i] = 'a';
sym128[sizeof(sym128)-2] = 'x';
sym128[sizeof(sym128)-1] = '\0';
for (i = 0; i < (int)sizeof(sym255)-2; i++)
sym255[i] = 'a';
sym255[sizeof(sym255)-2] = 'x';
sym255[sizeof(sym255)-1] = '\0';
fcnt = 0;
for (i = 0; lens[i] >= 0; i++) {
for (l = 0; l < lens[i]; l++) {
fname1[l] = 'a';
fname2[l] = 'A';
}
if (l > 0) {
fname1[l] = '\0';
fname2[l] = '\0';
add_entry(a, fname1, NULL);
add_entry(a, fname2, sym1);
fcnt += 2;
}
if (l < 254) {
fname1[l] = '.';
fname1[l+1] = 'c';
fname1[l+2] = '\0';
fname2[l] = '.';
fname2[l+1] = 'C';
fname2[l+2] = '\0';
add_entry(a, fname1, sym128);
add_entry(a, fname2, sym255);
fcnt += 2;
}
if (l < 252) {
fname1[l] = '.';
fname1[l+1] = 'p';
fname1[l+2] = 'n';
fname1[l+3] = 'g';
fname1[l+4] = '\0';
fname2[l] = '.';
fname2[l+1] = 'P';
fname2[l+2] = 'N';
fname2[l+3] = 'G';
fname2[l+4] = '\0';
add_entry(a, fname1, NULL);
add_entry(a, fname2, sym1);
fcnt += 2;
}
if (l < 251) {
fname1[l] = '.';
fname1[l+1] = 'j';
fname1[l+2] = 'p';
fname1[l+3] = 'e';
fname1[l+4] = 'g';
fname1[l+5] = '\0';
fname2[l] = '.';
fname2[l+1] = 'J';
fname2[l+2] = 'P';
fname2[l+3] = 'E';
fname2[l+4] = 'G';
fname2[l+5] = '\0';
add_entry(a, fname1, sym128);
add_entry(a, fname2, sym255);
fcnt += 2;
}
}
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
return (fcnt);
}