| /*- |
| * 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; |
| int i; |
| |
| 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_set_atime(e, 13580, 1000000001L); |
| assertEqualInt(archive_entry_atime(e), 13581); |
| assertEqualInt(archive_entry_atime_nsec(e), 1); |
| archive_entry_set_atime(e, 13580, -7); |
| assertEqualInt(archive_entry_atime(e), 13579); |
| assertEqualInt(archive_entry_atime_nsec(e), 999999993); |
| 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_set_birthtime(e, 17580, 1234567890L); |
| assertEqualInt(archive_entry_birthtime(e), 17581); |
| assertEqualInt(archive_entry_birthtime_nsec(e), 234567890); |
| archive_entry_set_birthtime(e, 17581, -24990); |
| assertEqualInt(archive_entry_birthtime(e), 17580); |
| assertEqualInt(archive_entry_birthtime_nsec(e), 999975010); |
| 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_set_ctime(e, 13581, 2008182348L); |
| assertEqualInt(archive_entry_ctime(e), 13583); |
| assertEqualInt(archive_entry_ctime_nsec(e), 8182348); |
| archive_entry_set_ctime(e, 13582, -24681); |
| assertEqualInt(archive_entry_ctime(e), 13581); |
| assertEqualInt(archive_entry_ctime_nsec(e), 999975319); |
| 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)); |
| |
| /* dev */ |
| assert(!archive_entry_dev_is_set(e)); |
| archive_entry_set_dev(e, 235); |
| assert(archive_entry_dev_is_set(e)); |
| assertEqualInt(archive_entry_dev(e), 235); |
| /* devmajor/devminor are tested specially below. */ |
| |
| /* filetype */ |
| archive_entry_set_filetype(e, AE_IFREG); |
| assertEqualInt(archive_entry_filetype(e), AE_IFREG); |
| |
| /* 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); |
| |
| /* ino */ |
| assert(!archive_entry_ino_is_set(e)); |
| archive_entry_set_ino(e, 8593); |
| assert(archive_entry_ino_is_set(e)); |
| assertEqualInt(archive_entry_ino(e), 8593); |
| assertEqualInt(archive_entry_ino64(e), 8593); |
| archive_entry_set_ino64(e, 8594); |
| assert(archive_entry_ino_is_set(e)); |
| assertEqualInt(archive_entry_ino(e), 8594); |
| assertEqualInt(archive_entry_ino64(e), 8594); |
| |
| /* 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_set_mtime(e, 13582, 1358297468); |
| assertEqualInt(archive_entry_mtime(e), 13583); |
| assertEqualInt(archive_entry_mtime_nsec(e), 358297468); |
| archive_entry_set_mtime(e, 13583, -24682); |
| assertEqualInt(archive_entry_mtime(e), 13582); |
| assertEqualInt(archive_entry_mtime_nsec(e), 999975318); |
| 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)); |
| |
| /* nlink */ |
| archive_entry_set_nlink(e, 736); |
| assertEqualInt(archive_entry_nlink(e), 736); |
| |
| /* 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"); |
| |
| /* rdev */ |
| archive_entry_set_rdev(e, 532); |
| assertEqualInt(archive_entry_rdev(e), 532); |
| /* 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"); |
| 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"); |
| 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); |
| archive_entry_set_dev(e, 235); |
| 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"); |
| archive_entry_set_ino(e, 8593); |
| archive_entry_set_mode(e, 0123456); |
| archive_entry_set_mtime(e, 13581, 24682); |
| archive_entry_set_nlink(e, 736); |
| archive_entry_set_pathname(e, "path"); |
| archive_entry_set_rdev(e, 532); |
| 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); |
| assertEqualInt(archive_entry_dev(e2), 235); |
| 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"); |
| assertEqualInt(archive_entry_ino(e2), 8593); |
| assertEqualInt(archive_entry_mode(e2), 0123456); |
| assertEqualInt(archive_entry_mtime(e2), 13581); |
| assertEqualInt(archive_entry_mtime_nsec(e2), 24682); |
| assertEqualInt(archive_entry_nlink(e2), 736); |
| assertEqualString(archive_entry_pathname(e2), "path"); |
| assertEqualInt(archive_entry_rdev(e2), 532); |
| 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"); |
| |
| /* 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"); |
| |
| /* 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); |
| |
| /* Change the original */ |
| archive_entry_set_atime(e, 13580, 24690); |
| archive_entry_set_birthtime(e, 13980, 24999); |
| archive_entry_set_ctime(e, 13590, 24691); |
| archive_entry_set_dev(e, 245); |
| archive_entry_set_fflags(e, 0x85, 0xDA); |
| archive_entry_set_filetype(e, AE_IFLNK); |
| archive_entry_set_gid(e, 214); |
| archive_entry_set_gname(e, "grouper"); |
| archive_entry_set_hardlink(e, "hardlinkpath"); |
| archive_entry_set_ino(e, 8763); |
| archive_entry_set_mode(e, 0123654); |
| archive_entry_set_mtime(e, 18351, 28642); |
| archive_entry_set_nlink(e, 73); |
| archive_entry_set_pathname(e, "pathest"); |
| archive_entry_set_rdev(e, 132); |
| 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); |
| assertEqualInt(archive_entry_dev(e2), 235); |
| 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"); |
| assertEqualInt(archive_entry_ino(e2), 8593); |
| assertEqualInt(archive_entry_mode(e2), 0123456); |
| assertEqualInt(archive_entry_mtime(e2), 13581); |
| assertEqualInt(archive_entry_mtime_nsec(e2), 24682); |
| assertEqualInt(archive_entry_nlink(e2), 736); |
| assertEqualString(archive_entry_pathname(e2), "path"); |
| assertEqualInt(archive_entry_rdev(e2), 532); |
| 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"); |
| |
| /* 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); |
| |
| /* Verify xattr was unchanged. */ |
| assertEqualInt(1, archive_entry_xattr_reset(e2)); |
| |
| /* 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); |
| assertEqualInt(archive_entry_filetype(e), 0); |
| 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); |
| assertEqualInt(archive_entry_nlink(e), 0); |
| 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); |
| assertEqualInt(archive_entry_nlink(e), 345); |
| 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); |
| archive_entry_set_dev(e, 123); |
| archive_entry_set_gid(e, 34); |
| archive_entry_set_ino(e, 234); |
| archive_entry_set_mode(e, 012345); |
| archive_entry_set_mode(e, 012345); |
| archive_entry_set_mtime(e, 234567, 543); |
| archive_entry_set_nlink(e, 345); |
| archive_entry_set_size(e, 123456789); |
| archive_entry_set_uid(e, 23); |
| /* Retrieve a stat structure. */ |
| assert((pst = archive_entry_stat(e)) != NULL); |
| if (pst == NULL) |
| return; |
| /* Check that the values match. */ |
| assertEqualInt(pst->st_atime, 456789); |
| assertEqualInt(pst->st_ctime, 345678); |
| assertEqualInt(pst->st_dev, 123); |
| assertEqualInt(pst->st_gid, 34); |
| assertEqualInt(pst->st_ino, 234); |
| assertEqualInt(pst->st_mode, 012345); |
| assertEqualInt(pst->st_mtime, 234567); |
| assertEqualInt(pst->st_nlink, 345); |
| 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); |
| if (pst == NULL) |
| return; |
| assertEqualInt(pst->st_atime, 456788); |
| archive_entry_set_ctime(e, 345677, 431); |
| assert((pst = archive_entry_stat(e)) != NULL); |
| if (pst == NULL) |
| return; |
| assertEqualInt(pst->st_ctime, 345677); |
| archive_entry_set_dev(e, 122); |
| assert((pst = archive_entry_stat(e)) != NULL); |
| if (pst == NULL) |
| return; |
| assertEqualInt(pst->st_dev, 122); |
| archive_entry_set_gid(e, 33); |
| assert((pst = archive_entry_stat(e)) != NULL); |
| if (pst == NULL) |
| return; |
| assertEqualInt(pst->st_gid, 33); |
| archive_entry_set_ino(e, 233); |
| assert((pst = archive_entry_stat(e)) != NULL); |
| if (pst == NULL) |
| return; |
| assertEqualInt(pst->st_ino, 233); |
| archive_entry_set_mode(e, 012344); |
| assert((pst = archive_entry_stat(e)) != NULL); |
| if (pst == NULL) |
| return; |
| assertEqualInt(pst->st_mode, 012344); |
| archive_entry_set_mtime(e, 234566, 542); |
| assert((pst = archive_entry_stat(e)) != NULL); |
| if (pst == NULL) |
| return; |
| assertEqualInt(pst->st_mtime, 234566); |
| archive_entry_set_nlink(e, 344); |
| assert((pst = archive_entry_stat(e)) != NULL); |
| if (pst == NULL) |
| return; |
| assertEqualInt(pst->st_nlink, 344); |
| archive_entry_set_size(e, 123456788); |
| assert((pst = archive_entry_stat(e)) != NULL); |
| if (pst == NULL) |
| return; |
| assertEqualInt(pst->st_size, 123456788); |
| archive_entry_set_uid(e, 22); |
| assert((pst = archive_entry_stat(e)) != NULL); |
| if (pst == NULL) |
| return; |
| 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__ |
| 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 |
| |
| /* |
| * Exercise the character-conversion logic, if we can. |
| */ |
| if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) { |
| 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)); |
| } |
| |
| 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 wcscpy or C99 \u#### syntax. |
| */ |
| name = "xxxAyyyBzzz"; |
| for (i = 0; i < (int)strlen(name); ++i) |
| wbuff[i] = name[i]; |
| wbuff[3] = (wchar_t)0x12345678; |
| wbuff[7] = (wchar_t)0x5678; |
| /* A Unicode filename that cannot be converted to UTF-8. */ |
| archive_entry_copy_pathname_w(e, wbuff); |
| failure("Converting wide characters from Unicode should fail."); |
| assertEqualString(NULL, archive_entry_pathname(e)); |
| } |
| |
| /* Release the experimental entry. */ |
| archive_entry_free(e); |
| } |
