diff options
Diffstat (limited to 'contrib/libarchive/libarchive/test/test_entry.c')
| -rw-r--r-- | contrib/libarchive/libarchive/test/test_entry.c | 903 |
1 files changed, 903 insertions, 0 deletions
diff --git a/contrib/libarchive/libarchive/test/test_entry.c b/contrib/libarchive/libarchive/test/test_entry.c new file mode 100644 index 0000000..bf36cbe --- /dev/null +++ b/contrib/libarchive/libarchive/test/test_entry.c @@ -0,0 +1,903 @@ +/*- + * Copyright (c) 2003-2007 Tim Kientzle + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#include "test.h" +__FBSDID("$FreeBSD: head/lib/libarchive/test/test_entry.c 201247 2009-12-30 05:59:21Z kientzle $"); + +#include <locale.h> + +#ifndef HAVE_WCSCPY +static wchar_t * wcscpy(wchar_t *s1, const wchar_t *s2) +{ + wchar_t *dest = s1; + while ((*s1 = *s2) != L'\0') + ++s1, ++s2; + return dest; +} +#endif + +/* + * Most of these tests are system-independent, though a few depend on + * features of the local system. Such tests are conditionalized on + * the platform name. On unsupported platforms, only the + * system-independent features will be tested. + * + * No, I don't want to use config.h in the test files because I want + * the tests to also serve as a check on the correctness of config.h. + * A mis-configured library build should cause tests to fail. + */ + +DEFINE_TEST(test_entry) +{ + char buff[128]; + wchar_t wbuff[128]; + struct stat st; + struct archive_entry *e, *e2; + const struct stat *pst; + unsigned long set, clear; /* For fflag testing. */ + int type, permset, tag, qual; /* For ACL testing. */ + const char *name; /* For ACL testing. */ + const char *xname; /* For xattr tests. */ + const void *xval; /* For xattr tests. */ + size_t xsize; /* For xattr tests. */ + wchar_t wc; + long l; + + assert((e = archive_entry_new()) != NULL); + + /* + * Verify that the AE_IF* defines match S_IF* defines + * on this platform. See comments in archive_entry.h. + */ +#ifdef S_IFREG + assertEqualInt(S_IFREG, AE_IFREG); +#endif +#ifdef S_IFLNK + assertEqualInt(S_IFLNK, AE_IFLNK); +#endif +#ifdef S_IFSOCK + assertEqualInt(S_IFSOCK, AE_IFSOCK); +#endif +#ifdef S_IFCHR + assertEqualInt(S_IFCHR, AE_IFCHR); +#endif +/* Work around MinGW, which defines S_IFBLK wrong. */ +/* sourceforge.net/tracker/?func=detail&atid=102435&aid=1942809&group_id=2435 */ +#if defined(S_IFBLK) && !defined(_WIN32) + assertEqualInt(S_IFBLK, AE_IFBLK); +#endif +#ifdef S_IFDIR + assertEqualInt(S_IFDIR, AE_IFDIR); +#endif +#ifdef S_IFIFO + assertEqualInt(S_IFIFO, AE_IFIFO); +#endif + + /* + * Basic set/read tests for all fields. + * We should be able to set any field and read + * back the same value. + * + * For methods that "copy" a string, we should be able + * to overwrite the original passed-in string without + * changing the value in the entry. + * + * The following tests are ordered alphabetically by the + * name of the field. + */ + + /* atime */ + archive_entry_set_atime(e, 13579, 24680); + assertEqualInt(archive_entry_atime(e), 13579); + assertEqualInt(archive_entry_atime_nsec(e), 24680); + archive_entry_unset_atime(e); + assertEqualInt(archive_entry_atime(e), 0); + assertEqualInt(archive_entry_atime_nsec(e), 0); + assert(!archive_entry_atime_is_set(e)); + + /* birthtime */ + archive_entry_set_birthtime(e, 17579, 24990); + assertEqualInt(archive_entry_birthtime(e), 17579); + assertEqualInt(archive_entry_birthtime_nsec(e), 24990); + archive_entry_unset_birthtime(e); + assertEqualInt(archive_entry_birthtime(e), 0); + assertEqualInt(archive_entry_birthtime_nsec(e), 0); + assert(!archive_entry_birthtime_is_set(e)); + + /* ctime */ + archive_entry_set_ctime(e, 13580, 24681); + assertEqualInt(archive_entry_ctime(e), 13580); + assertEqualInt(archive_entry_ctime_nsec(e), 24681); + archive_entry_unset_ctime(e); + assertEqualInt(archive_entry_ctime(e), 0); + assertEqualInt(archive_entry_ctime_nsec(e), 0); + assert(!archive_entry_ctime_is_set(e)); + +#if ARCHIVE_VERSION_NUMBER >= 1009000 + /* dev */ + archive_entry_set_dev(e, 235); + assertEqualInt(archive_entry_dev(e), 235); +#else + skipping("archive_entry_dev()"); +#endif + /* devmajor/devminor are tested specially below. */ + +#if ARCHIVE_VERSION_NUMBER >= 1009000 + /* filetype */ + archive_entry_set_filetype(e, AE_IFREG); + assertEqualInt(archive_entry_filetype(e), AE_IFREG); +#else + skipping("archive_entry_filetype()"); +#endif + + /* fflags are tested specially below */ + + /* gid */ + archive_entry_set_gid(e, 204); + assertEqualInt(archive_entry_gid(e), 204); + + /* gname */ + archive_entry_set_gname(e, "group"); + assertEqualString(archive_entry_gname(e), "group"); + wcscpy(wbuff, L"wgroup"); + archive_entry_copy_gname_w(e, wbuff); + assertEqualWString(archive_entry_gname_w(e), L"wgroup"); + memset(wbuff, 0, sizeof(wbuff)); + assertEqualWString(archive_entry_gname_w(e), L"wgroup"); + + /* hardlink */ + archive_entry_set_hardlink(e, "hardlinkname"); + assertEqualString(archive_entry_hardlink(e), "hardlinkname"); + strcpy(buff, "hardlinkname2"); + archive_entry_copy_hardlink(e, buff); + assertEqualString(archive_entry_hardlink(e), "hardlinkname2"); + memset(buff, 0, sizeof(buff)); + assertEqualString(archive_entry_hardlink(e), "hardlinkname2"); + archive_entry_copy_hardlink(e, NULL); + assertEqualString(archive_entry_hardlink(e), NULL); + assertEqualWString(archive_entry_hardlink_w(e), NULL); + wcscpy(wbuff, L"whardlink"); + archive_entry_copy_hardlink_w(e, wbuff); + assertEqualWString(archive_entry_hardlink_w(e), L"whardlink"); + memset(wbuff, 0, sizeof(wbuff)); + assertEqualWString(archive_entry_hardlink_w(e), L"whardlink"); + archive_entry_copy_hardlink_w(e, NULL); + assertEqualString(archive_entry_hardlink(e), NULL); + assertEqualWString(archive_entry_hardlink_w(e), NULL); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + /* ino */ + archive_entry_set_ino(e, 8593); + assertEqualInt(archive_entry_ino(e), 8593); +#else + skipping("archive_entry_ino()"); +#endif + + /* link */ + archive_entry_set_hardlink(e, "hardlinkname"); + archive_entry_set_symlink(e, NULL); + archive_entry_set_link(e, "link"); + assertEqualString(archive_entry_hardlink(e), "link"); + assertEqualString(archive_entry_symlink(e), NULL); + archive_entry_copy_link(e, "link2"); + assertEqualString(archive_entry_hardlink(e), "link2"); + assertEqualString(archive_entry_symlink(e), NULL); + archive_entry_copy_link_w(e, L"link3"); + assertEqualString(archive_entry_hardlink(e), "link3"); + assertEqualString(archive_entry_symlink(e), NULL); + archive_entry_set_hardlink(e, NULL); + archive_entry_set_symlink(e, "symlink"); + archive_entry_set_link(e, "link"); + assertEqualString(archive_entry_hardlink(e), NULL); + assertEqualString(archive_entry_symlink(e), "link"); + archive_entry_copy_link(e, "link2"); + assertEqualString(archive_entry_hardlink(e), NULL); + assertEqualString(archive_entry_symlink(e), "link2"); + archive_entry_copy_link_w(e, L"link3"); + assertEqualString(archive_entry_hardlink(e), NULL); + assertEqualString(archive_entry_symlink(e), "link3"); + /* Arbitrarily override symlink if both hardlink and symlink set. */ + archive_entry_set_hardlink(e, "hardlink"); + archive_entry_set_symlink(e, "symlink"); + archive_entry_set_link(e, "link"); + assertEqualString(archive_entry_hardlink(e), "hardlink"); + assertEqualString(archive_entry_symlink(e), "link"); + + /* mode */ + archive_entry_set_mode(e, 0123456); + assertEqualInt(archive_entry_mode(e), 0123456); + + /* mtime */ + archive_entry_set_mtime(e, 13581, 24682); + assertEqualInt(archive_entry_mtime(e), 13581); + assertEqualInt(archive_entry_mtime_nsec(e), 24682); + archive_entry_unset_mtime(e); + assertEqualInt(archive_entry_mtime(e), 0); + assertEqualInt(archive_entry_mtime_nsec(e), 0); + assert(!archive_entry_mtime_is_set(e)); + +#if ARCHIVE_VERSION_NUMBER >= 1009000 + /* nlink */ + archive_entry_set_nlink(e, 736); + assertEqualInt(archive_entry_nlink(e), 736); +#else + skipping("archive_entry_nlink()"); +#endif + + /* pathname */ + archive_entry_set_pathname(e, "path"); + assertEqualString(archive_entry_pathname(e), "path"); + archive_entry_set_pathname(e, "path"); + assertEqualString(archive_entry_pathname(e), "path"); + strcpy(buff, "path2"); + archive_entry_copy_pathname(e, buff); + assertEqualString(archive_entry_pathname(e), "path2"); + memset(buff, 0, sizeof(buff)); + assertEqualString(archive_entry_pathname(e), "path2"); + wcscpy(wbuff, L"wpath"); + archive_entry_copy_pathname_w(e, wbuff); + assertEqualWString(archive_entry_pathname_w(e), L"wpath"); + memset(wbuff, 0, sizeof(wbuff)); + assertEqualWString(archive_entry_pathname_w(e), L"wpath"); + +#if ARCHIVE_VERSION_NUMBER >= 1009000 + /* rdev */ + archive_entry_set_rdev(e, 532); + assertEqualInt(archive_entry_rdev(e), 532); +#else + skipping("archive_entry_rdev()"); +#endif + /* rdevmajor/rdevminor are tested specially below. */ + + /* size */ + archive_entry_set_size(e, 987654321); + assertEqualInt(archive_entry_size(e), 987654321); + archive_entry_unset_size(e); + assertEqualInt(archive_entry_size(e), 0); + assert(!archive_entry_size_is_set(e)); + + /* sourcepath */ + archive_entry_copy_sourcepath(e, "path1"); + assertEqualString(archive_entry_sourcepath(e), "path1"); + + /* symlink */ + archive_entry_set_symlink(e, "symlinkname"); + assertEqualString(archive_entry_symlink(e), "symlinkname"); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + strcpy(buff, "symlinkname2"); + archive_entry_copy_symlink(e, buff); + assertEqualString(archive_entry_symlink(e), "symlinkname2"); + memset(buff, 0, sizeof(buff)); + assertEqualString(archive_entry_symlink(e), "symlinkname2"); +#endif + archive_entry_copy_symlink_w(e, NULL); + assertEqualWString(archive_entry_symlink_w(e), NULL); + assertEqualString(archive_entry_symlink(e), NULL); + archive_entry_copy_symlink_w(e, L"wsymlink"); + assertEqualWString(archive_entry_symlink_w(e), L"wsymlink"); + archive_entry_copy_symlink(e, NULL); + assertEqualWString(archive_entry_symlink_w(e), NULL); + assertEqualString(archive_entry_symlink(e), NULL); + + /* uid */ + archive_entry_set_uid(e, 83); + assertEqualInt(archive_entry_uid(e), 83); + + /* uname */ + archive_entry_set_uname(e, "user"); + assertEqualString(archive_entry_uname(e), "user"); + wcscpy(wbuff, L"wuser"); + archive_entry_copy_gname_w(e, wbuff); + assertEqualWString(archive_entry_gname_w(e), L"wuser"); + memset(wbuff, 0, sizeof(wbuff)); + assertEqualWString(archive_entry_gname_w(e), L"wuser"); + + /* Test fflags interface. */ + archive_entry_set_fflags(e, 0x55, 0xAA); + archive_entry_fflags(e, &set, &clear); + failure("Testing set/get of fflags data."); + assertEqualInt(set, 0x55); + failure("Testing set/get of fflags data."); + assertEqualInt(clear, 0xAA); +#ifdef __FreeBSD__ + /* Converting fflags bitmap to string is currently system-dependent. */ + /* TODO: Make this system-independent. */ + assertEqualString(archive_entry_fflags_text(e), + "uappnd,nouchg,nodump,noopaque,uunlnk"); + /* Test archive_entry_copy_fflags_text_w() */ + archive_entry_copy_fflags_text_w(e, L" ,nouappnd, nouchg, dump,uunlnk"); + archive_entry_fflags(e, &set, &clear); + assertEqualInt(16, set); + assertEqualInt(7, clear); + /* Test archive_entry_copy_fflags_text() */ + archive_entry_copy_fflags_text(e, " ,nouappnd, nouchg, dump,uunlnk"); + archive_entry_fflags(e, &set, &clear); + assertEqualInt(16, set); + assertEqualInt(7, clear); +#endif + + /* See test_acl_basic.c for tests of ACL set/get consistency. */ + + /* Test xattrs set/get consistency. */ + archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue1", 12); + assertEqualInt(1, archive_entry_xattr_reset(e)); + assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize)); + assertEqualString(xname, "xattr1"); + assertEqualString(xval, "xattrvalue1"); + assertEqualInt((int)xsize, 12); + assertEqualInt(1, archive_entry_xattr_count(e)); + assertEqualInt(ARCHIVE_WARN, + archive_entry_xattr_next(e, &xname, &xval, &xsize)); + assertEqualString(xname, NULL); + assertEqualString(xval, NULL); + assertEqualInt((int)xsize, 0); + archive_entry_xattr_clear(e); + assertEqualInt(0, archive_entry_xattr_reset(e)); + assertEqualInt(ARCHIVE_WARN, + archive_entry_xattr_next(e, &xname, &xval, &xsize)); + assertEqualString(xname, NULL); + assertEqualString(xval, NULL); + assertEqualInt((int)xsize, 0); + archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue1", 12); + assertEqualInt(1, archive_entry_xattr_reset(e)); + archive_entry_xattr_add_entry(e, "xattr2", "xattrvalue2", 12); + assertEqualInt(2, archive_entry_xattr_reset(e)); + assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize)); + assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize)); + assertEqualInt(ARCHIVE_WARN, + archive_entry_xattr_next(e, &xname, &xval, &xsize)); + assertEqualString(xname, NULL); + assertEqualString(xval, NULL); + assertEqualInt((int)xsize, 0); + + + /* + * Test clone() implementation. + */ + + /* Set values in 'e' */ + archive_entry_clear(e); + archive_entry_set_atime(e, 13579, 24680); + archive_entry_set_birthtime(e, 13779, 24990); + archive_entry_set_ctime(e, 13580, 24681); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + archive_entry_set_dev(e, 235); +#endif + archive_entry_set_fflags(e, 0x55, 0xAA); + archive_entry_set_gid(e, 204); + archive_entry_set_gname(e, "group"); + archive_entry_set_hardlink(e, "hardlinkname"); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + archive_entry_set_ino(e, 8593); +#endif + archive_entry_set_mode(e, 0123456); + archive_entry_set_mtime(e, 13581, 24682); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + archive_entry_set_nlink(e, 736); +#endif + archive_entry_set_pathname(e, "path"); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + archive_entry_set_rdev(e, 532); +#endif + archive_entry_set_size(e, 987654321); + archive_entry_copy_sourcepath(e, "source"); + archive_entry_set_symlink(e, "symlinkname"); + archive_entry_set_uid(e, 83); + archive_entry_set_uname(e, "user"); + /* Add an ACL entry. */ + archive_entry_acl_add_entry(e, ARCHIVE_ENTRY_ACL_TYPE_ACCESS, + ARCHIVE_ENTRY_ACL_READ, ARCHIVE_ENTRY_ACL_USER, 77, "user77"); + /* Add an extended attribute. */ + archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue", 11); + + /* Make a clone. */ + e2 = archive_entry_clone(e); + + /* Clone should have same contents. */ + assertEqualInt(archive_entry_atime(e2), 13579); + assertEqualInt(archive_entry_atime_nsec(e2), 24680); + assertEqualInt(archive_entry_birthtime(e2), 13779); + assertEqualInt(archive_entry_birthtime_nsec(e2), 24990); + assertEqualInt(archive_entry_ctime(e2), 13580); + assertEqualInt(archive_entry_ctime_nsec(e2), 24681); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + assertEqualInt(archive_entry_dev(e2), 235); +#endif + archive_entry_fflags(e, &set, &clear); + assertEqualInt(clear, 0xAA); + assertEqualInt(set, 0x55); + assertEqualInt(archive_entry_gid(e2), 204); + assertEqualString(archive_entry_gname(e2), "group"); + assertEqualString(archive_entry_hardlink(e2), "hardlinkname"); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + assertEqualInt(archive_entry_ino(e2), 8593); +#endif + assertEqualInt(archive_entry_mode(e2), 0123456); + assertEqualInt(archive_entry_mtime(e2), 13581); + assertEqualInt(archive_entry_mtime_nsec(e2), 24682); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + assertEqualInt(archive_entry_nlink(e2), 736); +#endif + assertEqualString(archive_entry_pathname(e2), "path"); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + assertEqualInt(archive_entry_rdev(e2), 532); +#endif + assertEqualInt(archive_entry_size(e2), 987654321); + assertEqualString(archive_entry_sourcepath(e2), "source"); + assertEqualString(archive_entry_symlink(e2), "symlinkname"); + assertEqualInt(archive_entry_uid(e2), 83); + assertEqualString(archive_entry_uname(e2), "user"); +#if ARCHIVE_VERSION_NUMBER < 1009000 + skipping("ACL preserved by archive_entry_clone()"); +#else + /* Verify ACL was copied. */ + assertEqualInt(4, archive_entry_acl_reset(e2, + ARCHIVE_ENTRY_ACL_TYPE_ACCESS)); + /* First three are standard permission bits. */ + assertEqualInt(0, archive_entry_acl_next(e2, + ARCHIVE_ENTRY_ACL_TYPE_ACCESS, + &type, &permset, &tag, &qual, &name)); + assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS); + assertEqualInt(permset, 4); + assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER_OBJ); + assertEqualInt(qual, -1); + assertEqualString(name, NULL); + assertEqualInt(0, archive_entry_acl_next(e2, + ARCHIVE_ENTRY_ACL_TYPE_ACCESS, + &type, &permset, &tag, &qual, &name)); + assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS); + assertEqualInt(permset, 5); + assertEqualInt(tag, ARCHIVE_ENTRY_ACL_GROUP_OBJ); + assertEqualInt(qual, -1); + assertEqualString(name, NULL); + assertEqualInt(0, archive_entry_acl_next(e2, + ARCHIVE_ENTRY_ACL_TYPE_ACCESS, + &type, &permset, &tag, &qual, &name)); + assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS); + assertEqualInt(permset, 6); + assertEqualInt(tag, ARCHIVE_ENTRY_ACL_OTHER); + assertEqualInt(qual, -1); + assertEqualString(name, NULL); + /* Fourth is custom one. */ + assertEqualInt(0, archive_entry_acl_next(e2, + ARCHIVE_ENTRY_ACL_TYPE_ACCESS, + &type, &permset, &tag, &qual, &name)); + assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS); + assertEqualInt(permset, ARCHIVE_ENTRY_ACL_READ); + assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER); + assertEqualInt(qual, 77); + assertEqualString(name, "user77"); +#endif +#if ARCHIVE_VERSION_NUMBER < 1009000 + skipping("xattr data preserved by archive_entry_clone"); +#else + /* Verify xattr was copied. */ + assertEqualInt(1, archive_entry_xattr_reset(e2)); + assertEqualInt(0, archive_entry_xattr_next(e2, &xname, &xval, &xsize)); + assertEqualString(xname, "xattr1"); + assertEqualString(xval, "xattrvalue"); + assertEqualInt((int)xsize, 11); + assertEqualInt(ARCHIVE_WARN, + archive_entry_xattr_next(e2, &xname, &xval, &xsize)); + assertEqualString(xname, NULL); + assertEqualString(xval, NULL); + assertEqualInt((int)xsize, 0); +#endif + + /* Change the original */ + archive_entry_set_atime(e, 13580, 24690); + archive_entry_set_birthtime(e, 13980, 24999); + archive_entry_set_ctime(e, 13590, 24691); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + archive_entry_set_dev(e, 245); +#endif + archive_entry_set_fflags(e, 0x85, 0xDA); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + archive_entry_set_filetype(e, AE_IFLNK); +#endif + archive_entry_set_gid(e, 214); + archive_entry_set_gname(e, "grouper"); + archive_entry_set_hardlink(e, "hardlinkpath"); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + archive_entry_set_ino(e, 8763); +#endif + archive_entry_set_mode(e, 0123654); + archive_entry_set_mtime(e, 18351, 28642); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + archive_entry_set_nlink(e, 73); +#endif + archive_entry_set_pathname(e, "pathest"); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + archive_entry_set_rdev(e, 132); +#endif + archive_entry_set_size(e, 987456321); + archive_entry_copy_sourcepath(e, "source2"); + archive_entry_set_symlink(e, "symlinkpath"); + archive_entry_set_uid(e, 93); + archive_entry_set_uname(e, "username"); + archive_entry_acl_clear(e); + archive_entry_xattr_clear(e); + + /* Clone should still have same contents. */ + assertEqualInt(archive_entry_atime(e2), 13579); + assertEqualInt(archive_entry_atime_nsec(e2), 24680); + assertEqualInt(archive_entry_birthtime(e2), 13779); + assertEqualInt(archive_entry_birthtime_nsec(e2), 24990); + assertEqualInt(archive_entry_ctime(e2), 13580); + assertEqualInt(archive_entry_ctime_nsec(e2), 24681); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + assertEqualInt(archive_entry_dev(e2), 235); +#endif + archive_entry_fflags(e2, &set, &clear); + assertEqualInt(clear, 0xAA); + assertEqualInt(set, 0x55); + assertEqualInt(archive_entry_gid(e2), 204); + assertEqualString(archive_entry_gname(e2), "group"); + assertEqualString(archive_entry_hardlink(e2), "hardlinkname"); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + assertEqualInt(archive_entry_ino(e2), 8593); +#endif + assertEqualInt(archive_entry_mode(e2), 0123456); + assertEqualInt(archive_entry_mtime(e2), 13581); + assertEqualInt(archive_entry_mtime_nsec(e2), 24682); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + assertEqualInt(archive_entry_nlink(e2), 736); +#endif + assertEqualString(archive_entry_pathname(e2), "path"); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + assertEqualInt(archive_entry_rdev(e2), 532); +#endif + assertEqualInt(archive_entry_size(e2), 987654321); + assertEqualString(archive_entry_sourcepath(e2), "source"); + assertEqualString(archive_entry_symlink(e2), "symlinkname"); + assertEqualInt(archive_entry_uid(e2), 83); + assertEqualString(archive_entry_uname(e2), "user"); +#if ARCHIVE_VERSION_NUMBER < 1009000 + skipping("ACL held by clone of archive_entry"); +#else + /* Verify ACL was unchanged. */ + assertEqualInt(4, archive_entry_acl_reset(e2, + ARCHIVE_ENTRY_ACL_TYPE_ACCESS)); + /* First three are standard permission bits. */ + assertEqualInt(0, archive_entry_acl_next(e2, + ARCHIVE_ENTRY_ACL_TYPE_ACCESS, + &type, &permset, &tag, &qual, &name)); + assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS); + assertEqualInt(permset, 4); + assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER_OBJ); + assertEqualInt(qual, -1); + assertEqualString(name, NULL); + assertEqualInt(0, archive_entry_acl_next(e2, + ARCHIVE_ENTRY_ACL_TYPE_ACCESS, + &type, &permset, &tag, &qual, &name)); + assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS); + assertEqualInt(permset, 5); + assertEqualInt(tag, ARCHIVE_ENTRY_ACL_GROUP_OBJ); + assertEqualInt(qual, -1); + assertEqualString(name, NULL); + assertEqualInt(0, archive_entry_acl_next(e2, + ARCHIVE_ENTRY_ACL_TYPE_ACCESS, + &type, &permset, &tag, &qual, &name)); + assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS); + assertEqualInt(permset, 6); + assertEqualInt(tag, ARCHIVE_ENTRY_ACL_OTHER); + assertEqualInt(qual, -1); + assertEqualString(name, NULL); + /* Fourth is custom one. */ + assertEqualInt(0, archive_entry_acl_next(e2, + ARCHIVE_ENTRY_ACL_TYPE_ACCESS, + &type, &permset, &tag, &qual, &name)); + assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS); + assertEqualInt(permset, ARCHIVE_ENTRY_ACL_READ); + assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER); + assertEqualInt(qual, 77); + assertEqualString(name, "user77"); + assertEqualInt(1, archive_entry_acl_next(e2, + ARCHIVE_ENTRY_ACL_TYPE_ACCESS, + &type, &permset, &tag, &qual, &name)); + assertEqualInt(type, 0); + assertEqualInt(permset, 0); + assertEqualInt(tag, 0); + assertEqualInt(qual, -1); + assertEqualString(name, NULL); +#endif +#if ARCHIVE_VERSION_NUMBER < 1009000 + skipping("xattr preserved in archive_entry copy"); +#else + /* Verify xattr was unchanged. */ + assertEqualInt(1, archive_entry_xattr_reset(e2)); +#endif + + /* Release clone. */ + archive_entry_free(e2); + + /* + * Test clear() implementation. + */ + archive_entry_clear(e); + assertEqualInt(archive_entry_atime(e), 0); + assertEqualInt(archive_entry_atime_nsec(e), 0); + assertEqualInt(archive_entry_birthtime(e), 0); + assertEqualInt(archive_entry_birthtime_nsec(e), 0); + assertEqualInt(archive_entry_ctime(e), 0); + assertEqualInt(archive_entry_ctime_nsec(e), 0); + assertEqualInt(archive_entry_dev(e), 0); + archive_entry_fflags(e, &set, &clear); + assertEqualInt(clear, 0); + assertEqualInt(set, 0); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + assertEqualInt(archive_entry_filetype(e), 0); +#endif + assertEqualInt(archive_entry_gid(e), 0); + assertEqualString(archive_entry_gname(e), NULL); + assertEqualString(archive_entry_hardlink(e), NULL); + assertEqualInt(archive_entry_ino(e), 0); + assertEqualInt(archive_entry_mode(e), 0); + assertEqualInt(archive_entry_mtime(e), 0); + assertEqualInt(archive_entry_mtime_nsec(e), 0); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + assertEqualInt(archive_entry_nlink(e), 0); +#endif + assertEqualString(archive_entry_pathname(e), NULL); + assertEqualInt(archive_entry_rdev(e), 0); + assertEqualInt(archive_entry_size(e), 0); + assertEqualString(archive_entry_symlink(e), NULL); + assertEqualInt(archive_entry_uid(e), 0); + assertEqualString(archive_entry_uname(e), NULL); + /* ACLs should be cleared. */ + assertEqualInt(archive_entry_acl_count(e, ARCHIVE_ENTRY_ACL_TYPE_ACCESS), 0); + assertEqualInt(archive_entry_acl_count(e, ARCHIVE_ENTRY_ACL_TYPE_DEFAULT), 0); + /* Extended attributes should be cleared. */ + assertEqualInt(archive_entry_xattr_count(e), 0); + + /* + * Test archive_entry_copy_stat(). + */ + memset(&st, 0, sizeof(st)); + /* Set all of the standard 'struct stat' fields. */ + st.st_atime = 456789; + st.st_ctime = 345678; + st.st_dev = 123; + st.st_gid = 34; + st.st_ino = 234; + st.st_mode = 077777; + st.st_mtime = 234567; + st.st_nlink = 345; + st.st_size = 123456789; + st.st_uid = 23; +#ifdef __FreeBSD__ + /* On FreeBSD, high-res timestamp data should come through. */ + st.st_atimespec.tv_nsec = 6543210; + st.st_ctimespec.tv_nsec = 5432109; + st.st_mtimespec.tv_nsec = 3210987; + st.st_birthtimespec.tv_nsec = 7459386; +#endif + /* Copy them into the entry. */ + archive_entry_copy_stat(e, &st); + /* Read each one back separately and compare. */ + assertEqualInt(archive_entry_atime(e), 456789); + assertEqualInt(archive_entry_ctime(e), 345678); + assertEqualInt(archive_entry_dev(e), 123); + assertEqualInt(archive_entry_gid(e), 34); + assertEqualInt(archive_entry_ino(e), 234); + assertEqualInt(archive_entry_mode(e), 077777); + assertEqualInt(archive_entry_mtime(e), 234567); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + assertEqualInt(archive_entry_nlink(e), 345); +#endif + assertEqualInt(archive_entry_size(e), 123456789); + assertEqualInt(archive_entry_uid(e), 23); +#if __FreeBSD__ + /* On FreeBSD, high-res timestamp data should come through. */ + assertEqualInt(archive_entry_atime_nsec(e), 6543210); + assertEqualInt(archive_entry_ctime_nsec(e), 5432109); + assertEqualInt(archive_entry_mtime_nsec(e), 3210987); + assertEqualInt(archive_entry_birthtime_nsec(e), 7459386); +#endif + + /* + * Test archive_entry_stat(). + */ + /* First, clear out any existing stat data. */ + memset(&st, 0, sizeof(st)); + archive_entry_copy_stat(e, &st); + /* Set a bunch of fields individually. */ + archive_entry_set_atime(e, 456789, 321); + archive_entry_set_ctime(e, 345678, 432); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + archive_entry_set_dev(e, 123); +#endif + archive_entry_set_gid(e, 34); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + archive_entry_set_ino(e, 234); +#endif + archive_entry_set_mode(e, 012345); + archive_entry_set_mode(e, 012345); + archive_entry_set_mtime(e, 234567, 543); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + archive_entry_set_nlink(e, 345); +#endif + archive_entry_set_size(e, 123456789); + archive_entry_set_uid(e, 23); + /* Retrieve a stat structure. */ + assert((pst = archive_entry_stat(e)) != NULL); + /* Check that the values match. */ + assertEqualInt(pst->st_atime, 456789); + assertEqualInt(pst->st_ctime, 345678); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + assertEqualInt(pst->st_dev, 123); +#endif + assertEqualInt(pst->st_gid, 34); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + assertEqualInt(pst->st_ino, 234); +#endif + assertEqualInt(pst->st_mode, 012345); + assertEqualInt(pst->st_mtime, 234567); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + assertEqualInt(pst->st_nlink, 345); +#endif + assertEqualInt(pst->st_size, 123456789); + assertEqualInt(pst->st_uid, 23); +#ifdef __FreeBSD__ + /* On FreeBSD, high-res timestamp data should come through. */ + assertEqualInt(pst->st_atimespec.tv_nsec, 321); + assertEqualInt(pst->st_ctimespec.tv_nsec, 432); + assertEqualInt(pst->st_mtimespec.tv_nsec, 543); +#endif + + /* Changing any one value should update struct stat. */ + archive_entry_set_atime(e, 456788, 0); + assert((pst = archive_entry_stat(e)) != NULL); + assertEqualInt(pst->st_atime, 456788); + archive_entry_set_ctime(e, 345677, 431); + assert((pst = archive_entry_stat(e)) != NULL); + assertEqualInt(pst->st_ctime, 345677); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + archive_entry_set_dev(e, 122); + assert((pst = archive_entry_stat(e)) != NULL); + assertEqualInt(pst->st_dev, 122); +#endif + archive_entry_set_gid(e, 33); + assert((pst = archive_entry_stat(e)) != NULL); + assertEqualInt(pst->st_gid, 33); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + archive_entry_set_ino(e, 233); + assert((pst = archive_entry_stat(e)) != NULL); + assertEqualInt(pst->st_ino, 233); +#endif + archive_entry_set_mode(e, 012344); + assert((pst = archive_entry_stat(e)) != NULL); + assertEqualInt(pst->st_mode, 012344); + archive_entry_set_mtime(e, 234566, 542); + assert((pst = archive_entry_stat(e)) != NULL); + assertEqualInt(pst->st_mtime, 234566); +#if ARCHIVE_VERSION_NUMBER >= 1009000 + archive_entry_set_nlink(e, 344); + assert((pst = archive_entry_stat(e)) != NULL); + assertEqualInt(pst->st_nlink, 344); +#endif + archive_entry_set_size(e, 123456788); + assert((pst = archive_entry_stat(e)) != NULL); + assertEqualInt(pst->st_size, 123456788); + archive_entry_set_uid(e, 22); + assert((pst = archive_entry_stat(e)) != NULL); + assertEqualInt(pst->st_uid, 22); + /* We don't need to check high-res fields here. */ + + /* + * Test dev/major/minor interfaces. Setting 'dev' or 'rdev' + * should change the corresponding major/minor values, and + * vice versa. + * + * The test here is system-specific because it assumes that + * makedev(), major(), and minor() are defined in sys/stat.h. + * I'm not too worried about it, though, because the code is + * simple. If it works on FreeBSD, it's unlikely to be broken + * anywhere else. Note: The functionality is present on every + * platform even if these tests only run some places; + * libarchive's more extensive configuration logic should find + * the necessary definitions on every platform. + */ +#if __FreeBSD__ +#if ARCHIVE_VERSION_NUMBER >= 1009000 + archive_entry_set_dev(e, 0x12345678); + assertEqualInt(archive_entry_devmajor(e), major(0x12345678)); + assertEqualInt(archive_entry_devminor(e), minor(0x12345678)); + assertEqualInt(archive_entry_dev(e), 0x12345678); + archive_entry_set_devmajor(e, 0xfe); + archive_entry_set_devminor(e, 0xdcba98); + assertEqualInt(archive_entry_devmajor(e), 0xfe); + assertEqualInt(archive_entry_devminor(e), 0xdcba98); + assertEqualInt(archive_entry_dev(e), makedev(0xfe, 0xdcba98)); + archive_entry_set_rdev(e, 0x12345678); + assertEqualInt(archive_entry_rdevmajor(e), major(0x12345678)); + assertEqualInt(archive_entry_rdevminor(e), minor(0x12345678)); + assertEqualInt(archive_entry_rdev(e), 0x12345678); + archive_entry_set_rdevmajor(e, 0xfe); + archive_entry_set_rdevminor(e, 0xdcba98); + assertEqualInt(archive_entry_rdevmajor(e), 0xfe); + assertEqualInt(archive_entry_rdevminor(e), 0xdcba98); + assertEqualInt(archive_entry_rdev(e), makedev(0xfe, 0xdcba98)); +#endif +#endif + + /* + * Exercise the character-conversion logic, if we can. + */ + if (NULL == LOCALE_UTF8 || NULL == setlocale(LC_ALL, LOCALE_UTF8)) { + skipping("Can't exercise charset-conversion logic without" + " a suitable locale."); + } else { + /* A filename that cannot be converted to wide characters. */ + archive_entry_copy_pathname(e, "abc\314\214mno\374xyz"); + failure("Converting invalid chars to Unicode should fail."); + assert(NULL == archive_entry_pathname_w(e)); + //failure("Converting invalid chars to UTF-8 should fail."); + //assert(NULL == archive_entry_pathname_utf8(e)); + + /* A group name that cannot be converted. */ + archive_entry_copy_gname(e, "abc\314\214mno\374xyz"); + failure("Converting invalid chars to Unicode should fail."); + assert(NULL == archive_entry_gname_w(e)); + + /* A user name that cannot be converted. */ + archive_entry_copy_uname(e, "abc\314\214mno\374xyz"); + failure("Converting invalid chars to Unicode should fail."); + assert(NULL == archive_entry_uname_w(e)); + + /* A hardlink target that cannot be converted. */ + archive_entry_copy_hardlink(e, "abc\314\214mno\374xyz"); + failure("Converting invalid chars to Unicode should fail."); + assert(NULL == archive_entry_hardlink_w(e)); + + /* A symlink target that cannot be converted. */ + archive_entry_copy_symlink(e, "abc\314\214mno\374xyz"); + failure("Converting invalid chars to Unicode should fail."); + assert(NULL == archive_entry_symlink_w(e)); + } + +#if HAVE_WCSCPY + l = 0x12345678L; + wc = (wchar_t)l; /* Wide character too big for UTF-8. */ + if (NULL == setlocale(LC_ALL, "C") || (long)wc != l) { + skipping("Testing charset conversion failure requires 32-bit wchar_t and support for \"C\" locale."); + } else { + /* + * Build the string L"xxx\U12345678yyy\u5678zzz" without + * using C99 \u#### syntax, which isn't uniformly + * supported. (GCC 3.4.6, for instance, defaults to + * "c89 plus GNU extensions.") + */ + wcscpy(wbuff, L"xxxAyyyBzzz"); + wbuff[3] = (wchar_t)0x12345678; + wbuff[7] = (wchar_t)0x5678; + /* A wide filename that cannot be converted to narrow. */ + archive_entry_copy_pathname_w(e, wbuff); + failure("Converting wide characters from Unicode should fail."); + assertEqualString(NULL, archive_entry_pathname(e)); + } +#endif + + /* Release the experimental entry. */ + archive_entry_free(e); +} |
