/*
* Test functions for pathname patterns.
*
* Returns 1 if archive entry is excluded.
* Returns 0 if archive entry is not excluded.
* Returns <0 if something error happened.
*/
int
archive_match_path_excluded(struct archive *_a,
struct archive_entry *entry)
{
struct archive_match *a;
archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
ARCHIVE_STATE_NEW, "archive_match_path_excluded");
a = (struct archive_match *)_a;
if (entry == NULL) {
archive_set_error(&(a->archive), EINVAL, "entry is NULL");
return (ARCHIVE_FAILED);
}
/* If we don't have exclusion/inclusion pattern set at all,
* the entry is always not excluded. */
if ((a->setflag & PATTERN_IS_SET) == 0)
return (0);
#if defined(_WIN32) && !defined(__CYGWIN__)
return (path_excluded(a, 0, archive_entry_pathname_w(entry)));
#else
return (path_excluded(a, 1, archive_entry_pathname(entry)));
#endif
}
static void
verify(struct archive *a) {
struct archive_entry *ae;
const wchar_t *wp;
int file, i;
/*
* Test file has a pattern to all names: They all have a
* number followed by " - " and an accented character. This
* archive was created by Windows and has regular filenames in
* some MBCS and uses the Zip 0x7075 extension to hold UTF-8
* pathnames. The code below checks that the correct
* (Unicode) characters are decoded by comparing the number to
* the expected accented character.
*/
for (file = 0; file < 20; ++file) {
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
wp = archive_entry_pathname_w(ae);
for (i = 0; wp[i] != 0; ++i) {
if (wp[i] == '2') {
failure("Unicode 'o with umlaut' expected");
assertEqualInt(wp[i + 4], 0xF6);
} else if (wp[i] == '3') {
failure("Unicode 'a with umlaut' expected");
assertEqualInt(wp[i + 4], 0xE4);
} else if (wp[i] == '4') {
failure("Unicode 'a with ring' expected");
assertEqualInt(wp[i + 4], 0xE5);
}
}
}
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
}
static foreign_t
archive_next_header(term_t archive, term_t name)
{ archive_wrapper *ar;
int rc;
if ( !get_archive(archive, &ar) )
return FALSE;
if ( ar->status == AR_NEW_ENTRY )
archive_read_data_skip(ar->archive);
if ( ar->status == AR_OPENED_ENTRY )
return PL_permission_error("next_header", "archive", archive);
while ( (rc=archive_read_next_header(ar->archive, &ar->entry)) == ARCHIVE_OK )
{ if ( PL_unify_wchars(name, PL_ATOM, -1,
archive_entry_pathname_w(ar->entry)) )
{ ar->status = AR_NEW_ENTRY;
return TRUE;
}
if ( PL_exception(0) )
return FALSE;
}
if ( rc == ARCHIVE_EOF )
return FALSE; /* simply at the end */
return archive_error(ar);
}
static QString next_file( archive* a ){
archive_entry *entry;
switch( archive_read_next_header( a, &entry ) ){
case ARCHIVE_EOF: return QString();
case ARCHIVE_OK:
return QString::fromWCharArray( archive_entry_pathname_w( entry ) );
default:
qCWarning(LOG) << "Can't read the next zip header:" << archive_error_string(a);
return QString();
}
}
/*
* Convenience function to perform all exclusion tests.
*
* Returns 1 if archive entry is excluded.
* Returns 0 if archive entry is not excluded.
* Returns <0 if something error happened.
*/
int
archive_match_excluded(struct archive *_a, struct archive_entry *entry)
{
struct archive_match *a;
int r;
archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
ARCHIVE_STATE_NEW, "archive_match_excluded_ae");
a = (struct archive_match *)_a;
if (entry == NULL) {
archive_set_error(&(a->archive), EINVAL, "entry is NULL");
return (ARCHIVE_FAILED);
}
r = 0;
if (a->setflag & PATTERN_IS_SET) {
#if defined(_WIN32) && !defined(__CYGWIN__)
r = path_excluded(a, 0, archive_entry_pathname_w(entry));
#else
r = path_excluded(a, 1, archive_entry_pathname(entry));
#endif
if (r != 0)
return (r);
}
if (a->setflag & TIME_IS_SET) {
r = time_excluded(a, entry);
if (r != 0)
return (r);
}
if (a->setflag & ID_IS_SET)
r = owner_excluded(a, entry);
return (r);
}
/*
* Test if entry is excluded by its timestamp.
*/
static int
time_excluded(struct archive_match *a, struct archive_entry *entry)
{
struct match_file *f;
const void *pathname;
time_t sec;
long nsec;
/*
* If this file/dir is excluded by a time comparison, skip it.
*/
if (a->newer_ctime_filter) {
/* If ctime is not set, use mtime instead. */
if (archive_entry_ctime_is_set(entry))
sec = archive_entry_ctime(entry);
else
sec = archive_entry_mtime(entry);
if (sec < a->newer_ctime_sec)
return (1); /* Too old, skip it. */
if (sec == a->newer_ctime_sec) {
if (archive_entry_ctime_is_set(entry))
nsec = archive_entry_ctime_nsec(entry);
else
nsec = archive_entry_mtime_nsec(entry);
if (nsec < a->newer_ctime_nsec)
return (1); /* Too old, skip it. */
if (nsec == a->newer_ctime_nsec &&
(a->newer_ctime_filter & ARCHIVE_MATCH_EQUAL)
== 0)
return (1); /* Equal, skip it. */
}
}
if (a->older_ctime_filter) {
/* If ctime is not set, use mtime instead. */
if (archive_entry_ctime_is_set(entry))
sec = archive_entry_ctime(entry);
else
sec = archive_entry_mtime(entry);
if (sec > a->older_ctime_sec)
return (1); /* Too new, skip it. */
if (sec == a->older_ctime_sec) {
if (archive_entry_ctime_is_set(entry))
nsec = archive_entry_ctime_nsec(entry);
else
nsec = archive_entry_mtime_nsec(entry);
if (nsec > a->older_ctime_nsec)
return (1); /* Too new, skip it. */
if (nsec == a->older_ctime_nsec &&
(a->older_ctime_filter & ARCHIVE_MATCH_EQUAL)
== 0)
return (1); /* Equal, skip it. */
}
}
if (a->newer_mtime_filter) {
sec = archive_entry_mtime(entry);
if (sec < a->newer_mtime_sec)
return (1); /* Too old, skip it. */
if (sec == a->newer_mtime_sec) {
nsec = archive_entry_mtime_nsec(entry);
if (nsec < a->newer_mtime_nsec)
return (1); /* Too old, skip it. */
if (nsec == a->newer_mtime_nsec &&
(a->newer_mtime_filter & ARCHIVE_MATCH_EQUAL)
== 0)
return (1); /* Equal, skip it. */
}
}
if (a->older_mtime_filter) {
sec = archive_entry_mtime(entry);
if (sec > a->older_mtime_sec)
return (1); /* Too new, skip it. */
nsec = archive_entry_mtime_nsec(entry);
if (sec == a->older_mtime_sec) {
if (nsec > a->older_mtime_nsec)
return (1); /* Too new, skip it. */
if (nsec == a->older_mtime_nsec &&
(a->older_mtime_filter & ARCHIVE_MATCH_EQUAL)
== 0)
return (1); /* Equal, skip it. */
}
}
/* If there is no exclusion list, include the file. */
if (a->exclusion_entry_list.count == 0)
return (0);
#if defined(_WIN32) && !defined(__CYGWIN__)
pathname = archive_entry_pathname_w(entry);
a->exclusion_tree.rbt_ops = &rb_ops_wcs;
#else
(void)rb_ops_wcs;
pathname = archive_entry_pathname(entry);
a->exclusion_tree.rbt_ops = &rb_ops_mbs;
#endif
if (pathname == NULL)
return (0);
f = (struct match_file *)__archive_rb_tree_find_node(
&(a->exclusion_tree), pathname);
/* If the file wasn't rejected, include it. */
if (f == NULL)
return (0);
if (f->flag & ARCHIVE_MATCH_CTIME) {
sec = archive_entry_ctime(entry);
if (f->ctime_sec > sec) {
if (f->flag & ARCHIVE_MATCH_OLDER)
return (1);
} else if (f->ctime_sec < sec) {
if (f->flag & ARCHIVE_MATCH_NEWER)
return (1);
} else {
nsec = archive_entry_ctime_nsec(entry);
if (f->ctime_nsec > nsec) {
if (f->flag & ARCHIVE_MATCH_OLDER)
return (1);
} else if (f->ctime_nsec < nsec) {
if (f->flag & ARCHIVE_MATCH_NEWER)
return (1);
} else if (f->flag & ARCHIVE_MATCH_EQUAL)
return (1);
}
}
if (f->flag & ARCHIVE_MATCH_MTIME) {
sec = archive_entry_mtime(entry);
if (f->mtime_sec > sec) {
if (f->flag & ARCHIVE_MATCH_OLDER)
return (1);
} else if (f->mtime_sec < sec) {
if (f->flag & ARCHIVE_MATCH_NEWER)
return (1);
} else {
nsec = archive_entry_mtime_nsec(entry);
if (f->mtime_nsec > nsec) {
if (f->flag & ARCHIVE_MATCH_OLDER)
return (1);
} else if (f->mtime_nsec < nsec) {
if (f->flag & ARCHIVE_MATCH_NEWER)
return (1);
} else if (f->flag & ARCHIVE_MATCH_EQUAL)
return (1);
}
}
return (0);
}
static int
add_entry(struct archive_match *a, int flag,
struct archive_entry *entry)
{
struct match_file *f;
const void *pathname;
int r;
f = calloc(1, sizeof(*f));
if (f == NULL)
return (error_nomem(a));
#if defined(_WIN32) && !defined(__CYGWIN__)
pathname = archive_entry_pathname_w(entry);
if (pathname == NULL) {
free(f);
archive_set_error(&(a->archive), EINVAL, "pathname is NULL");
return (ARCHIVE_FAILED);
}
archive_mstring_copy_wcs(&(f->pathname), pathname);
a->exclusion_tree.rbt_ops = &rb_ops_wcs;
#else
(void)rb_ops_wcs;
pathname = archive_entry_pathname(entry);
if (pathname == NULL) {
free(f);
archive_set_error(&(a->archive), EINVAL, "pathname is NULL");
return (ARCHIVE_FAILED);
}
archive_mstring_copy_mbs(&(f->pathname), pathname);
a->exclusion_tree.rbt_ops = &rb_ops_mbs;
#endif
f->flag = flag;
f->mtime_sec = archive_entry_mtime(entry);
f->mtime_nsec = archive_entry_mtime_nsec(entry);
f->ctime_sec = archive_entry_ctime(entry);
f->ctime_nsec = archive_entry_ctime_nsec(entry);
r = __archive_rb_tree_insert_node(&(a->exclusion_tree), &(f->node));
if (!r) {
struct match_file *f2;
/* Get the duplicated file. */
f2 = (struct match_file *)__archive_rb_tree_find_node(
&(a->exclusion_tree), pathname);
/*
* We always overwrite comparison condition.
* If you do not want to overwrite it, you should not
* call archive_match_exclude_entry(). We cannot know
* what behavior you really expect since overwriting
* condition might be different with the flag.
*/
if (f2 != NULL) {
f2->flag = f->flag;
f2->mtime_sec = f->mtime_sec;
f2->mtime_nsec = f->mtime_nsec;
f2->ctime_sec = f->ctime_sec;
f2->ctime_nsec = f->ctime_nsec;
}
/* Release the duplicated file. */
archive_mstring_clean(&(f->pathname));
free(f);
return (ARCHIVE_OK);
}
entry_list_add(&(a->exclusion_entry_list), f);
a->setflag |= TIME_IS_SET;
return (ARCHIVE_OK);
}
static void
test_open_filename_wcs(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_w(a, L"test.tar"));
/*
* Write a file to it.
*/
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_mtime(ae, 1, 0);
archive_entry_copy_pathname_w(ae, L"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_w(ae, L"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_w(a, L"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));
assertEqualWString(L"file", archive_entry_pathname_w(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));
assertEqualWString(L"file2", archive_entry_pathname_w(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_w(a, L"nonexistent.tar", 512));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
static int
archive_write_gnutar_header(struct archive_write *a,
struct archive_entry *entry)
{
char buff[512];
int r, ret, ret2 = ARCHIVE_OK;
int tartype;
struct gnutar *gnutar;
struct archive_string_conv *sconv;
struct archive_entry *entry_main;
gnutar = (struct gnutar *)a->format_data;
/* Setup default string conversion. */
if (gnutar->opt_sconv == NULL) {
if (!gnutar->init_default_conversion) {
gnutar->sconv_default =
archive_string_default_conversion_for_write(
&(a->archive));
gnutar->init_default_conversion = 1;
}
sconv = gnutar->sconv_default;
} else
sconv = gnutar->opt_sconv;
/* Only regular files (not hardlinks) have data. */
if (archive_entry_hardlink(entry) != NULL ||
archive_entry_symlink(entry) != NULL ||
!(archive_entry_filetype(entry) == AE_IFREG))
archive_entry_set_size(entry, 0);
if (AE_IFDIR == archive_entry_filetype(entry)) {
const char *p;
size_t path_length;
/*
* Ensure a trailing '/'. Modify the entry so
* the client sees the change.
*/
#if defined(_WIN32) && !defined(__CYGWIN__)
const wchar_t *wp;
wp = archive_entry_pathname_w(entry);
if (wp != NULL && wp[wcslen(wp) -1] != L'/') {
struct archive_wstring ws;
archive_string_init(&ws);
path_length = wcslen(wp);
if (archive_wstring_ensure(&ws,
path_length + 2) == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate ustar data");
archive_wstring_free(&ws);
return(ARCHIVE_FATAL);
}
/* Should we keep '\' ? */
if (wp[path_length -1] == L'\\')
path_length--;
archive_wstrncpy(&ws, wp, path_length);
archive_wstrappend_wchar(&ws, L'/');
archive_entry_copy_pathname_w(entry, ws.s);
archive_wstring_free(&ws);
p = NULL;
} else
#endif
p = archive_entry_pathname(entry);
/*
* On Windows, this is a backup operation just in
* case getting WCS failed. On POSIX, this is a
* normal operation.
*/
if (p != NULL && p[0] != '\0' && p[strlen(p) - 1] != '/') {
struct archive_string as;
archive_string_init(&as);
path_length = strlen(p);
if (archive_string_ensure(&as,
path_length + 2) == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate ustar data");
archive_string_free(&as);
return(ARCHIVE_FATAL);
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* NOTE: This might break the pathname
* if the current code page is CP932 and
* the pathname includes a character '\'
* as a part of its multibyte pathname. */
if (p[strlen(p) -1] == '\\')
path_length--;
else
#endif
archive_strncpy(&as, p, path_length);
archive_strappend_char(&as, '/');
archive_entry_copy_pathname(entry, as.s);
archive_string_free(&as);
}
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* Make sure the path separators in pathname, hardlink and symlink
* are all slash '/', not the Windows path separator '\'. */
entry_main = __la_win_entry_in_posix_pathseparator(entry);
if (entry_main == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate ustar data");
return(ARCHIVE_FATAL);
}
if (entry != entry_main)
entry = entry_main;
else
entry_main = NULL;
#else
entry_main = NULL;
#endif
r = archive_entry_pathname_l(entry, &(gnutar->pathname),
&(gnutar->pathname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Pathame");
ret = ARCHIVE_FATAL;
goto exit_write_header;
}
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;
}
r = archive_entry_uname_l(entry, &(gnutar->uname),
&(gnutar->uname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Uname");
ret = ARCHIVE_FATAL;
goto exit_write_header;
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate uname '%s' to %s",
archive_entry_uname(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
r = archive_entry_gname_l(entry, &(gnutar->gname),
&(gnutar->gname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Gname");
ret = ARCHIVE_FATAL;
goto exit_write_header;
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate gname '%s' to %s",
archive_entry_gname(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
/* If linkname is longer than 100 chars we need to add a 'K' header. */
r = archive_entry_hardlink_l(entry, &(gnutar->linkname),
&(gnutar->linkname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Linkname");
ret = ARCHIVE_FATAL;
goto exit_write_header;
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate linkname '%s' to %s",
archive_entry_hardlink(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
if (gnutar->linkname_length == 0) {
r = archive_entry_symlink_l(entry, &(gnutar->linkname),
&(gnutar->linkname_length), sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Linkname");
ret = ARCHIVE_FATAL;
goto exit_write_header;
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate linkname '%s' to %s",
archive_entry_hardlink(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
}
if (gnutar->linkname_length > GNUTAR_linkname_size) {
size_t length = gnutar->linkname_length + 1;
struct archive_entry *temp = archive_entry_new2(&a->archive);
/* Uname/gname here don't really matter since no one reads them;
* these are the values that GNU tar happens to use on FreeBSD. */
archive_entry_set_uname(temp, "root");
archive_entry_set_gname(temp, "wheel");
archive_entry_set_pathname(temp, "././@LongLink");
archive_entry_set_size(temp, length);
ret = archive_format_gnutar_header(a, buff, temp, 'K');
archive_entry_free(temp);
if (ret < ARCHIVE_WARN)
goto exit_write_header;
ret = __archive_write_output(a, buff, 512);
if (ret < ARCHIVE_WARN)
goto exit_write_header;
/* Write name and trailing null byte. */
ret = __archive_write_output(a, gnutar->linkname, length);
if (ret < ARCHIVE_WARN)
goto exit_write_header;
/* Pad to 512 bytes */
ret = __archive_write_nulls(a, 0x1ff & (-(ssize_t)length));
if (ret < ARCHIVE_WARN)
goto exit_write_header;
}
/* If pathname is longer than 100 chars we need to add an 'L' header. */
if (gnutar->pathname_length > GNUTAR_name_size) {
const char *pathname = gnutar->pathname;
size_t length = gnutar->pathname_length + 1;
struct archive_entry *temp = archive_entry_new2(&a->archive);
/* Uname/gname here don't really matter since no one reads them;
* these are the values that GNU tar happens to use on FreeBSD. */
archive_entry_set_uname(temp, "root");
archive_entry_set_gname(temp, "wheel");
archive_entry_set_pathname(temp, "././@LongLink");
archive_entry_set_size(temp, length);
ret = archive_format_gnutar_header(a, buff, temp, 'L');
archive_entry_free(temp);
if (ret < ARCHIVE_WARN)
goto exit_write_header;
ret = __archive_write_output(a, buff, 512);
if(ret < ARCHIVE_WARN)
goto exit_write_header;
/* Write pathname + trailing null byte. */
ret = __archive_write_output(a, pathname, length);
if(ret < ARCHIVE_WARN)
goto exit_write_header;
/* Pad to multiple of 512 bytes. */
ret = __archive_write_nulls(a, 0x1ff & (-(ssize_t)length));
if (ret < ARCHIVE_WARN)
goto exit_write_header;
}
if (archive_entry_hardlink(entry) != NULL) {
tartype = '1';
} else
switch (archive_entry_filetype(entry)) {
case AE_IFREG: tartype = '0' ; break;
case AE_IFLNK: tartype = '2' ; break;
case AE_IFCHR: tartype = '3' ; break;
case AE_IFBLK: tartype = '4' ; break;
case AE_IFDIR: tartype = '5' ; break;
case AE_IFIFO: tartype = '6' ; break;
case AE_IFSOCK:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"tar format cannot archive socket");
ret = ARCHIVE_FAILED;
goto exit_write_header;
default:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"tar format cannot archive this (mode=0%lo)",
(unsigned long)archive_entry_mode(entry));
ret = ARCHIVE_FAILED;
goto exit_write_header;
}
ret = archive_format_gnutar_header(a, buff, entry, tartype);
if (ret < ARCHIVE_WARN)
goto exit_write_header;
if (ret2 < ret)
ret = ret2;
ret2 = __archive_write_output(a, buff, 512);
if (ret2 < ARCHIVE_WARN) {
ret = ret2;
goto exit_write_header;
}
if (ret2 < ret)
ret = ret2;
gnutar->entry_bytes_remaining = archive_entry_size(entry);
gnutar->entry_padding = 0x1ff & (-(int64_t)gnutar->entry_bytes_remaining);
exit_write_header:
archive_entry_free(entry_main);
return (ret);
}
/*
* Create an entry starting from a wide-character Unicode pathname,
* read it back into "C" locale, which doesn't support the name.
* TODO: Figure out the "right" behavior here.
*/
static void
test_pax_filename_encoding_3(void)
{
wchar_t badname[] = L"xxxAyyyBzzz";
const char badname_utf8[] = "xxx\xE1\x88\xB4yyy\xE5\x99\xB8zzz";
struct archive *a;
struct archive_entry *entry;
char buff[65536];
size_t used;
badname[3] = 0x1234;
badname[7] = 0x5678;
/* If it doesn't exist, just warn and return. */
if (NULL == setlocale(LC_ALL, "C")) {
skipping("Can't set \"C\" locale, so can't exercise "
"certain character-conversion failures");
return;
}
/* If wctomb is broken, warn and return. */
if (wctomb(buff, 0x1234) > 0) {
skipping("Cannot test conversion failures because \"C\" "
"locale on this system has no invalid characters.");
return;
}
/* If wctomb is broken, warn and return. */
if (wctomb(buff, 0x1234) > 0) {
skipping("Cannot test conversion failures because \"C\" "
"locale on this system has no invalid characters.");
return;
}
/* Skip test if archive_entry_update_pathname_utf8() is broken. */
/* In particular, this is currently broken on Win32 because
* setlocale() does not set the default encoding for CP_ACP. */
entry = archive_entry_new();
if (archive_entry_update_pathname_utf8(entry, badname_utf8)) {
archive_entry_free(entry);
skipping("Cannot test conversion failures.");
return;
}
archive_entry_free(entry);
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, 0, archive_write_set_format_pax(a));
assertEqualIntA(a, 0, archive_write_add_filter_none(a));
assertEqualIntA(a, 0, archive_write_set_bytes_per_block(a, 0));
assertEqualInt(0,
archive_write_open_memory(a, buff, sizeof(buff), &used));
assert((entry = archive_entry_new()) != NULL);
/* Set pathname to non-convertible wide value. */
archive_entry_copy_pathname_w(entry, badname);
archive_entry_set_filetype(entry, AE_IFREG);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assert((entry = archive_entry_new()) != NULL);
archive_entry_copy_pathname_w(entry, L"abc");
/* Set gname to non-convertible wide value. */
archive_entry_copy_gname_w(entry, badname);
archive_entry_set_filetype(entry, AE_IFREG);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assert((entry = archive_entry_new()) != NULL);
archive_entry_copy_pathname_w(entry, L"abc");
/* Set uname to non-convertible wide value. */
archive_entry_copy_uname_w(entry, badname);
archive_entry_set_filetype(entry, AE_IFREG);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assert((entry = archive_entry_new()) != NULL);
archive_entry_copy_pathname_w(entry, L"abc");
/* Set hardlink to non-convertible wide value. */
archive_entry_copy_hardlink_w(entry, badname);
archive_entry_set_filetype(entry, AE_IFREG);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assert((entry = archive_entry_new()) != NULL);
archive_entry_copy_pathname_w(entry, L"abc");
/* Set symlink to non-convertible wide value. */
archive_entry_copy_symlink_w(entry, badname);
archive_entry_set_filetype(entry, AE_IFLNK);
assertEqualInt(ARCHIVE_OK, archive_write_header(a, entry));
archive_entry_free(entry);
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now read the entries back.
*/
assert((a = archive_read_new()) != NULL);
assertEqualInt(0, archive_read_support_format_tar(a));
assertEqualInt(0, archive_read_open_memory(a, buff, used));
failure("A non-convertible pathname should cause a warning.");
assertEqualInt(ARCHIVE_WARN, archive_read_next_header(a, &entry));
assertEqualWString(badname, archive_entry_pathname_w(entry));
failure("If native locale can't convert, we should get UTF-8 back.");
assertEqualString(badname_utf8, archive_entry_pathname(entry));
failure("A non-convertible gname should cause a warning.");
assertEqualInt(ARCHIVE_WARN, archive_read_next_header(a, &entry));
assertEqualWString(badname, archive_entry_gname_w(entry));
failure("If native locale can't convert, we should get UTF-8 back.");
assertEqualString(badname_utf8, archive_entry_gname(entry));
failure("A non-convertible uname should cause a warning.");
assertEqualInt(ARCHIVE_WARN, archive_read_next_header(a, &entry));
assertEqualWString(badname, archive_entry_uname_w(entry));
failure("If native locale can't convert, we should get UTF-8 back.");
assertEqualString(badname_utf8, archive_entry_uname(entry));
failure("A non-convertible hardlink should cause a warning.");
assertEqualInt(ARCHIVE_WARN, archive_read_next_header(a, &entry));
assertEqualWString(badname, archive_entry_hardlink_w(entry));
failure("If native locale can't convert, we should get UTF-8 back.");
assertEqualString(badname_utf8, archive_entry_hardlink(entry));
failure("A non-convertible symlink should cause a warning.");
assertEqualInt(ARCHIVE_WARN, archive_read_next_header(a, &entry));
assertEqualWString(badname, archive_entry_symlink_w(entry));
assertEqualWString(NULL, archive_entry_hardlink_w(entry));
failure("If native locale can't convert, we should get UTF-8 back.");
assertEqualString(badname_utf8, archive_entry_symlink(entry));
assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &entry));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
static int
archive_write_v7tar_header(struct archive_write *a, struct archive_entry *entry)
{
char buff[512];
int ret, ret2;
struct v7tar *v7tar;
struct archive_entry *entry_main;
struct archive_string_conv *sconv;
v7tar = (struct v7tar *)a->format_data;
/* Setup default string conversion. */
if (v7tar->opt_sconv == NULL) {
if (!v7tar->init_default_conversion) {
v7tar->sconv_default =
archive_string_default_conversion_for_write(
&(a->archive));
v7tar->init_default_conversion = 1;
}
sconv = v7tar->sconv_default;
} else
sconv = v7tar->opt_sconv;
/* Sanity check. */
if (archive_entry_pathname(entry) == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Can't record entry in tar file without pathname");
return (ARCHIVE_FAILED);
}
/* Only regular files (not hardlinks) have data. */
if (archive_entry_hardlink(entry) != NULL ||
archive_entry_symlink(entry) != NULL ||
!(archive_entry_filetype(entry) == AE_IFREG))
archive_entry_set_size(entry, 0);
if (AE_IFDIR == archive_entry_filetype(entry)) {
const char *p;
size_t path_length;
/*
* Ensure a trailing '/'. Modify the entry so
* the client sees the change.
*/
#if defined(_WIN32) && !defined(__CYGWIN__)
const wchar_t *wp;
wp = archive_entry_pathname_w(entry);
if (wp != NULL && wp[wcslen(wp) -1] != L'/') {
struct archive_wstring ws;
archive_string_init(&ws);
path_length = wcslen(wp);
if (archive_wstring_ensure(&ws,
path_length + 2) == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate v7tar data");
archive_wstring_free(&ws);
return(ARCHIVE_FATAL);
}
/* Should we keep '\' ? */
if (wp[path_length -1] == L'\\')
path_length--;
archive_wstrncpy(&ws, wp, path_length);
archive_wstrappend_wchar(&ws, L'/');
archive_entry_copy_pathname_w(entry, ws.s);
archive_wstring_free(&ws);
p = NULL;
} else
#endif
p = archive_entry_pathname(entry);
/*
* On Windows, this is a backup operation just in
* case getting WCS failed. On POSIX, this is a
* normal operation.
*/
if (p != NULL && p[strlen(p) - 1] != '/') {
struct archive_string as;
archive_string_init(&as);
path_length = strlen(p);
if (archive_string_ensure(&as,
path_length + 2) == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate v7tar data");
archive_string_free(&as);
return(ARCHIVE_FATAL);
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* NOTE: This might break the pathname
* if the current code page is CP932 and
* the pathname includes a character '\'
* as a part of its multibyte pathname. */
if (p[strlen(p) -1] == '\\')
path_length--;
else
#endif
archive_strncpy(&as, p, path_length);
archive_strappend_char(&as, '/');
archive_entry_copy_pathname(entry, as.s);
archive_string_free(&as);
}
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* Make sure the path separators in pahtname, hardlink and symlink
* are all slash '/', not the Windows path separator '\'. */
entry_main = __la_win_entry_in_posix_pathseparator(entry);
if (entry_main == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate v7tar data");
return(ARCHIVE_FATAL);
}
if (entry != entry_main)
entry = entry_main;
else
entry_main = NULL;
#else
entry_main = NULL;
#endif
ret = format_header_v7tar(a, buff, entry, 1, sconv);
if (ret < ARCHIVE_WARN) {
if (entry_main)
archive_entry_free(entry_main);
return (ret);
}
ret2 = __archive_write_output(a, buff, 512);
if (ret2 < ARCHIVE_WARN) {
if (entry_main)
archive_entry_free(entry_main);
return (ret2);
}
if (ret2 < ret)
ret = ret2;
v7tar->entry_bytes_remaining = archive_entry_size(entry);
v7tar->entry_padding = 0x1ff & (-(int64_t)v7tar->entry_bytes_remaining);
if (entry_main)
archive_entry_free(entry_main);
return (ret);
}
