static void
verify(unsigned char *buff, size_t used, enum vtype type, struct fns *fns)
{
struct archive *a;
struct archive_entry *ae;
size_t i;
/*
* Read ISO image.
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, 0, archive_read_support_format_all(a));
assertEqualIntA(a, 0, archive_read_support_filter_all(a));
if (type >= 1)
assertA(0 == archive_read_set_option(a, NULL, "rockridge",
NULL));
if (type >= 2)
assertA(0 == archive_read_set_option(a, NULL, "joliet",
NULL));
assertEqualIntA(a, 0, archive_read_open_memory(a, buff, used));
/*
* Read Root Directory
* Root Directory entry must be in ISO image.
*/
assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
assertEqualInt(archive_entry_atime(ae), archive_entry_ctime(ae));
assertEqualInt(archive_entry_atime(ae), archive_entry_mtime(ae));
assertEqualString(".", archive_entry_pathname(ae));
switch (type) {
case ROCKRIDGE:
assert((S_IFDIR | 0555) == archive_entry_mode(ae));
break;
case JOLIET:
assert((S_IFDIR | 0700) == archive_entry_mode(ae));
break;
case ISO9660:
assert((S_IFDIR | 0700) == archive_entry_mode(ae));
break;
}
/*
* Verify file status.
*/
memset(fns->names, 0, sizeof(char *) * fns->alloc);
fns->cnt = 0;
for (i = 0; i < fns->alloc; i++)
verify_file(a, type, fns);
for (i = 0; i < fns->alloc; i++)
free(fns->names[i]);
assertEqualInt((int)fns->longest_len, (int)fns->maxlen);
/*
* Verify the end of the archive.
*/
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}
static void
test_binary(void)
{
const char reffile[] = "test_read_format_rar_binary_data.rar";
char file1_buff[1048576];
int file1_size = sizeof(file1_buff);
const char file1_test_txt[] = "\x37\xef\xb2\xbe\x33\xf6\xcc\xcb\xee\x2a\x10"
"\x9d\x2e\x01\xe9\xf6\xf9\xe5\xe6\x67\x0c\x2b"
"\xd8\x6b\xa0\x26\x9a\xf7\x93\x87\x42\xf1\x08"
"\x42\xdc\x9b\x76\x91\x20\xa4\x01\xbe\x67\xbd"
"\x08\x74\xde\xec";
char file2_buff[32618];
int file2_size = sizeof(file2_buff);
const char file2_test_txt[] = "\x00\xee\x78\x00\x00\x4d\x45\x54\x41\x2d\x49"
"\x4e\x46\x2f\x6d\x61\x6e\x69\x66\x65\x73\x74"
"\x2e\x78\x6d\x6c\x50\x4b\x05\x06\x00\x00\x00"
"\x00\x12\x00\x12\x00\xaa\x04\x00\x00\xaa\x7a"
"\x00\x00\x00\x00";
struct archive_entry *ae;
struct archive *a;
extract_reference_file(reffile);
assert((a = archive_read_new()) != NULL);
assertA(0 == archive_read_support_filter_all(a));
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_open_file(a, reffile, 10240));
/* First header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("random_data.bin", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(file1_size, archive_entry_size(ae));
assertEqualInt(33188, archive_entry_mode(ae));
assertA(file1_size == archive_read_data(a, file1_buff, file1_size));
assertEqualMem(&file1_buff[file1_size - sizeof(file1_test_txt) + 1],
file1_test_txt, sizeof(file1_test_txt) - 1);
/* Second header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("LibarchiveAddingTest.odt", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(file2_size, archive_entry_size(ae));
assertEqualInt(33188, archive_entry_mode(ae));
assertA(file2_size == archive_read_data(a, file2_buff, file2_size));
assertEqualMem(&file2_buff[file2_size + 1 - sizeof(file2_test_txt)],
file2_test_txt, sizeof(file2_test_txt) - 1);
/* Test EOF */
assertA(1 == archive_read_next_header(a, &ae));
assertEqualInt(2, archive_file_count(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
static void
test_noeof(void)
{
char buff[64];
const char reffile[] = "test_read_format_rar_noeof.rar";
const char test_txt[] = "test text document\r\n";
int size = sizeof(test_txt)-1;
struct archive_entry *ae;
struct archive *a;
extract_reference_file(reffile);
assert((a = archive_read_new()) != NULL);
assertA(0 == archive_read_support_filter_all(a));
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_open_file(a, reffile, 10240));
/* First header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("test.txt", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(20, archive_entry_size(ae));
assertEqualInt(33188, archive_entry_mode(ae));
assertA(size == archive_read_data(a, buff, size));
assertEqualMem(buff, test_txt, size);
/* Test EOF */
assertA(1 == archive_read_next_header(a, &ae));
assertEqualInt(1, archive_file_count(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
clPtr<FS> clArchPlugin::OpenFS( clPtr<FS> Fs, FSPath& Path ) const
{
FSString Uri = Fs->Uri( Path );
struct archive* Arch = ArchOpen( Uri.GetUtf8() );
if ( Arch == nullptr )
{
return nullptr;
}
FSArchNode RootDir;
RootDir.fsStat.mode = S_IFDIR;
FSPath NodePath;
struct archive_entry* entry = archive_entry_new2( Arch );
int Res;
while ( ( Res = archive_read_next_header2( Arch, entry ) ) == ARCHIVE_OK )
{
NodePath.Set( CS_UTF8, archive_entry_pathname( entry ) );
FSString* ItemName = NodePath.GetItem( NodePath.Count() - 1 );
if ( NodePath.Count() == 1 && ( ItemName->IsDot() || ItemName->IsEmpty() ) )
{
// skip root dir
continue;
}
const mode_t Mode = archive_entry_mode( entry );
const int64_t Size = archive_entry_size( entry );
RootDir.entryOffset += Size;
FSStat ItemStat;
ItemStat.mode = S_ISREG( Mode ) ? Mode : S_IFDIR;
ItemStat.size = Size;
ItemStat.m_CreationTime = archive_entry_ctime( entry );
ItemStat.m_LastAccessTime = archive_entry_atime( entry );
ItemStat.m_LastWriteTime = archive_entry_mtime( entry );
ItemStat.m_ChangeTime = ItemStat.m_LastWriteTime;
FSArchNode* Dir = ArchGetParentDir( &RootDir, NodePath, ItemStat );
FSArchNode* Item = Dir->Add( FSArchNode( ItemName->GetUtf8(), ItemStat ) );
if (Item) {
Item->entryOffset = archive_read_header_position( Arch );
}
}
if ( Res != ARCHIVE_EOF )
{
dbg_printf( "Couldn't read archive entry: %s\n", archive_error_string( Arch ) );
}
archive_entry_free( entry );
ArchClose( Arch );
return new FSArch( RootDir, Uri );
}
/* For sequentially stepping through all files in the archive */
static int arxive_get_next_header(arc_handle_t ar, tar_header* hdr)
{
char buffer[ARC_BLOCKSIZE];
off_t o = 0;
size_t s = sizeof(buffer);
const char* p = buffer;
file_ptr_t entry;
if (archive_read_next_header(ar, &entry) != ARCHIVE_OK)
return -1;
hdr->compressed = archive_compression(ar);
hdr->size = archive_entry_size(entry);
hdr->hdr_offset = archive_read_header_position(ar);
hdr->data_offset = archive_read_data_position(ar);
hdr->atime = archive_entry_atime(entry);
hdr->mtime = archive_entry_mtime(entry);
hdr->mode = archive_entry_mode(entry);
hdr->uid = archive_entry_uid(entry);
hdr->gid = archive_entry_gid(entry);
hdr->reg_file = S_ISREG(hdr->mode);
strncpy(hdr->name, archive_entry_pathname(entry), sizeof(hdr->name) - 1);
return 0;
}
static int ar_entry_atime(lua_State *L) {
struct archive_entry* self = *ar_entry_check(L, 1);
int is_set;
int num_results;
if ( NULL == self ) return 0;
is_set = ( lua_gettop(L) >= 2 );
num_results = 0;
if ( archive_entry_atime_is_set(self) ) {
num_results = 2;
lua_pushnumber(L, archive_entry_atime(self));
lua_pushnumber(L, archive_entry_atime_nsec(self));
}
if ( is_set ) {
if ( lua_isnil(L, 2) ) {
archive_entry_unset_atime(self);
} else if ( lua_istable(L, 2) ) {
lua_rawgeti(L, 2, 1);
lua_rawgeti(L, 2, 2);
archive_entry_set_atime(self,
lua_tonumber(L, -2),
lua_tonumber(L, -1));
} else {
archive_entry_set_atime(self,
lua_tonumber(L, 2),
lua_tonumber(L, 3));
}
}
return num_results;
}
static int
restore_time(struct cpio *cpio, struct archive_entry *entry,
const char *name, int fd)
{
#ifndef HAVE_UTIMES
static int warned = 0;
(void)cpio; /* UNUSED */
(void)entry; /* UNUSED */
(void)name; /* UNUSED */
if (!warned)
lafe_warnc(0, "Can't restore access times on this platform");
warned = 1;
return (fd);
#else
#if defined(_WIN32) && !defined(__CYGWIN__)
struct __timeval times[2];
#else
struct timeval times[2];
#endif
if (!cpio->option_atime_restore)
return (fd);
times[1].tv_sec = archive_entry_mtime(entry);
times[1].tv_usec = archive_entry_mtime_nsec(entry) / 1000;
times[0].tv_sec = archive_entry_atime(entry);
times[0].tv_usec = archive_entry_atime_nsec(entry) / 1000;
#if defined(HAVE_FUTIMES) && !defined(__CYGWIN__)
if (fd >= 0 && futimes(fd, times) == 0)
return (fd);
#endif
/*
* Some platform cannot restore access times if the file descriptor
* is still opened.
*/
if (fd >= 0) {
close(fd);
fd = -1;
}
#ifdef HAVE_LUTIMES
if (lutimes(name, times) != 0)
#else
if ((AE_IFLNK != archive_entry_filetype(entry))
&& utimes(name, times) != 0)
#endif
lafe_warnc(errno, "Can't update time for %s", name);
#endif
return (fd);
}
static void
test_large_splitted_file(void)
{
static const char *reffiles[] =
{
"test_read_large_splitted_rar_aa",
"test_read_large_splitted_rar_ab",
"test_read_large_splitted_rar_ac",
"test_read_large_splitted_rar_ad",
"test_read_large_splitted_rar_ae",
NULL
};
const char test_txt[] = "gin-bottom: 0in\"><BR>\n</P>\n</BODY>\n</HTML>";
int size = 241647978, offset = 0;
char buff[64];
struct archive_entry *ae;
struct archive *a;
extract_reference_files(reffiles);
assert((a = archive_read_new()) != NULL);
assertA(0 == archive_read_support_filter_all(a));
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_open_filenames(a, reffiles, 10240));
/* First header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("ppmd_lzss_conversion_test.txt",
archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(size, archive_entry_size(ae));
assertEqualInt(33188, archive_entry_mode(ae));
while (offset + (int)sizeof(buff) < size)
{
assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
offset += sizeof(buff);
}
assertA(size - offset == archive_read_data(a, buff, size - offset));
assertEqualMem(buff, test_txt, size - offset);
/* Test EOF */
assertA(1 == archive_read_next_header(a, &ae));
assertEqualInt(1, archive_file_count(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* This test is for sufficiently large files that would have been compressed
* using multiple lzss blocks.
*/
static void
test_multi_lzss_blocks(void)
{
const char reffile[] = "test_read_format_rar_multi_lzss_blocks.rar";
const char test_txt[] = "-bottom: 0in\"><BR>\n</P>\n</BODY>\n</HTML>";
int size = 20131111, offset = 0;
char buff[64];
struct archive_entry *ae;
struct archive *a;
extract_reference_file(reffile);
assert((a = archive_read_new()) != NULL);
assertA(0 == archive_read_support_filter_all(a));
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_open_file(a, reffile, 10240));
/* First header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("multi_lzss_blocks_test.txt", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(size, archive_entry_size(ae));
assertEqualInt(33188, archive_entry_mode(ae));
while (offset + (int)sizeof(buff) < size)
{
assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
offset += sizeof(buff);
}
assertA(size - offset == archive_read_data(a, buff, size - offset));
assertEqualMem(buff, test_txt, size - offset);
/* Test EOF */
assertA(1 == archive_read_next_header(a, &ae));
assertEqualInt(1, archive_file_count(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
static void
test_customized_multiple_data_objects(void)
{
char buff[64];
static const char *reffiles[] =
{
"test_read_splitted_rar_aa",
"test_read_splitted_rar_ab",
"test_read_splitted_rar_ac",
"test_read_splitted_rar_ad",
NULL
};
const char test_txt[] = "test text document\r\n";
int size = sizeof(test_txt)-1;
struct archive_entry *ae;
struct archive *a;
struct mydata *mydata;
const char *filename = *reffiles;
int i;
extract_reference_files(reffiles);
assert((a = archive_read_new()) != NULL);
assertA(0 == archive_read_support_filter_all(a));
assertA(0 == archive_read_support_format_all(a));
for (i = 0; filename != NULL;)
{
assert((mydata = (struct mydata *)calloc(1, sizeof(*mydata))) != NULL);
assert((mydata->filename =
(char *)calloc(1, strlen(filename) + 1)) != NULL);
strcpy(mydata->filename, filename);
mydata->fd = -1;
filename = reffiles[++i];
assertA(0 == archive_read_append_callback_data(a, mydata));
}
assertA(0 == archive_read_set_open_callback(a, file_open));
assertA(0 == archive_read_set_read_callback(a, file_read));
assertA(0 == archive_read_set_skip_callback(a, file_skip));
assertA(0 == archive_read_set_close_callback(a, file_close));
assertA(0 == archive_read_set_switch_callback(a, file_switch));
assertA(0 == archive_read_set_seek_callback(a, file_seek));
assertA(0 == archive_read_open1(a));
/* First header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("test.txt", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(20, archive_entry_size(ae));
assertEqualInt(33188, archive_entry_mode(ae));
assertA(size == archive_read_data(a, buff, size));
assertEqualMem(buff, test_txt, size);
/* Second header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testlink", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualInt(41471, archive_entry_mode(ae));
assertEqualString("test.txt", archive_entry_symlink(ae));
assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));
/* Third header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(20, archive_entry_size(ae));
assertEqualInt(33188, archive_entry_mode(ae));
assertA(size == archive_read_data(a, buff, size));
assertEqualMem(buff, test_txt, size);
/* Fourth header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testdir", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualInt(16877, archive_entry_mode(ae));
/* Fifth header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testemptydir", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualInt(16877, archive_entry_mode(ae));
/* Test EOF */
assertA(1 == archive_read_next_header(a, &ae));
assertEqualInt(5, archive_file_count(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
static void
test_sfx(void)
{
char buff[441];
const char reffile[] = "test_read_format_rar_sfx.exe";
const char test_txt[] = "test text file\r\n";
int size = sizeof(test_txt)-1;
struct archive_entry *ae;
struct archive *a;
extract_reference_file(reffile);
assert((a = archive_read_new()) != NULL);
assertA(0 == archive_read_support_filter_all(a));
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_open_file(a, reffile, 10240));
/* First header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("test.txt", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(16, archive_entry_size(ae));
assertEqualInt(33188, archive_entry_mode(ae));
assertA(size == archive_read_data(a, buff, size));
assertEqualMem(buff, test_txt, size);
/* Second header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testshortcut.lnk", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(sizeof(buff), archive_entry_size(ae));
assertEqualInt(33188, archive_entry_mode(ae));
assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
/* Third header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(16, archive_entry_size(ae));
assertEqualInt(33188, archive_entry_mode(ae));
assertA(size == archive_read_data(a, buff, size));
assertEqualMem(buff, test_txt, size);
/* Fourth header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testdir", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualInt(16877, archive_entry_mode(ae));
/* Fifth header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testemptydir", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualInt(16877, archive_entry_mode(ae));
/* Test EOF */
assertA(1 == archive_read_next_header(a, &ae));
assertEqualInt(5, archive_file_count(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
static void
test_splitted_file(void)
{
char buff[64];
static const char *reffiles[] =
{
"test_read_splitted_rar_aa",
"test_read_splitted_rar_ab",
"test_read_splitted_rar_ac",
"test_read_splitted_rar_ad",
NULL
};
const char test_txt[] = "test text document\r\n";
int size = sizeof(test_txt)-1;
struct archive_entry *ae;
struct archive *a;
extract_reference_files(reffiles);
assert((a = archive_read_new()) != NULL);
assertA(0 == archive_read_support_filter_all(a));
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_open_filenames(a, reffiles, 10240));
/* First header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("test.txt", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(20, archive_entry_size(ae));
assertEqualInt(33188, archive_entry_mode(ae));
assertA(size == archive_read_data(a, buff, size));
assertEqualMem(buff, test_txt, size);
/* Second header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testlink", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualInt(41471, archive_entry_mode(ae));
assertEqualString("test.txt", archive_entry_symlink(ae));
assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));
/* Third header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(20, archive_entry_size(ae));
assertEqualInt(33188, archive_entry_mode(ae));
assertA(size == archive_read_data(a, buff, size));
assertEqualMem(buff, test_txt, size);
/* Fourth header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testdir", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualInt(16877, archive_entry_mode(ae));
/* Fifth header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testemptydir", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualInt(16877, archive_entry_mode(ae));
/* Test EOF */
assertA(1 == archive_read_next_header(a, &ae));
assertEqualInt(5, archive_file_count(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
static void
verify_contents(struct archive *a, int expect_details)
{
char filedata[64];
struct archive_entry *ae;
/*
* Read and verify first file.
*/
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(1, archive_entry_mtime(ae));
/* Zip doesn't store high-resolution mtime. */
assertEqualInt(0, archive_entry_mtime_nsec(ae));
assertEqualInt(0, archive_entry_atime(ae));
assertEqualInt(0, archive_entry_ctime(ae));
assertEqualString("file", archive_entry_pathname(ae));
if (expect_details) {
assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
assertEqualInt(8, archive_entry_size(ae));
} else {
assertEqualInt(0, 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));
if (expect_details) {
assertEqualInt(AE_IFREG | 0755, archive_entry_mode(ae));
assertEqualInt(4, archive_entry_size(ae));
} else {
assertEqualInt(0, archive_entry_size(ae));
}
assertEqualIntA(a, 4,
archive_read_data(a, filedata, sizeof(filedata)));
assertEqualMem(filedata, "1234", 4);
/*
* Read the third 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("symlink", archive_entry_pathname(ae));
if (expect_details) {
assertEqualInt(AE_IFLNK | 0755, archive_entry_mode(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualString("file1", archive_entry_symlink(ae));
} else {
assertEqualInt(AE_IFREG | 0777, archive_entry_mode(ae));
assertEqualInt(0, archive_entry_size(ae));
}
/*
* Read the dir entry back.
*/
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualInt(11, archive_entry_mtime(ae));
assertEqualInt(0, archive_entry_mtime_nsec(ae));
assertEqualInt(0, archive_entry_atime(ae));
assertEqualInt(0, archive_entry_ctime(ae));
assertEqualString("dir/", archive_entry_pathname(ae));
if (expect_details)
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));
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
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_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_open_filename_mbs(void)
{
char buff[64];
struct archive_entry *ae;
struct archive *a;
/* Write an archive through this FILE *. */
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_none(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_write_open_filename(a, "test.tar"));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 0);
archive_entry_copy_pathname(ae, "file");
archive_entry_set_mode(ae, S_IFREG | 0755);
archive_entry_set_size(ae, 8);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
assertEqualIntA(a, 8, archive_write_data(a, "12345678", 9));
/*
* Write a second file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_copy_pathname(ae, "file2");
archive_entry_set_mode(ae, S_IFREG | 0755);
archive_entry_set_size(ae, 819200);
assertEqualIntA(a, ARCHIVE_OK, 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);
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_filename(a, "test.tar", 512));
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("file", archive_entry_pathname(ae));
assert((S_IFREG | 0755) == archive_entry_mode(ae));
assertEqualInt(8, archive_entry_size(ae));
assertEqualIntA(a, 8, archive_read_data(a, buff, 10));
assertEqualMem(buff, "12345678", 8);
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("file2", archive_entry_pathname(ae));
assert((S_IFREG | 0755) == archive_entry_mode(ae));
assertEqualInt(819200, archive_entry_size(ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_data_skip(a));
/* 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));
/*
* Verify some of the error handling.
*/
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_FATAL,
archive_read_open_filename(a, "nonexistent.tar", 512));
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);
}
static int
archive_write_zip_header(struct archive_write *a, struct archive_entry *entry)
{
struct zip *zip;
struct zip_local_file_header h;
struct zip_extra_data_local e;
struct zip_data_descriptor *d;
struct zip_file_header_link *l;
int ret;
int64_t size;
mode_t type;
/* Entries other than a regular file or a folder are skipped. */
type = archive_entry_filetype(entry);
if ((type != AE_IFREG) & (type != AE_IFDIR)) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, "Filetype not supported");
return ARCHIVE_FAILED;
};
/* Directory entries should have a size of 0. */
if (type == AE_IFDIR)
archive_entry_set_size(entry, 0);
zip = a->format_data;
d = &zip->data_descriptor;
size = archive_entry_size(entry);
zip->remaining_data_bytes = size;
/* Append archive entry to the central directory data. */
l = (struct zip_file_header_link *) malloc(sizeof(*l));
if (l == NULL) {
archive_set_error(&a->archive, ENOMEM, "Can't allocate zip header data");
return (ARCHIVE_FATAL);
}
l->entry = archive_entry_clone(entry);
/* Initialize the CRC variable and potentially the local crc32(). */
l->crc32 = crc32(0, NULL, 0);
l->compression = zip->compression;
l->compressed_size = 0;
l->next = NULL;
if (zip->central_directory == NULL) {
zip->central_directory = l;
} else {
zip->central_directory_end->next = l;
}
zip->central_directory_end = l;
/* Store the offset of this header for later use in central directory. */
l->offset = zip->written_bytes;
memset(&h, 0, sizeof(h));
archive_le32enc(&h.signature, ZIP_SIGNATURE_LOCAL_FILE_HEADER);
archive_le16enc(&h.version, ZIP_VERSION_EXTRACT);
archive_le16enc(&h.flags, ZIP_FLAGS);
archive_le16enc(&h.compression, zip->compression);
archive_le32enc(&h.timedate, dos_time(archive_entry_mtime(entry)));
archive_le16enc(&h.filename_length, (uint16_t)path_length(entry));
switch (zip->compression) {
case COMPRESSION_STORE:
/* Setting compressed and uncompressed sizes even when specification says
* to set to zero when using data descriptors. Otherwise the end of the
* data for an entry is rather difficult to find. */
archive_le32enc(&h.compressed_size, size);
archive_le32enc(&h.uncompressed_size, size);
break;
#ifdef HAVE_ZLIB_H
case COMPRESSION_DEFLATE:
archive_le32enc(&h.uncompressed_size, size);
zip->stream.zalloc = Z_NULL;
zip->stream.zfree = Z_NULL;
zip->stream.opaque = Z_NULL;
zip->stream.next_out = zip->buf;
zip->stream.avail_out = zip->len_buf;
if (deflateInit2(&zip->stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
-15, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
archive_set_error(&a->archive, ENOMEM, "Can't init deflate compressor");
return (ARCHIVE_FATAL);
}
break;
#endif
}
/* Formatting extra data. */
archive_le16enc(&h.extra_length, sizeof(e));
archive_le16enc(&e.time_id, ZIP_SIGNATURE_EXTRA_TIMESTAMP);
archive_le16enc(&e.time_size, sizeof(e.time_flag) +
sizeof(e.mtime) + sizeof(e.atime) + sizeof(e.ctime));
e.time_flag[0] = 0x07;
archive_le32enc(&e.mtime, archive_entry_mtime(entry));
archive_le32enc(&e.atime, archive_entry_atime(entry));
archive_le32enc(&e.ctime, archive_entry_ctime(entry));
archive_le16enc(&e.unix_id, ZIP_SIGNATURE_EXTRA_UNIX);
archive_le16enc(&e.unix_size, sizeof(e.unix_uid) + sizeof(e.unix_gid));
archive_le16enc(&e.unix_uid, archive_entry_uid(entry));
archive_le16enc(&e.unix_gid, archive_entry_gid(entry));
archive_le32enc(&d->uncompressed_size, size);
ret = (a->compressor.write)(a, &h, sizeof(h));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(h);
ret = write_path(entry, a);
if (ret <= ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += ret;
ret = (a->compressor.write)(a, &e, sizeof(e));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(e);
return (ARCHIVE_OK);
}
/*
* Verify file
*/
static void
verify_file(struct archive *a, enum vtype type, struct fns *fns)
{
struct archive_entry *ae;
int i;
assertEqualIntA(a, 0, archive_read_next_header(a, &ae));
if (type == ROCKRIDGE) {
assertEqualInt(2, archive_entry_birthtime(ae));
assertEqualInt(3, archive_entry_atime(ae));
assertEqualInt(4, archive_entry_ctime(ae));
} else {
assertEqualInt(0, archive_entry_birthtime_is_set(ae));
assertEqualInt(5, archive_entry_atime(ae));
assertEqualInt(5, archive_entry_ctime(ae));
}
assertEqualInt(5, archive_entry_mtime(ae));
if (type == ROCKRIDGE)
assert((S_IFREG | 0555) == archive_entry_mode(ae));
else
assert((S_IFREG | 0400) == archive_entry_mode(ae));
assertEqualInt(0, archive_entry_size(ae));
/*
* Check if the same filename does not appear.
*/
for (i = 0; i < fns->cnt; i++) {
const char *p;
const char *pathname = archive_entry_pathname(ae);
const char *symlinkname = archive_entry_symlink(ae);
size_t length;
if (symlinkname != NULL) {
length = strlen(symlinkname);
assert(length == 1 || length == 128 || length == 255);
assertEqualInt(symlinkname[length-1], 'x');
}
failure("Found duplicate for %s", pathname);
assert(strcmp(fns->names[i], pathname) != 0);
assert((length = strlen(pathname)) <= fns->maxlen);
if (length > fns->longest_len)
fns->longest_len = length;
p = strrchr(pathname, '.');
if (p != NULL) {
/* Check a length of file name. */
assert((size_t)(p - pathname) <= fns->maxflen);
/* Check a length of file extension. */
assert(strlen(p+1) <= fns->maxelen);
if (fns->opt & ONE_DOT) {
/* Do not have multi dot. */
assert(strchr(pathname, '.') == p);
}
}
for (p = pathname; *p; p++) {
if (fns->opt & UPPER_CASE_ONLY) {
/* Do not have any lower-case character. */
assert(*p < 'a' || *p > 'z');
} else
break;
}
if ((fns->opt & ALLOW_LDOT) == 0)
/* Do not have a dot at the first position. */
assert(*pathname != '.');
}
/* Save the filename which is appeared to use above next time. */
fns->names[fns->cnt++] = strdup(archive_entry_pathname(ae));
}
static void
test_compress_best(void)
{
const char reffile[] = "test_read_format_rar_compress_best.rar";
char file1_buff[20111];
int file1_size = sizeof(file1_buff);
const char file1_test_txt[] = "<P STYLE=\"margin-bottom: 0in\"><BR>\n"
"</P>\n"
"</BODY>\n"
"</HTML>";
char file2_buff[20];
int file2_size = sizeof(file2_buff);
const char file2_test_txt[] = "test text document\r\n";
struct archive_entry *ae;
struct archive *a;
extract_reference_file(reffile);
assert((a = archive_read_new()) != NULL);
assertA(0 == archive_read_support_filter_all(a));
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_open_file(a, reffile, 10240));
/* First header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("LibarchiveAddingTest.html", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(file1_size, archive_entry_size(ae));
assertEqualInt(33188, archive_entry_mode(ae));
assertA(file1_size == archive_read_data(a, file1_buff, file1_size));
assertEqualMem(&file1_buff[file1_size - sizeof(file1_test_txt) + 1],
file1_test_txt, sizeof(file1_test_txt) - 1);
/* Second header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testlink", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualInt(41471, archive_entry_mode(ae));
assertEqualString("LibarchiveAddingTest.html", archive_entry_symlink(ae));
assertEqualIntA(a, 0, archive_read_data(a, file1_buff, 30));
/* Third header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(file2_size, archive_entry_size(ae));
assertEqualInt(33188, archive_entry_mode(ae));
assertA(file2_size == archive_read_data(a, file2_buff, file2_size));
assertEqualMem(&file2_buff[file2_size + 1 - sizeof(file2_test_txt)],
file2_test_txt, sizeof(file2_test_txt) - 1);
/* Fourth header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testdir/LibarchiveAddingTest.html",
archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(file1_size, archive_entry_size(ae));
assertEqualInt(33188, archive_entry_mode(ae));
assertA(file1_size == archive_read_data(a, file1_buff, file1_size));
assertEqualMem(&file1_buff[file1_size - sizeof(file1_test_txt) + 1],
file1_test_txt, sizeof(file1_test_txt) - 1);
/* Fifth header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testdir", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualInt(16877, archive_entry_mode(ae));
/* Sixth header. */
assertA(0 == archive_read_next_header(a, &ae));
assertEqualString("testemptydir", archive_entry_pathname(ae));
assertA((int)archive_entry_mtime(ae));
assertA((int)archive_entry_ctime(ae));
assertA((int)archive_entry_atime(ae));
assertEqualInt(0, archive_entry_size(ae));
assertEqualInt(16877, archive_entry_mode(ae));
/* Test EOF */
assertA(1 == archive_read_next_header(a, &ae));
assertEqualInt(6, archive_file_count(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/*
* 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_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);
}
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_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);
}
unsigned long Entry::atime()
{
return archive_entry_atime(_entry);
}
static int
archive_write_zip_header(struct archive_write *a, struct archive_entry *entry)
{
unsigned char local_header[32];
unsigned char local_extra[128];
struct zip *zip = a->format_data;
unsigned char *e;
unsigned char *cd_extra;
size_t filename_length;
const char *slink = NULL;
size_t slink_size = 0;
struct archive_string_conv *sconv = get_sconv(a, zip);
int ret, ret2 = ARCHIVE_OK;
int64_t size;
mode_t type;
int version_needed = 10;
/* Ignore types of entries that we don't support. */
type = archive_entry_filetype(entry);
if (type != AE_IFREG && type != AE_IFDIR && type != AE_IFLNK) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Filetype not supported");
return ARCHIVE_FAILED;
};
/* If we're not using Zip64, reject large files. */
if (zip->flags & ZIP_FLAG_AVOID_ZIP64) {
/* Reject entries over 4GB. */
if (archive_entry_size_is_set(entry)
&& (archive_entry_size(entry) > 0xffffffff)) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Files > 4GB require Zip64 extensions");
return ARCHIVE_FAILED;
}
/* Reject entries if archive is > 4GB. */
if (zip->written_bytes > 0xffffffff) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Archives > 4GB require Zip64 extensions");
return ARCHIVE_FAILED;
}
}
/* Only regular files can have size > 0. */
if (type != AE_IFREG)
archive_entry_set_size(entry, 0);
/* Reset information from last entry. */
zip->entry_offset = zip->written_bytes;
zip->entry_uncompressed_limit = INT64_MAX;
zip->entry_compressed_size = 0;
zip->entry_uncompressed_size = 0;
zip->entry_compressed_written = 0;
zip->entry_uncompressed_written = 0;
zip->entry_flags = 0;
zip->entry_uses_zip64 = 0;
zip->entry_crc32 = zip->crc32func(0, NULL, 0);
if (zip->entry != NULL) {
archive_entry_free(zip->entry);
zip->entry = NULL;
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* Make sure the path separators in pahtname, hardlink and symlink
* are all slash '/', not the Windows path separator '\'. */
zip->entry = __la_win_entry_in_posix_pathseparator(entry);
if (zip->entry == entry)
zip->entry = archive_entry_clone(entry);
#else
zip->entry = archive_entry_clone(entry);
#endif
if (zip->entry == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate zip header data");
return (ARCHIVE_FATAL);
}
if (sconv != NULL) {
const char *p;
size_t len;
if (archive_entry_pathname_l(entry, &p, &len, sconv) != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Pathname");
return (ARCHIVE_FATAL);
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate Pathname '%s' to %s",
archive_entry_pathname(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
if (len > 0)
archive_entry_set_pathname(zip->entry, p);
/*
* There is no standard for symlink handling; we convert
* it using the same character-set translation that we use
* for filename.
*/
if (type == AE_IFLNK) {
if (archive_entry_symlink_l(entry, &p, &len, sconv)) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory "
" for Symlink");
return (ARCHIVE_FATAL);
}
/* No error if we can't convert. */
} else if (len > 0)
archive_entry_set_symlink(zip->entry, p);
}
}
/* If filename isn't ASCII and we can use UTF-8, set the UTF-8 flag. */
if (!is_all_ascii(archive_entry_pathname(zip->entry))) {
if (zip->opt_sconv != NULL) {
if (strcmp(archive_string_conversion_charset_name(
zip->opt_sconv), "UTF-8") == 0)
zip->entry_flags |= ZIP_ENTRY_FLAG_UTF8_NAME;
#if HAVE_NL_LANGINFO
} else if (strcmp(nl_langinfo(CODESET), "UTF-8") == 0) {
zip->entry_flags |= ZIP_ENTRY_FLAG_UTF8_NAME;
#endif
}
}
filename_length = path_length(zip->entry);
/* Determine appropriate compression and size for this entry. */
if (type == AE_IFLNK) {
slink = archive_entry_symlink(zip->entry);
if (slink != NULL)
slink_size = strlen(slink);
else
slink_size = 0;
zip->entry_uncompressed_limit = slink_size;
zip->entry_compressed_size = slink_size;
zip->entry_uncompressed_size = slink_size;
zip->entry_crc32 = zip->crc32func(zip->entry_crc32,
(const unsigned char *)slink, slink_size);
zip->entry_compression = COMPRESSION_STORE;
version_needed = 20;
} else if (type != AE_IFREG) {
zip->entry_compression = COMPRESSION_STORE;
zip->entry_uncompressed_limit = 0;
size = 0;
version_needed = 20;
} else if (archive_entry_size_is_set(zip->entry)) {
size = archive_entry_size(zip->entry);
zip->entry_uncompressed_limit = size;
zip->entry_compression = zip->requested_compression;
if (zip->entry_compression == COMPRESSION_UNSPECIFIED) {
zip->entry_compression = COMPRESSION_DEFAULT;
}
if (zip->entry_compression == COMPRESSION_STORE) {
zip->entry_compressed_size = size;
zip->entry_uncompressed_size = size;
version_needed = 10;
} else {
zip->entry_uncompressed_size = size;
version_needed = 20;
}
if ((zip->flags & ZIP_FLAG_FORCE_ZIP64) /* User asked. */
|| (zip->entry_uncompressed_size > ARCHIVE_LITERAL_LL(0xffffffff))) { /* Large entry. */
zip->entry_uses_zip64 = 1;
version_needed = 45;
}
/* We may know the size, but never the CRC. */
zip->entry_flags |= ZIP_ENTRY_FLAG_LENGTH_AT_END;
} else {
/* Prefer deflate if it's available, because deflate
* has a clear end-of-data marker that makes
* length-at-end more reliable. */
zip->entry_compression = COMPRESSION_DEFAULT;
zip->entry_flags |= ZIP_ENTRY_FLAG_LENGTH_AT_END;
if ((zip->flags & ZIP_FLAG_AVOID_ZIP64) == 0) {
zip->entry_uses_zip64 = 1;
version_needed = 45;
} else if (zip->entry_compression == COMPRESSION_STORE) {
version_needed = 10;
} else {
version_needed = 20;
}
}
/* Format the local header. */
memset(local_header, 0, sizeof(local_header));
memcpy(local_header, "PK\003\004", 4);
archive_le16enc(local_header + 4, version_needed);
archive_le16enc(local_header + 6, zip->entry_flags);
archive_le16enc(local_header + 8, zip->entry_compression);
archive_le32enc(local_header + 10, dos_time(archive_entry_mtime(zip->entry)));
archive_le32enc(local_header + 14, zip->entry_crc32);
if (zip->entry_uses_zip64) {
/* Zip64 data in the local header "must" include both
* compressed and uncompressed sizes AND those fields
* are included only if these are 0xffffffff;
* THEREFORE these must be set this way, even if we
* know one of them is smaller. */
archive_le32enc(local_header + 18, ARCHIVE_LITERAL_LL(0xffffffff));
archive_le32enc(local_header + 22, ARCHIVE_LITERAL_LL(0xffffffff));
} else {
archive_le32enc(local_header + 18, zip->entry_compressed_size);
archive_le32enc(local_header + 22, zip->entry_uncompressed_size);
}
archive_le16enc(local_header + 26, filename_length);
/* Format as much of central directory file header as we can: */
zip->file_header = cd_alloc(zip, 46);
/* If (zip->file_header == NULL) XXXX */
++zip->central_directory_entries;
memset(zip->file_header, 0, 46);
memcpy(zip->file_header, "PK\001\002", 4);
/* "Made by PKZip 2.0 on Unix." */
archive_le16enc(zip->file_header + 4, 3 * 256 + version_needed);
archive_le16enc(zip->file_header + 6, version_needed);
archive_le16enc(zip->file_header + 8, zip->entry_flags);
archive_le16enc(zip->file_header + 10, zip->entry_compression);
archive_le32enc(zip->file_header + 12, dos_time(archive_entry_mtime(zip->entry)));
archive_le16enc(zip->file_header + 28, filename_length);
/* Following Info-Zip, store mode in the "external attributes" field. */
archive_le32enc(zip->file_header + 38,
((uint32_t)archive_entry_mode(zip->entry)) << 16);
e = cd_alloc(zip, filename_length);
/* If (e == NULL) XXXX */
copy_path(zip->entry, e);
/* Format extra data. */
memset(local_extra, 0, sizeof(local_extra));
e = local_extra;
/* First, extra blocks that are the same between
* the local file header and the central directory.
* We format them once and then duplicate them. */
/* UT timestamp, length depends on what timestamps are set. */
memcpy(e, "UT", 2);
archive_le16enc(e + 2,
1
+ (archive_entry_mtime_is_set(entry) ? 4 : 0)
+ (archive_entry_atime_is_set(entry) ? 4 : 0)
+ (archive_entry_ctime_is_set(entry) ? 4 : 0));
e += 4;
*e++ =
(archive_entry_mtime_is_set(entry) ? 1 : 0)
| (archive_entry_atime_is_set(entry) ? 2 : 0)
| (archive_entry_ctime_is_set(entry) ? 4 : 0);
if (archive_entry_mtime_is_set(entry)) {
archive_le32enc(e, (uint32_t)archive_entry_mtime(entry));
e += 4;
}
if (archive_entry_atime_is_set(entry)) {
archive_le32enc(e, (uint32_t)archive_entry_atime(entry));
e += 4;
}
if (archive_entry_ctime_is_set(entry)) {
archive_le32enc(e, (uint32_t)archive_entry_ctime(entry));
e += 4;
}
/* ux Unix extra data, length 11, version 1 */
/* TODO: If uid < 64k, use 2 bytes, ditto for gid. */
memcpy(e, "ux\013\000\001", 5);
e += 5;
*e++ = 4; /* Length of following UID */
archive_le32enc(e, (uint32_t)archive_entry_uid(entry));
e += 4;
*e++ = 4; /* Length of following GID */
archive_le32enc(e, (uint32_t)archive_entry_gid(entry));
e += 4;
/* Copy UT and ux into central directory as well. */
zip->file_header_extra_offset = zip->central_directory_bytes;
cd_extra = cd_alloc(zip, e - local_extra);
memcpy(cd_extra, local_extra, e - local_extra);
/*
* Following extra blocks vary between local header and
* central directory. These are the local header versions.
* Central directory versions get formatted in
* archive_write_zip_finish_entry() below.
*/
/* "[Zip64 entry] in the local header MUST include BOTH
* original [uncompressed] and compressed size fields." */
if (zip->entry_uses_zip64) {
unsigned char *zip64_start = e;
memcpy(e, "\001\000\020\000", 4);
e += 4;
archive_le64enc(e, zip->entry_uncompressed_size);
e += 8;
archive_le64enc(e, zip->entry_compressed_size);
e += 8;
archive_le16enc(zip64_start + 2, e - (zip64_start + 4));
}
if (zip->flags & ZIP_FLAG_EXPERIMENT_EL) {
/* Experimental 'el' extension to improve streaming. */
unsigned char *external_info = e;
int included = 7;
memcpy(e, "el\000\000", 4); // 0x6c65 + 2-byte length
e += 4;
e[0] = included; /* bitmap of included fields */
e += 1;
if (included & 1) {
archive_le16enc(e, /* "Version created by" */
3 * 256 + version_needed);
e += 2;
}
if (included & 2) {
archive_le16enc(e, 0); /* internal file attributes */
e += 2;
}
if (included & 4) {
archive_le32enc(e, /* external file attributes */
((uint32_t)archive_entry_mode(zip->entry)) << 16);
e += 4;
}
if (included & 8) {
// Libarchive does not currently support file comments.
}
archive_le16enc(external_info + 2, e - (external_info + 4));
}
/* Update local header with size of extra data and write it all out: */
archive_le16enc(local_header + 28, e - local_extra);
ret = __archive_write_output(a, local_header, 30);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += 30;
ret = write_path(zip->entry, a);
if (ret <= ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += ret;
ret = __archive_write_output(a, local_extra, e - local_extra);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += e - local_extra;
/* For symlinks, write the body now. */
if (slink != NULL) {
ret = __archive_write_output(a, slink, slink_size);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->entry_compressed_written += slink_size;
zip->entry_uncompressed_written += slink_size;
zip->written_bytes += slink_size;
}
#ifdef HAVE_ZLIB_H
if (zip->entry_compression == COMPRESSION_DEFLATE) {
zip->stream.zalloc = Z_NULL;
zip->stream.zfree = Z_NULL;
zip->stream.opaque = Z_NULL;
zip->stream.next_out = zip->buf;
zip->stream.avail_out = (uInt)zip->len_buf;
if (deflateInit2(&zip->stream, Z_DEFAULT_COMPRESSION,
Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
archive_set_error(&a->archive, ENOMEM,
"Can't init deflate compressor");
return (ARCHIVE_FATAL);
}
}
#endif
return (ret2);
}
const struct stat *
archive_entry_stat(struct archive_entry *entry)
{
struct stat *st;
if (entry->stat == NULL) {
entry->stat = calloc(1, sizeof(*st));
if (entry->stat == NULL)
return (NULL);
entry->stat_valid = 0;
}
/*
* If none of the underlying fields have been changed, we
* don't need to regenerate. In theory, we could use a bitmap
* here to flag only those items that have changed, but the
* extra complexity probably isn't worth it. It will be very
* rare for anyone to change just one field then request a new
* stat structure.
*/
if (entry->stat_valid)
return (entry->stat);
st = entry->stat;
/*
* Use the public interfaces to extract items, so that
* the appropriate conversions get invoked.
*/
st->st_atime = archive_entry_atime(entry);
#if HAVE_STRUCT_STAT_ST_BIRTHTIME
st->st_birthtime = archive_entry_birthtime(entry);
#endif
st->st_ctime = archive_entry_ctime(entry);
st->st_mtime = archive_entry_mtime(entry);
st->st_dev = archive_entry_dev(entry);
st->st_gid = archive_entry_gid(entry);
st->st_uid = archive_entry_uid(entry);
st->st_ino = archive_entry_ino64(entry);
st->st_nlink = archive_entry_nlink(entry);
st->st_rdev = archive_entry_rdev(entry);
st->st_size = archive_entry_size(entry);
st->st_mode = archive_entry_mode(entry);
/*
* On systems that support high-res timestamps, copy that
* information into struct stat.
*/
#if HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC
st->st_atimespec.tv_nsec = archive_entry_atime_nsec(entry);
st->st_ctimespec.tv_nsec = archive_entry_ctime_nsec(entry);
st->st_mtimespec.tv_nsec = archive_entry_mtime_nsec(entry);
#elif HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
st->st_atim.tv_nsec = archive_entry_atime_nsec(entry);
st->st_ctim.tv_nsec = archive_entry_ctime_nsec(entry);
st->st_mtim.tv_nsec = archive_entry_mtime_nsec(entry);
#elif HAVE_STRUCT_STAT_ST_MTIME_N
st->st_atime_n = archive_entry_atime_nsec(entry);
st->st_ctime_n = archive_entry_ctime_nsec(entry);
st->st_mtime_n = archive_entry_mtime_nsec(entry);
#elif HAVE_STRUCT_STAT_ST_UMTIME
st->st_uatime = archive_entry_atime_nsec(entry) / 1000;
st->st_uctime = archive_entry_ctime_nsec(entry) / 1000;
st->st_umtime = archive_entry_mtime_nsec(entry) / 1000;
#elif HAVE_STRUCT_STAT_ST_MTIME_USEC
st->st_atime_usec = archive_entry_atime_nsec(entry) / 1000;
st->st_ctime_usec = archive_entry_ctime_nsec(entry) / 1000;
st->st_mtime_usec = archive_entry_mtime_nsec(entry) / 1000;
#endif
#if HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC
st->st_birthtimespec.tv_nsec = archive_entry_birthtime_nsec(entry);
#endif
/*
* TODO: On Linux, store 32 or 64 here depending on whether
* the cached stat structure is a stat32 or a stat64. This
* will allow us to support both variants interchangeably.
*/
entry->stat_valid = 1;
return (st);
}
static int
archive_write_zip_header(struct archive_write *a, struct archive_entry *entry)
{
struct zip *zip;
struct zip_local_file_header h;
struct zip_extra_data_local e;
struct zip_data_descriptor *d;
struct zip_file_header_link *l;
struct archive_string_conv *sconv;
int ret, ret2 = ARCHIVE_OK;
int64_t size;
mode_t type;
/* Entries other than a regular file or a folder are skipped. */
type = archive_entry_filetype(entry);
if ((type != AE_IFREG) & (type != AE_IFDIR)) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Filetype not supported");
return ARCHIVE_FAILED;
};
/* Directory entries should have a size of 0. */
if (type == AE_IFDIR)
archive_entry_set_size(entry, 0);
zip = a->format_data;
/* Setup default conversion. */
if (zip->opt_sconv == NULL && !zip->init_default_conversion) {
zip->sconv_default =
archive_string_default_conversion_for_write(&(a->archive));
zip->init_default_conversion = 1;
}
if (zip->flags == 0) {
/* Initialize the general purpose flags. */
zip->flags = ZIP_FLAGS;
if (zip->opt_sconv != NULL) {
if (strcmp(archive_string_conversion_charset_name(
zip->opt_sconv), "UTF-8") == 0)
zip->flags |= ZIP_FLAGS_UTF8_NAME;
#if HAVE_NL_LANGINFO
} else if (strcmp(nl_langinfo(CODESET), "UTF-8") == 0) {
zip->flags |= ZIP_FLAGS_UTF8_NAME;
#endif
}
}
d = &zip->data_descriptor;
size = archive_entry_size(entry);
zip->remaining_data_bytes = size;
/* Append archive entry to the central directory data. */
l = (struct zip_file_header_link *) malloc(sizeof(*l));
if (l == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate zip header data");
return (ARCHIVE_FATAL);
}
l->entry = archive_entry_clone(entry);
l->flags = zip->flags;
if (zip->opt_sconv != NULL)
sconv = zip->opt_sconv;
else
sconv = zip->sconv_default;
if (sconv != NULL) {
const char *p;
size_t len;
if (archive_entry_pathname_l(entry, &p, &len, sconv) != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Pathname");
return (ARCHIVE_FATAL);
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate pathname '%s' to %s",
archive_entry_pathname(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
if (len > 0)
archive_entry_set_pathname(l->entry, p);
}
/* If all character of a filename is ASCII, Reset UTF-8 Name flag. */
if ((l->flags & ZIP_FLAGS_UTF8_NAME) != 0 &&
is_all_ascii(archive_entry_pathname(l->entry)))
l->flags &= ~ZIP_FLAGS_UTF8_NAME;
/* Initialize the CRC variable and potentially the local crc32(). */
l->crc32 = crc32(0, NULL, 0);
l->compression = zip->compression;
l->compressed_size = 0;
l->next = NULL;
if (zip->central_directory == NULL) {
zip->central_directory = l;
} else {
zip->central_directory_end->next = l;
}
zip->central_directory_end = l;
/* Store the offset of this header for later use in central directory. */
l->offset = zip->written_bytes;
memset(&h, 0, sizeof(h));
archive_le32enc(&h.signature, ZIP_SIGNATURE_LOCAL_FILE_HEADER);
archive_le16enc(&h.version, ZIP_VERSION_EXTRACT);
archive_le16enc(&h.flags, l->flags);
archive_le16enc(&h.compression, zip->compression);
archive_le32enc(&h.timedate, dos_time(archive_entry_mtime(entry)));
archive_le16enc(&h.filename_length, (uint16_t)path_length(l->entry));
switch (zip->compression) {
case COMPRESSION_STORE:
/* Setting compressed and uncompressed sizes even when specification says
* to set to zero when using data descriptors. Otherwise the end of the
* data for an entry is rather difficult to find. */
archive_le32enc(&h.compressed_size, size);
archive_le32enc(&h.uncompressed_size, size);
break;
#ifdef HAVE_ZLIB_H
case COMPRESSION_DEFLATE:
archive_le32enc(&h.uncompressed_size, size);
zip->stream.zalloc = Z_NULL;
zip->stream.zfree = Z_NULL;
zip->stream.opaque = Z_NULL;
zip->stream.next_out = zip->buf;
zip->stream.avail_out = zip->len_buf;
if (deflateInit2(&zip->stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
-15, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
archive_set_error(&a->archive, ENOMEM,
"Can't init deflate compressor");
return (ARCHIVE_FATAL);
}
break;
#endif
}
/* Formatting extra data. */
archive_le16enc(&h.extra_length, sizeof(e));
archive_le16enc(&e.time_id, ZIP_SIGNATURE_EXTRA_TIMESTAMP);
archive_le16enc(&e.time_size, sizeof(e.time_flag) +
sizeof(e.mtime) + sizeof(e.atime) + sizeof(e.ctime));
e.time_flag[0] = 0x07;
archive_le32enc(&e.mtime, archive_entry_mtime(entry));
archive_le32enc(&e.atime, archive_entry_atime(entry));
archive_le32enc(&e.ctime, archive_entry_ctime(entry));
archive_le16enc(&e.unix_id, ZIP_SIGNATURE_EXTRA_NEW_UNIX);
archive_le16enc(&e.unix_size, sizeof(e.unix_version) +
sizeof(e.unix_uid_size) + sizeof(e.unix_uid) +
sizeof(e.unix_gid_size) + sizeof(e.unix_gid));
e.unix_version = 1;
e.unix_uid_size = 4;
archive_le32enc(&e.unix_uid, archive_entry_uid(entry));
e.unix_gid_size = 4;
archive_le32enc(&e.unix_gid, archive_entry_gid(entry));
archive_le32enc(&d->uncompressed_size, size);
ret = __archive_write_output(a, &h, sizeof(h));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(h);
ret = write_path(l->entry, a);
if (ret <= ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += ret;
ret = __archive_write_output(a, &e, sizeof(e));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(e);
if (ret2 != ARCHIVE_OK)
return (ret2);
return (ARCHIVE_OK);
}
static int
archive_write_zip_header(struct archive_write *a, struct archive_entry *entry)
{
struct zip *zip;
uint8_t h[SIZE_LOCAL_FILE_HEADER];
uint8_t e[SIZE_EXTRA_DATA_LOCAL];
uint8_t *d;
struct zip_file_header_link *l;
struct archive_string_conv *sconv;
int ret, ret2 = ARCHIVE_OK;
int64_t size;
mode_t type;
/* Entries other than a regular file or a folder are skipped. */
type = archive_entry_filetype(entry);
if (type != AE_IFREG && type != AE_IFDIR && type != AE_IFLNK) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Filetype not supported");
return ARCHIVE_FAILED;
};
/* Directory entries should have a size of 0. */
if (type == AE_IFDIR)
archive_entry_set_size(entry, 0);
zip = a->format_data;
/* Setup default conversion. */
if (zip->opt_sconv == NULL && !zip->init_default_conversion) {
zip->sconv_default =
archive_string_default_conversion_for_write(&(a->archive));
zip->init_default_conversion = 1;
}
if (zip->flags == 0) {
/* Initialize the general purpose flags. */
zip->flags = ZIP_FLAGS;
if (zip->opt_sconv != NULL) {
if (strcmp(archive_string_conversion_charset_name(
zip->opt_sconv), "UTF-8") == 0)
zip->flags |= ZIP_FLAGS_UTF8_NAME;
#if HAVE_NL_LANGINFO
} else if (strcmp(nl_langinfo(CODESET), "UTF-8") == 0) {
zip->flags |= ZIP_FLAGS_UTF8_NAME;
#endif
}
}
d = zip->data_descriptor;
size = archive_entry_size(entry);
zip->remaining_data_bytes = size;
/* Append archive entry to the central directory data. */
l = (struct zip_file_header_link *) malloc(sizeof(*l));
if (l == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate zip header data");
return (ARCHIVE_FATAL);
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* Make sure the path separators in pahtname, hardlink and symlink
* are all slash '/', not the Windows path separator '\'. */
l->entry = __la_win_entry_in_posix_pathseparator(entry);
if (l->entry == entry)
l->entry = archive_entry_clone(entry);
#else
l->entry = archive_entry_clone(entry);
#endif
if (l->entry == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate zip header data");
free(l);
return (ARCHIVE_FATAL);
}
l->flags = zip->flags;
if (zip->opt_sconv != NULL)
sconv = zip->opt_sconv;
else
sconv = zip->sconv_default;
if (sconv != NULL) {
const char *p;
size_t len;
if (archive_entry_pathname_l(entry, &p, &len, sconv) != 0) {
if (errno == ENOMEM) {
archive_entry_free(l->entry);
free(l);
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Pathname");
return (ARCHIVE_FATAL);
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate Pathname '%s' to %s",
archive_entry_pathname(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
if (len > 0)
archive_entry_set_pathname(l->entry, p);
/*
* Although there is no character-set regulation for Symlink,
* it is suitable to convert a character-set of Symlinke to
* what those of the Pathname has been converted to.
*/
if (type == AE_IFLNK) {
if (archive_entry_symlink_l(entry, &p, &len, sconv)) {
if (errno == ENOMEM) {
archive_entry_free(l->entry);
free(l);
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory "
" for Symlink");
return (ARCHIVE_FATAL);
}
/*
* Even if the strng conversion failed,
* we should not report the error since
* thre is no regulation for.
*/
} else if (len > 0)
archive_entry_set_symlink(l->entry, p);
}
}
/* If all characters in a filename are ASCII, Reset UTF-8 Name flag. */
if ((l->flags & ZIP_FLAGS_UTF8_NAME) != 0 &&
is_all_ascii(archive_entry_pathname(l->entry)))
l->flags &= ~ZIP_FLAGS_UTF8_NAME;
/* Initialize the CRC variable and potentially the local crc32(). */
l->crc32 = crc32(0, NULL, 0);
if (type == AE_IFLNK) {
const char *p = archive_entry_symlink(l->entry);
if (p != NULL)
size = strlen(p);
else
size = 0;
zip->remaining_data_bytes = 0;
archive_entry_set_size(l->entry, size);
l->compression = COMPRESSION_STORE;
l->compressed_size = size;
} else {
l->compression = zip->compression;
l->compressed_size = 0;
}
l->next = NULL;
if (zip->central_directory == NULL) {
zip->central_directory = l;
} else {
zip->central_directory_end->next = l;
}
zip->central_directory_end = l;
/* Store the offset of this header for later use in central
* directory. */
l->offset = zip->written_bytes;
memset(h, 0, sizeof(h));
archive_le32enc(&h[LOCAL_FILE_HEADER_SIGNATURE],
ZIP_SIGNATURE_LOCAL_FILE_HEADER);
archive_le16enc(&h[LOCAL_FILE_HEADER_VERSION], ZIP_VERSION_EXTRACT);
archive_le16enc(&h[LOCAL_FILE_HEADER_FLAGS], l->flags);
archive_le16enc(&h[LOCAL_FILE_HEADER_COMPRESSION], l->compression);
archive_le32enc(&h[LOCAL_FILE_HEADER_TIMEDATE],
dos_time(archive_entry_mtime(entry)));
archive_le16enc(&h[LOCAL_FILE_HEADER_FILENAME_LENGTH],
(uint16_t)path_length(l->entry));
switch (l->compression) {
case COMPRESSION_STORE:
/* Setting compressed and uncompressed sizes even when
* specification says to set to zero when using data
* descriptors. Otherwise the end of the data for an
* entry is rather difficult to find. */
archive_le32enc(&h[LOCAL_FILE_HEADER_COMPRESSED_SIZE],
(uint32_t)size);
archive_le32enc(&h[LOCAL_FILE_HEADER_UNCOMPRESSED_SIZE],
(uint32_t)size);
break;
#ifdef HAVE_ZLIB_H
case COMPRESSION_DEFLATE:
archive_le32enc(&h[LOCAL_FILE_HEADER_UNCOMPRESSED_SIZE],
(uint32_t)size);
zip->stream.zalloc = Z_NULL;
zip->stream.zfree = Z_NULL;
zip->stream.opaque = Z_NULL;
zip->stream.next_out = zip->buf;
zip->stream.avail_out = (uInt)zip->len_buf;
if (deflateInit2(&zip->stream, Z_DEFAULT_COMPRESSION,
Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
archive_set_error(&a->archive, ENOMEM,
"Can't init deflate compressor");
return (ARCHIVE_FATAL);
}
break;
#endif
}
/* Formatting extra data. */
archive_le16enc(&h[LOCAL_FILE_HEADER_EXTRA_LENGTH], sizeof(e));
archive_le16enc(&e[EXTRA_DATA_LOCAL_TIME_ID],
ZIP_SIGNATURE_EXTRA_TIMESTAMP);
archive_le16enc(&e[EXTRA_DATA_LOCAL_TIME_SIZE], 1 + 4 * 3);
e[EXTRA_DATA_LOCAL_TIME_FLAG] = 0x07;
archive_le32enc(&e[EXTRA_DATA_LOCAL_MTIME],
(uint32_t)archive_entry_mtime(entry));
archive_le32enc(&e[EXTRA_DATA_LOCAL_ATIME],
(uint32_t)archive_entry_atime(entry));
archive_le32enc(&e[EXTRA_DATA_LOCAL_CTIME],
(uint32_t)archive_entry_ctime(entry));
archive_le16enc(&e[EXTRA_DATA_LOCAL_UNIX_ID],
ZIP_SIGNATURE_EXTRA_NEW_UNIX);
archive_le16enc(&e[EXTRA_DATA_LOCAL_UNIX_SIZE], 1 + (1 + 4) * 2);
e[EXTRA_DATA_LOCAL_UNIX_VERSION] = 1;
e[EXTRA_DATA_LOCAL_UNIX_UID_SIZE] = 4;
archive_le32enc(&e[EXTRA_DATA_LOCAL_UNIX_UID],
(uint32_t)archive_entry_uid(entry));
e[EXTRA_DATA_LOCAL_UNIX_GID_SIZE] = 4;
archive_le32enc(&e[EXTRA_DATA_LOCAL_UNIX_GID],
(uint32_t)archive_entry_gid(entry));
archive_le32enc(&d[DATA_DESCRIPTOR_UNCOMPRESSED_SIZE],
(uint32_t)size);
ret = __archive_write_output(a, h, sizeof(h));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(h);
ret = write_path(l->entry, a);
if (ret <= ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += ret;
ret = __archive_write_output(a, e, sizeof(e));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(e);
if (type == AE_IFLNK) {
const unsigned char *p;
p = (const unsigned char *)archive_entry_symlink(l->entry);
ret = __archive_write_output(a, p, (size_t)size);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += size;
l->crc32 = crc32(l->crc32, p, (unsigned)size);
}
if (ret2 != ARCHIVE_OK)
return (ret2);
return (ARCHIVE_OK);
}
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);
}