contrib/libarchive/libarchive/test/test_entry.c

   1 /*-
   2  * Copyright (c) 2003-2007 Tim Kientzle
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25 #include "test.h"
  26 __FBSDID("$FreeBSD$");
  27
  28 #include <locale.h>
  29
  30 #ifdef HAVE_LINUX_FS_H
  31 #include <linux/fs.h>   /* for Linux file flags */
  32 #endif
  33
  34 #ifndef HAVE_WCSCPY
  35 static wchar_t * wcscpy(wchar_t *s1, const wchar_t *s2)
  36 {
  37         wchar_t *dest = s1;
  38         while ((*s1 = *s2) != L'\0')
  39                 ++s1, ++s2;
  40         return dest;
  41 }
  42 #endif
  43
  44 /*
  45  * Most of these tests are system-independent, though a few depend on
  46  * features of the local system.  Such tests are conditionalized on
  47  * the platform name.  On unsupported platforms, only the
  48  * system-independent features will be tested.
  49  *
  50  * No, I don't want to use config.h in the test files because I want
  51  * the tests to also serve as a check on the correctness of config.h.
  52  * A mis-configured library build should cause tests to fail.
  53  */
  54
  55 DEFINE_TEST(test_entry)
  56 {
  57         char buff[128];
  58         wchar_t wbuff[128];
  59         struct stat st;
  60         struct archive_entry *e, *e2;
  61         const struct stat *pst;
  62         unsigned long set, clear; /* For fflag testing. */
  63         int type, permset, tag, qual; /* For ACL testing. */
  64         const char *name; /* For ACL testing. */
  65         const char *xname; /* For xattr tests. */
  66         const void *xval; /* For xattr tests. */
  67         size_t xsize; /* For xattr tests. */
  68         wchar_t wc;
  69         long l;
  70         int i;
  71
  72         assert((e = archive_entry_new()) != NULL);
  73
  74         /*
  75          * Verify that the AE_IF* defines match S_IF* defines
  76          * on this platform. See comments in archive_entry.h.
  77          */
  78 #ifdef S_IFREG
  79         assertEqualInt(S_IFREG, AE_IFREG);
  80 #endif
  81 #ifdef S_IFLNK
  82         assertEqualInt(S_IFLNK, AE_IFLNK);
  83 #endif
  84 #ifdef S_IFSOCK
  85         assertEqualInt(S_IFSOCK, AE_IFSOCK);
  86 #endif
  87 #ifdef S_IFCHR
  88         assertEqualInt(S_IFCHR, AE_IFCHR);
  89 #endif
  90 /* Work around MinGW, which defines S_IFBLK wrong. */
  91 /* sourceforge.net/tracker/?func=detail&atid=102435&aid=1942809&group_id=2435 */
  92 #if defined(S_IFBLK) && !defined(_WIN32)
  93         assertEqualInt(S_IFBLK, AE_IFBLK);
  94 #endif
  95 #ifdef S_IFDIR
  96         assertEqualInt(S_IFDIR, AE_IFDIR);
  97 #endif
  98 #ifdef S_IFIFO
  99         assertEqualInt(S_IFIFO, AE_IFIFO);
 100 #endif
 101
 102         /*
 103          * Basic set/read tests for all fields.
 104          * We should be able to set any field and read
 105          * back the same value.
 106          *
 107          * For methods that "copy" a string, we should be able
 108          * to overwrite the original passed-in string without
 109          * changing the value in the entry.
 110          *
 111          * The following tests are ordered alphabetically by the
 112          * name of the field.
 113          */
 114
 115         /* atime */
 116         archive_entry_set_atime(e, 13579, 24680);
 117         assertEqualInt(archive_entry_atime(e), 13579);
 118         assertEqualInt(archive_entry_atime_nsec(e), 24680);
 119         archive_entry_set_atime(e, 13580, 1000000001L);
 120         assertEqualInt(archive_entry_atime(e), 13581);
 121         assertEqualInt(archive_entry_atime_nsec(e), 1);
 122         archive_entry_set_atime(e, 13580, -7);
 123         assertEqualInt(archive_entry_atime(e), 13579);
 124         assertEqualInt(archive_entry_atime_nsec(e), 999999993);
 125         archive_entry_unset_atime(e);
 126         assertEqualInt(archive_entry_atime(e), 0);
 127         assertEqualInt(archive_entry_atime_nsec(e), 0);
 128         assert(!archive_entry_atime_is_set(e));
 129
 130         /* birthtime */
 131         archive_entry_set_birthtime(e, 17579, 24990);
 132         assertEqualInt(archive_entry_birthtime(e), 17579);
 133         assertEqualInt(archive_entry_birthtime_nsec(e), 24990);
 134         archive_entry_set_birthtime(e, 17580, 1234567890L);
 135         assertEqualInt(archive_entry_birthtime(e), 17581);
 136         assertEqualInt(archive_entry_birthtime_nsec(e), 234567890);
 137         archive_entry_set_birthtime(e, 17581, -24990);
 138         assertEqualInt(archive_entry_birthtime(e), 17580);
 139         assertEqualInt(archive_entry_birthtime_nsec(e), 999975010);
 140         archive_entry_unset_birthtime(e);
 141         assertEqualInt(archive_entry_birthtime(e), 0);
 142         assertEqualInt(archive_entry_birthtime_nsec(e), 0);
 143         assert(!archive_entry_birthtime_is_set(e));
 144
 145         /* ctime */
 146         archive_entry_set_ctime(e, 13580, 24681);
 147         assertEqualInt(archive_entry_ctime(e), 13580);
 148         assertEqualInt(archive_entry_ctime_nsec(e), 24681);
 149         archive_entry_set_ctime(e, 13581, 2008182348L);
 150         assertEqualInt(archive_entry_ctime(e), 13583);
 151         assertEqualInt(archive_entry_ctime_nsec(e), 8182348);
 152         archive_entry_set_ctime(e, 13582, -24681);
 153         assertEqualInt(archive_entry_ctime(e), 13581);
 154         assertEqualInt(archive_entry_ctime_nsec(e), 999975319);
 155         archive_entry_unset_ctime(e);
 156         assertEqualInt(archive_entry_ctime(e), 0);
 157         assertEqualInt(archive_entry_ctime_nsec(e), 0);
 158         assert(!archive_entry_ctime_is_set(e));
 159
 160         /* dev */
 161         assert(!archive_entry_dev_is_set(e));
 162         archive_entry_set_dev(e, 235);
 163         assert(archive_entry_dev_is_set(e));
 164         assertEqualInt(archive_entry_dev(e), 235);
 165         /* devmajor/devminor are tested specially below. */
 166
 167         /* filetype */
 168         archive_entry_set_filetype(e, AE_IFREG);
 169         assertEqualInt(archive_entry_filetype(e), AE_IFREG);
 170
 171         /* fflags are tested specially below */
 172
 173         /* gid */
 174         archive_entry_set_gid(e, 204);
 175         assertEqualInt(archive_entry_gid(e), 204);
 176
 177         /* gname */
 178         archive_entry_set_gname(e, "group");
 179         assertEqualString(archive_entry_gname(e), "group");
 180         wcscpy(wbuff, L"wgroup");
 181         archive_entry_copy_gname_w(e, wbuff);
 182         assertEqualWString(archive_entry_gname_w(e), L"wgroup");
 183         memset(wbuff, 0, sizeof(wbuff));
 184         assertEqualWString(archive_entry_gname_w(e), L"wgroup");
 185
 186         /* hardlink */
 187         archive_entry_set_hardlink(e, "hardlinkname");
 188         assertEqualString(archive_entry_hardlink(e), "hardlinkname");
 189         strcpy(buff, "hardlinkname2");
 190         archive_entry_copy_hardlink(e, buff);
 191         assertEqualString(archive_entry_hardlink(e), "hardlinkname2");
 192         memset(buff, 0, sizeof(buff));
 193         assertEqualString(archive_entry_hardlink(e), "hardlinkname2");
 194         archive_entry_copy_hardlink(e, NULL);
 195         assertEqualString(archive_entry_hardlink(e), NULL);
 196         assertEqualWString(archive_entry_hardlink_w(e), NULL);
 197         wcscpy(wbuff, L"whardlink");
 198         archive_entry_copy_hardlink_w(e, wbuff);
 199         assertEqualWString(archive_entry_hardlink_w(e), L"whardlink");
 200         memset(wbuff, 0, sizeof(wbuff));
 201         assertEqualWString(archive_entry_hardlink_w(e), L"whardlink");
 202         archive_entry_copy_hardlink_w(e, NULL);
 203         assertEqualString(archive_entry_hardlink(e), NULL);
 204         assertEqualWString(archive_entry_hardlink_w(e), NULL);
 205
 206         /* ino */
 207         assert(!archive_entry_ino_is_set(e));
 208         archive_entry_set_ino(e, 8593);
 209         assert(archive_entry_ino_is_set(e));
 210         assertEqualInt(archive_entry_ino(e), 8593);
 211         assertEqualInt(archive_entry_ino64(e), 8593);
 212         archive_entry_set_ino64(e, 8594);
 213         assert(archive_entry_ino_is_set(e));
 214         assertEqualInt(archive_entry_ino(e), 8594);
 215         assertEqualInt(archive_entry_ino64(e), 8594);
 216
 217         /* link */
 218         archive_entry_set_hardlink(e, "hardlinkname");
 219         archive_entry_set_symlink(e, NULL);
 220         archive_entry_set_link(e, "link");
 221         assertEqualString(archive_entry_hardlink(e), "link");
 222         assertEqualString(archive_entry_symlink(e), NULL);
 223         archive_entry_copy_link(e, "link2");
 224         assertEqualString(archive_entry_hardlink(e), "link2");
 225         assertEqualString(archive_entry_symlink(e), NULL);
 226         archive_entry_copy_link_w(e, L"link3");
 227         assertEqualString(archive_entry_hardlink(e), "link3");
 228         assertEqualString(archive_entry_symlink(e), NULL);
 229         archive_entry_set_hardlink(e, NULL);
 230         archive_entry_set_symlink(e, "symlink");
 231         archive_entry_set_link(e, "link");
 232         assertEqualString(archive_entry_hardlink(e), NULL);
 233         assertEqualString(archive_entry_symlink(e), "link");
 234         archive_entry_copy_link(e, "link2");
 235         assertEqualString(archive_entry_hardlink(e), NULL);
 236         assertEqualString(archive_entry_symlink(e), "link2");
 237         archive_entry_copy_link_w(e, L"link3");
 238         assertEqualString(archive_entry_hardlink(e), NULL);
 239         assertEqualString(archive_entry_symlink(e), "link3");
 240         /* Arbitrarily override symlink if both hardlink and symlink set. */
 241         archive_entry_set_hardlink(e, "hardlink");
 242         archive_entry_set_symlink(e, "symlink");
 243         archive_entry_set_link(e, "link");
 244         assertEqualString(archive_entry_hardlink(e), "hardlink");
 245         assertEqualString(archive_entry_symlink(e), "link");
 246
 247         /* mode */
 248         archive_entry_set_mode(e, 0123456);
 249         assertEqualInt(archive_entry_mode(e), 0123456);
 250
 251         /* mtime */
 252         archive_entry_set_mtime(e, 13581, 24682);
 253         assertEqualInt(archive_entry_mtime(e), 13581);
 254         assertEqualInt(archive_entry_mtime_nsec(e), 24682);
 255         archive_entry_set_mtime(e, 13582, 1358297468);
 256         assertEqualInt(archive_entry_mtime(e), 13583);
 257         assertEqualInt(archive_entry_mtime_nsec(e), 358297468);
 258         archive_entry_set_mtime(e, 13583, -24682);
 259         assertEqualInt(archive_entry_mtime(e), 13582);
 260         assertEqualInt(archive_entry_mtime_nsec(e), 999975318);
 261         archive_entry_unset_mtime(e);
 262         assertEqualInt(archive_entry_mtime(e), 0);
 263         assertEqualInt(archive_entry_mtime_nsec(e), 0);
 264         assert(!archive_entry_mtime_is_set(e));
 265
 266         /* nlink */
 267         archive_entry_set_nlink(e, 736);
 268         assertEqualInt(archive_entry_nlink(e), 736);
 269
 270         /* pathname */
 271         archive_entry_set_pathname(e, "path");
 272         assertEqualString(archive_entry_pathname(e), "path");
 273         archive_entry_set_pathname(e, "path");
 274         assertEqualString(archive_entry_pathname(e), "path");
 275         strcpy(buff, "path2");
 276         archive_entry_copy_pathname(e, buff);
 277         assertEqualString(archive_entry_pathname(e), "path2");
 278         memset(buff, 0, sizeof(buff));
 279         assertEqualString(archive_entry_pathname(e), "path2");
 280         wcscpy(wbuff, L"wpath");
 281         archive_entry_copy_pathname_w(e, wbuff);
 282         assertEqualWString(archive_entry_pathname_w(e), L"wpath");
 283         memset(wbuff, 0, sizeof(wbuff));
 284         assertEqualWString(archive_entry_pathname_w(e), L"wpath");
 285
 286         /* rdev */
 287         archive_entry_set_rdev(e, 532);
 288         assertEqualInt(archive_entry_rdev(e), 532);
 289         /* rdevmajor/rdevminor are tested specially below. */
 290
 291         /* size */
 292         archive_entry_set_size(e, 987654321);
 293         assertEqualInt(archive_entry_size(e), 987654321);
 294         archive_entry_unset_size(e);
 295         assertEqualInt(archive_entry_size(e), 0);
 296         assert(!archive_entry_size_is_set(e));
 297
 298         /* sourcepath */
 299         archive_entry_copy_sourcepath(e, "path1");
 300         assertEqualString(archive_entry_sourcepath(e), "path1");
 301
 302         /* symlink */
 303         archive_entry_set_symlink(e, "symlinkname");
 304         assertEqualString(archive_entry_symlink(e), "symlinkname");
 305         strcpy(buff, "symlinkname2");
 306         archive_entry_copy_symlink(e, buff);
 307         assertEqualString(archive_entry_symlink(e), "symlinkname2");
 308         memset(buff, 0, sizeof(buff));
 309         assertEqualString(archive_entry_symlink(e), "symlinkname2");
 310         archive_entry_copy_symlink_w(e, NULL);
 311         assertEqualWString(archive_entry_symlink_w(e), NULL);
 312         assertEqualString(archive_entry_symlink(e), NULL);
 313         archive_entry_copy_symlink_w(e, L"wsymlink");
 314         assertEqualWString(archive_entry_symlink_w(e), L"wsymlink");
 315         archive_entry_copy_symlink(e, NULL);
 316         assertEqualWString(archive_entry_symlink_w(e), NULL);
 317         assertEqualString(archive_entry_symlink(e), NULL);
 318
 319         /* uid */
 320         archive_entry_set_uid(e, 83);
 321         assertEqualInt(archive_entry_uid(e), 83);
 322
 323         /* uname */
 324         archive_entry_set_uname(e, "user");
 325         assertEqualString(archive_entry_uname(e), "user");
 326         wcscpy(wbuff, L"wuser");
 327         archive_entry_copy_gname_w(e, wbuff);
 328         assertEqualWString(archive_entry_gname_w(e), L"wuser");
 329         memset(wbuff, 0, sizeof(wbuff));
 330         assertEqualWString(archive_entry_gname_w(e), L"wuser");
 331
 332         /* Test fflags interface. */
 333         archive_entry_set_fflags(e, 0x55, 0xAA);
 334         archive_entry_fflags(e, &set, &clear);
 335         failure("Testing set/get of fflags data.");
 336         assertEqualInt(set, 0x55);
 337         failure("Testing set/get of fflags data.");
 338         assertEqualInt(clear, 0xAA);
 339 #ifdef __FreeBSD__
 340         /* Converting fflags bitmap to string is currently system-dependent. */
 341         /* TODO: Make this system-independent. */
 342         assertEqualString(archive_entry_fflags_text(e),
 343             "uappnd,nouchg,nodump,noopaque,uunlnk,nosystem");
 344 #endif
 345
 346 #if defined(__FreeBSD__) || defined(__APPLE__)
 347         /* Test archive_entry_copy_fflags_text_w() */
 348         archive_entry_copy_fflags_text_w(e, L" ,nouappnd, nouchg, dump,hidden");
 349         archive_entry_fflags(e, &set, &clear);
 350         assertEqualInt(UF_HIDDEN, set);
 351         assertEqualInt(UF_NODUMP | UF_IMMUTABLE | UF_APPEND, clear);
 352         /* Test archive_entry_copy_fflags_text() */
 353         archive_entry_copy_fflags_text(e, " ,nouappnd, nouchg, dump,hidden");
 354         archive_entry_fflags(e, &set, &clear);
 355         assertEqualInt(UF_HIDDEN, set);
 356         assertEqualInt(UF_NODUMP | UF_IMMUTABLE | UF_APPEND, clear);
 357 #elif defined(_WIN32) && !defined(CYGWIN)
 358         archive_entry_copy_fflags_text_w(e, L"rdonly,hidden,nosystem");
 359         archive_entry_fflags(e, &set, &clear);
 360         assertEqualInt(FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN, set);
 361         assertEqualInt(FILE_ATTRIBUTE_SYSTEM, clear);
 362         archive_entry_copy_fflags_text(e, "rdonly,hidden,nosystem");
 363         archive_entry_fflags(e, &set, &clear);
 364         assertEqualInt(FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN, set);
 365         assertEqualInt(FILE_ATTRIBUTE_SYSTEM, clear);
 366 #elif defined FS_IOC_GETFLAGS /* Linux */
 367         archive_entry_copy_fflags_text_w(e, L"sappnd,schg,dump,noundel");
 368         archive_entry_fflags(e, &set, &clear);
 369         assertEqualInt(FS_APPEND_FL | FS_IMMUTABLE_FL, set);
 370         assertEqualInt(FS_NODUMP_FL | FS_UNRM_FL, clear);
 371         archive_entry_copy_fflags_text(e, "sappnd,schg,dump,noundel");
 372         archive_entry_fflags(e, &set, &clear);
 373         assertEqualInt(FS_APPEND_FL | FS_IMMUTABLE_FL, set);
 374         assertEqualInt(FS_NODUMP_FL | FS_UNRM_FL, clear);
 375 #endif
 376
 377         /* See test_acl_basic.c for tests of ACL set/get consistency. */
 378
 379         /* Test xattrs set/get consistency. */
 380         archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue1", 12);
 381         assertEqualInt(1, archive_entry_xattr_reset(e));
 382         assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize));
 383         assertEqualString(xname, "xattr1");
 384         assertEqualString(xval, "xattrvalue1");
 385         assertEqualInt((int)xsize, 12);
 386         assertEqualInt(1, archive_entry_xattr_count(e));
 387         assertEqualInt(ARCHIVE_WARN,
 388             archive_entry_xattr_next(e, &xname, &xval, &xsize));
 389         assertEqualString(xname, NULL);
 390         assertEqualString(xval, NULL);
 391         assertEqualInt((int)xsize, 0);
 392         archive_entry_xattr_clear(e);
 393         assertEqualInt(0, archive_entry_xattr_reset(e));
 394         assertEqualInt(ARCHIVE_WARN,
 395             archive_entry_xattr_next(e, &xname, &xval, &xsize));
 396         assertEqualString(xname, NULL);
 397         assertEqualString(xval, NULL);
 398         assertEqualInt((int)xsize, 0);
 399         archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue1", 12);
 400         assertEqualInt(1, archive_entry_xattr_reset(e));
 401         archive_entry_xattr_add_entry(e, "xattr2", "xattrvalue2", 12);
 402         assertEqualInt(2, archive_entry_xattr_reset(e));
 403         assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize));
 404         assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize));
 405         assertEqualInt(ARCHIVE_WARN,
 406             archive_entry_xattr_next(e, &xname, &xval, &xsize));
 407         assertEqualString(xname, NULL);
 408         assertEqualString(xval, NULL);
 409         assertEqualInt((int)xsize, 0);
 410
 411
 412         /*
 413          * Test clone() implementation.
 414          */
 415
 416         /* Set values in 'e' */
 417         archive_entry_clear(e);
 418         archive_entry_set_atime(e, 13579, 24680);
 419         archive_entry_set_birthtime(e, 13779, 24990);
 420         archive_entry_set_ctime(e, 13580, 24681);
 421         archive_entry_set_dev(e, 235);
 422         archive_entry_set_fflags(e, 0x55, 0xAA);
 423         archive_entry_set_gid(e, 204);
 424         archive_entry_set_gname(e, "group");
 425         archive_entry_set_hardlink(e, "hardlinkname");
 426         archive_entry_set_ino(e, 8593);
 427         archive_entry_set_mode(e, 0123456);
 428         archive_entry_set_mtime(e, 13581, 24682);
 429         archive_entry_set_nlink(e, 736);
 430         archive_entry_set_pathname(e, "path");
 431         archive_entry_set_rdev(e, 532);
 432         archive_entry_set_size(e, 987654321);
 433         archive_entry_copy_sourcepath(e, "source");
 434         archive_entry_set_symlink(e, "symlinkname");
 435         archive_entry_set_uid(e, 83);
 436         archive_entry_set_uname(e, "user");
 437         /* Add an ACL entry. */
 438         archive_entry_acl_add_entry(e, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 439             ARCHIVE_ENTRY_ACL_READ, ARCHIVE_ENTRY_ACL_USER, 77, "user77");
 440         /* Add an extended attribute. */
 441         archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue", 11);
 442
 443         /* Make a clone. */
 444         e2 = archive_entry_clone(e);
 445
 446         /* Clone should have same contents. */
 447         assertEqualInt(archive_entry_atime(e2), 13579);
 448         assertEqualInt(archive_entry_atime_nsec(e2), 24680);
 449         assertEqualInt(archive_entry_birthtime(e2), 13779);
 450         assertEqualInt(archive_entry_birthtime_nsec(e2), 24990);
 451         assertEqualInt(archive_entry_ctime(e2), 13580);
 452         assertEqualInt(archive_entry_ctime_nsec(e2), 24681);
 453         assertEqualInt(archive_entry_dev(e2), 235);
 454         archive_entry_fflags(e, &set, &clear);
 455         assertEqualInt(clear, 0xAA);
 456         assertEqualInt(set, 0x55);
 457         assertEqualInt(archive_entry_gid(e2), 204);
 458         assertEqualString(archive_entry_gname(e2), "group");
 459         assertEqualString(archive_entry_hardlink(e2), "hardlinkname");
 460         assertEqualInt(archive_entry_ino(e2), 8593);
 461         assertEqualInt(archive_entry_mode(e2), 0123456);
 462         assertEqualInt(archive_entry_mtime(e2), 13581);
 463         assertEqualInt(archive_entry_mtime_nsec(e2), 24682);
 464         assertEqualInt(archive_entry_nlink(e2), 736);
 465         assertEqualString(archive_entry_pathname(e2), "path");
 466         assertEqualInt(archive_entry_rdev(e2), 532);
 467         assertEqualInt(archive_entry_size(e2), 987654321);
 468         assertEqualString(archive_entry_sourcepath(e2), "source");
 469         assertEqualString(archive_entry_symlink(e2), "symlinkname");
 470         assertEqualInt(archive_entry_uid(e2), 83);
 471         assertEqualString(archive_entry_uname(e2), "user");
 472
 473         /* Verify ACL was copied. */
 474         assertEqualInt(4, archive_entry_acl_reset(e2,
 475                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 476         /* First three are standard permission bits. */
 477         assertEqualInt(0, archive_entry_acl_next(e2,
 478                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 479                            &type, &permset, &tag, &qual, &name));
 480         assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
 481         assertEqualInt(permset, 4);
 482         assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER_OBJ);
 483         assertEqualInt(qual, -1);
 484         assertEqualString(name, NULL);
 485         assertEqualInt(0, archive_entry_acl_next(e2,
 486                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 487                            &type, &permset, &tag, &qual, &name));
 488         assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
 489         assertEqualInt(permset, 5);
 490         assertEqualInt(tag, ARCHIVE_ENTRY_ACL_GROUP_OBJ);
 491         assertEqualInt(qual, -1);
 492         assertEqualString(name, NULL);
 493         assertEqualInt(0, archive_entry_acl_next(e2,
 494                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 495                            &type, &permset, &tag, &qual, &name));
 496         assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
 497         assertEqualInt(permset, 6);
 498         assertEqualInt(tag, ARCHIVE_ENTRY_ACL_OTHER);
 499         assertEqualInt(qual, -1);
 500         assertEqualString(name, NULL);
 501         /* Fourth is custom one. */
 502         assertEqualInt(0, archive_entry_acl_next(e2,
 503                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 504                            &type, &permset, &tag, &qual, &name));
 505         assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
 506         assertEqualInt(permset, ARCHIVE_ENTRY_ACL_READ);
 507         assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER);
 508         assertEqualInt(qual, 77);
 509         assertEqualString(name, "user77");
 510
 511         /* Verify xattr was copied. */
 512         assertEqualInt(1, archive_entry_xattr_reset(e2));
 513         assertEqualInt(0, archive_entry_xattr_next(e2, &xname, &xval, &xsize));
 514         assertEqualString(xname, "xattr1");
 515         assertEqualString(xval, "xattrvalue");
 516         assertEqualInt((int)xsize, 11);
 517         assertEqualInt(ARCHIVE_WARN,
 518             archive_entry_xattr_next(e2, &xname, &xval, &xsize));
 519         assertEqualString(xname, NULL);
 520         assertEqualString(xval, NULL);
 521         assertEqualInt((int)xsize, 0);
 522
 523         /* Change the original */
 524         archive_entry_set_atime(e, 13580, 24690);
 525         archive_entry_set_birthtime(e, 13980, 24999);
 526         archive_entry_set_ctime(e, 13590, 24691);
 527         archive_entry_set_dev(e, 245);
 528         archive_entry_set_fflags(e, 0x85, 0xDA);
 529         archive_entry_set_filetype(e, AE_IFLNK);
 530         archive_entry_set_gid(e, 214);
 531         archive_entry_set_gname(e, "grouper");
 532         archive_entry_set_hardlink(e, "hardlinkpath");
 533         archive_entry_set_ino(e, 8763);
 534         archive_entry_set_mode(e, 0123654);
 535         archive_entry_set_mtime(e, 18351, 28642);
 536         archive_entry_set_nlink(e, 73);
 537         archive_entry_set_pathname(e, "pathest");
 538         archive_entry_set_rdev(e, 132);
 539         archive_entry_set_size(e, 987456321);
 540         archive_entry_copy_sourcepath(e, "source2");
 541         archive_entry_set_symlink(e, "symlinkpath");
 542         archive_entry_set_uid(e, 93);
 543         archive_entry_set_uname(e, "username");
 544         archive_entry_acl_clear(e);
 545         archive_entry_xattr_clear(e);
 546
 547         /* Clone should still have same contents. */
 548         assertEqualInt(archive_entry_atime(e2), 13579);
 549         assertEqualInt(archive_entry_atime_nsec(e2), 24680);
 550         assertEqualInt(archive_entry_birthtime(e2), 13779);
 551         assertEqualInt(archive_entry_birthtime_nsec(e2), 24990);
 552         assertEqualInt(archive_entry_ctime(e2), 13580);
 553         assertEqualInt(archive_entry_ctime_nsec(e2), 24681);
 554         assertEqualInt(archive_entry_dev(e2), 235);
 555         archive_entry_fflags(e2, &set, &clear);
 556         assertEqualInt(clear, 0xAA);
 557         assertEqualInt(set, 0x55);
 558         assertEqualInt(archive_entry_gid(e2), 204);
 559         assertEqualString(archive_entry_gname(e2), "group");
 560         assertEqualString(archive_entry_hardlink(e2), "hardlinkname");
 561         assertEqualInt(archive_entry_ino(e2), 8593);
 562         assertEqualInt(archive_entry_mode(e2), 0123456);
 563         assertEqualInt(archive_entry_mtime(e2), 13581);
 564         assertEqualInt(archive_entry_mtime_nsec(e2), 24682);
 565         assertEqualInt(archive_entry_nlink(e2), 736);
 566         assertEqualString(archive_entry_pathname(e2), "path");
 567         assertEqualInt(archive_entry_rdev(e2), 532);
 568         assertEqualInt(archive_entry_size(e2), 987654321);
 569         assertEqualString(archive_entry_sourcepath(e2), "source");
 570         assertEqualString(archive_entry_symlink(e2), "symlinkname");
 571         assertEqualInt(archive_entry_uid(e2), 83);
 572         assertEqualString(archive_entry_uname(e2), "user");
 573
 574         /* Verify ACL was unchanged. */
 575         assertEqualInt(4, archive_entry_acl_reset(e2,
 576                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 577         /* First three are standard permission bits. */
 578         assertEqualInt(0, archive_entry_acl_next(e2,
 579                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 580                            &type, &permset, &tag, &qual, &name));
 581         assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
 582         assertEqualInt(permset, 4);
 583         assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER_OBJ);
 584         assertEqualInt(qual, -1);
 585         assertEqualString(name, NULL);
 586         assertEqualInt(0, archive_entry_acl_next(e2,
 587                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 588                            &type, &permset, &tag, &qual, &name));
 589         assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
 590         assertEqualInt(permset, 5);
 591         assertEqualInt(tag, ARCHIVE_ENTRY_ACL_GROUP_OBJ);
 592         assertEqualInt(qual, -1);
 593         assertEqualString(name, NULL);
 594         assertEqualInt(0, archive_entry_acl_next(e2,
 595                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 596                            &type, &permset, &tag, &qual, &name));
 597         assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
 598         assertEqualInt(permset, 6);
 599         assertEqualInt(tag, ARCHIVE_ENTRY_ACL_OTHER);
 600         assertEqualInt(qual, -1);
 601         assertEqualString(name, NULL);
 602         /* Fourth is custom one. */
 603         assertEqualInt(0, archive_entry_acl_next(e2,
 604                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 605                            &type, &permset, &tag, &qual, &name));
 606         assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
 607         assertEqualInt(permset, ARCHIVE_ENTRY_ACL_READ);
 608         assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER);
 609         assertEqualInt(qual, 77);
 610         assertEqualString(name, "user77");
 611         assertEqualInt(1, archive_entry_acl_next(e2,
 612                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 613                            &type, &permset, &tag, &qual, &name));
 614         assertEqualInt(type, 0);
 615         assertEqualInt(permset, 0);
 616         assertEqualInt(tag, 0);
 617         assertEqualInt(qual, -1);
 618         assertEqualString(name, NULL);
 619
 620         /* Verify xattr was unchanged. */
 621         assertEqualInt(1, archive_entry_xattr_reset(e2));
 622
 623         /* Release clone. */
 624         archive_entry_free(e2);
 625
 626         /*
 627          * Test clear() implementation.
 628          */
 629         archive_entry_clear(e);
 630         assertEqualInt(archive_entry_atime(e), 0);
 631         assertEqualInt(archive_entry_atime_nsec(e), 0);
 632         assertEqualInt(archive_entry_birthtime(e), 0);
 633         assertEqualInt(archive_entry_birthtime_nsec(e), 0);
 634         assertEqualInt(archive_entry_ctime(e), 0);
 635         assertEqualInt(archive_entry_ctime_nsec(e), 0);
 636         assertEqualInt(archive_entry_dev(e), 0);
 637         archive_entry_fflags(e, &set, &clear);
 638         assertEqualInt(clear, 0);
 639         assertEqualInt(set, 0);
 640         assertEqualInt(archive_entry_filetype(e), 0);
 641         assertEqualInt(archive_entry_gid(e), 0);
 642         assertEqualString(archive_entry_gname(e), NULL);
 643         assertEqualString(archive_entry_hardlink(e), NULL);
 644         assertEqualInt(archive_entry_ino(e), 0);
 645         assertEqualInt(archive_entry_mode(e), 0);
 646         assertEqualInt(archive_entry_mtime(e), 0);
 647         assertEqualInt(archive_entry_mtime_nsec(e), 0);
 648         assertEqualInt(archive_entry_nlink(e), 0);
 649         assertEqualString(archive_entry_pathname(e), NULL);
 650         assertEqualInt(archive_entry_rdev(e), 0);
 651         assertEqualInt(archive_entry_size(e), 0);
 652         assertEqualString(archive_entry_symlink(e), NULL);
 653         assertEqualInt(archive_entry_uid(e), 0);
 654         assertEqualString(archive_entry_uname(e), NULL);
 655         /* ACLs should be cleared. */
 656         assertEqualInt(archive_entry_acl_count(e, ARCHIVE_ENTRY_ACL_TYPE_ACCESS), 0);
 657         assertEqualInt(archive_entry_acl_count(e, ARCHIVE_ENTRY_ACL_TYPE_DEFAULT), 0);
 658         /* Extended attributes should be cleared. */
 659         assertEqualInt(archive_entry_xattr_count(e), 0);
 660
 661         /*
 662          * Test archive_entry_copy_stat().
 663          */
 664         memset(&st, 0, sizeof(st));
 665         /* Set all of the standard 'struct stat' fields. */
 666         st.st_atime = 456789;
 667         st.st_ctime = 345678;
 668         st.st_dev = 123;
 669         st.st_gid = 34;
 670         st.st_ino = 234;
 671         st.st_mode = 077777;
 672         st.st_mtime = 234567;
 673         st.st_nlink = 345;
 674         st.st_size = 123456789;
 675         st.st_uid = 23;
 676 #ifdef __FreeBSD__
 677         /* On FreeBSD, high-res timestamp data should come through. */
 678         st.st_atimespec.tv_nsec = 6543210;
 679         st.st_ctimespec.tv_nsec = 5432109;
 680         st.st_mtimespec.tv_nsec = 3210987;
 681         st.st_birthtimespec.tv_nsec = 7459386;
 682 #endif
 683         /* Copy them into the entry. */
 684         archive_entry_copy_stat(e, &st);
 685         /* Read each one back separately and compare. */
 686         assertEqualInt(archive_entry_atime(e), 456789);
 687         assertEqualInt(archive_entry_ctime(e), 345678);
 688         assertEqualInt(archive_entry_dev(e), 123);
 689         assertEqualInt(archive_entry_gid(e), 34);
 690         assertEqualInt(archive_entry_ino(e), 234);
 691         assertEqualInt(archive_entry_mode(e), 077777);
 692         assertEqualInt(archive_entry_mtime(e), 234567);
 693         assertEqualInt(archive_entry_nlink(e), 345);
 694         assertEqualInt(archive_entry_size(e), 123456789);
 695         assertEqualInt(archive_entry_uid(e), 23);
 696 #if __FreeBSD__
 697         /* On FreeBSD, high-res timestamp data should come through. */
 698         assertEqualInt(archive_entry_atime_nsec(e), 6543210);
 699         assertEqualInt(archive_entry_ctime_nsec(e), 5432109);
 700         assertEqualInt(archive_entry_mtime_nsec(e), 3210987);
 701         assertEqualInt(archive_entry_birthtime_nsec(e), 7459386);
 702 #endif
 703
 704         /*
 705          * Test archive_entry_stat().
 706          */
 707         /* First, clear out any existing stat data. */
 708         memset(&st, 0, sizeof(st));
 709         archive_entry_copy_stat(e, &st);
 710         /* Set a bunch of fields individually. */
 711         archive_entry_set_atime(e, 456789, 321);
 712         archive_entry_set_ctime(e, 345678, 432);
 713         archive_entry_set_dev(e, 123);
 714         archive_entry_set_gid(e, 34);
 715         archive_entry_set_ino(e, 234);
 716         archive_entry_set_mode(e, 012345);
 717         archive_entry_set_mode(e, 012345);
 718         archive_entry_set_mtime(e, 234567, 543);
 719         archive_entry_set_nlink(e, 345);
 720         archive_entry_set_size(e, 123456789);
 721         archive_entry_set_uid(e, 23);
 722         /* Retrieve a stat structure. */
 723         assert((pst = archive_entry_stat(e)) != NULL);
 724         if (pst == NULL)
 725                 return;
 726         /* Check that the values match. */
 727         assertEqualInt(pst->st_atime, 456789);
 728         assertEqualInt(pst->st_ctime, 345678);
 729         assertEqualInt(pst->st_dev, 123);
 730         assertEqualInt(pst->st_gid, 34);
 731         assertEqualInt(pst->st_ino, 234);
 732         assertEqualInt(pst->st_mode, 012345);
 733         assertEqualInt(pst->st_mtime, 234567);
 734         assertEqualInt(pst->st_nlink, 345);
 735         assertEqualInt(pst->st_size, 123456789);
 736         assertEqualInt(pst->st_uid, 23);
 737 #ifdef __FreeBSD__
 738         /* On FreeBSD, high-res timestamp data should come through. */
 739         assertEqualInt(pst->st_atimespec.tv_nsec, 321);
 740         assertEqualInt(pst->st_ctimespec.tv_nsec, 432);
 741         assertEqualInt(pst->st_mtimespec.tv_nsec, 543);
 742 #endif
 743
 744         /* Changing any one value should update struct stat. */
 745         archive_entry_set_atime(e, 456788, 0);
 746         assert((pst = archive_entry_stat(e)) != NULL);
 747         if (pst == NULL)
 748                 return;
 749         assertEqualInt(pst->st_atime, 456788);
 750         archive_entry_set_ctime(e, 345677, 431);
 751         assert((pst = archive_entry_stat(e)) != NULL);
 752         if (pst == NULL)
 753                 return;
 754         assertEqualInt(pst->st_ctime, 345677);
 755         archive_entry_set_dev(e, 122);
 756         assert((pst = archive_entry_stat(e)) != NULL);
 757         if (pst == NULL)
 758                 return;
 759         assertEqualInt(pst->st_dev, 122);
 760         archive_entry_set_gid(e, 33);
 761         assert((pst = archive_entry_stat(e)) != NULL);
 762         if (pst == NULL)
 763                 return;
 764         assertEqualInt(pst->st_gid, 33);
 765         archive_entry_set_ino(e, 233);
 766         assert((pst = archive_entry_stat(e)) != NULL);
 767         if (pst == NULL)
 768                 return;
 769         assertEqualInt(pst->st_ino, 233);
 770         archive_entry_set_mode(e, 012344);
 771         assert((pst = archive_entry_stat(e)) != NULL);
 772         if (pst == NULL)
 773                 return;
 774         assertEqualInt(pst->st_mode, 012344);
 775         archive_entry_set_mtime(e, 234566, 542);
 776         assert((pst = archive_entry_stat(e)) != NULL);
 777         if (pst == NULL)
 778                 return;
 779         assertEqualInt(pst->st_mtime, 234566);
 780         archive_entry_set_nlink(e, 344);
 781         assert((pst = archive_entry_stat(e)) != NULL);
 782         if (pst == NULL)
 783                 return;
 784         assertEqualInt(pst->st_nlink, 344);
 785         archive_entry_set_size(e, 123456788);
 786         assert((pst = archive_entry_stat(e)) != NULL);
 787         if (pst == NULL)
 788                 return;
 789         assertEqualInt(pst->st_size, 123456788);
 790         archive_entry_set_uid(e, 22);
 791         assert((pst = archive_entry_stat(e)) != NULL);
 792         if (pst == NULL)
 793                 return;
 794         assertEqualInt(pst->st_uid, 22);
 795         /* We don't need to check high-res fields here. */
 796
 797         /*
 798          * Test dev/major/minor interfaces.  Setting 'dev' or 'rdev'
 799          * should change the corresponding major/minor values, and
 800          * vice versa.
 801          *
 802          * The test here is system-specific because it assumes that
 803          * makedev(), major(), and minor() are defined in sys/stat.h.
 804          * I'm not too worried about it, though, because the code is
 805          * simple.  If it works on FreeBSD, it's unlikely to be broken
 806          * anywhere else.  Note: The functionality is present on every
 807          * platform even if these tests only run some places;
 808          * libarchive's more extensive configuration logic should find
 809          * the necessary definitions on every platform.
 810          */
 811 #if __FreeBSD__
 812         archive_entry_set_dev(e, 0x12345678);
 813         assertEqualInt(archive_entry_devmajor(e), major(0x12345678));
 814         assertEqualInt(archive_entry_devminor(e), minor(0x12345678));
 815         assertEqualInt(archive_entry_dev(e), 0x12345678);
 816         archive_entry_set_devmajor(e, 0xfe);
 817         archive_entry_set_devminor(e, 0xdcba98);
 818         assertEqualInt(archive_entry_devmajor(e), 0xfe);
 819         assertEqualInt(archive_entry_devminor(e), 0xdcba98);
 820         assertEqualInt(archive_entry_dev(e), makedev(0xfe, 0xdcba98));
 821         archive_entry_set_rdev(e, 0x12345678);
 822         assertEqualInt(archive_entry_rdevmajor(e), major(0x12345678));
 823         assertEqualInt(archive_entry_rdevminor(e), minor(0x12345678));
 824         assertEqualInt(archive_entry_rdev(e), 0x12345678);
 825         archive_entry_set_rdevmajor(e, 0xfe);
 826         archive_entry_set_rdevminor(e, 0xdcba98);
 827         assertEqualInt(archive_entry_rdevmajor(e), 0xfe);
 828         assertEqualInt(archive_entry_rdevminor(e), 0xdcba98);
 829         assertEqualInt(archive_entry_rdev(e), makedev(0xfe, 0xdcba98));
 830 #endif
 831
 832         /*
 833          * Exercise the character-conversion logic, if we can.
 834          */
 835         if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
 836                 skipping("Can't exercise charset-conversion logic without"
 837                         " a suitable locale.");
 838         } else {
 839                 /* A filename that cannot be converted to wide characters. */
 840                 archive_entry_copy_pathname(e, "abc\314\214mno\374xyz");
 841                 failure("Converting invalid chars to Unicode should fail.");
 842                 assert(NULL == archive_entry_pathname_w(e));
 843                 /*
 844                   failure("Converting invalid chars to UTF-8 should fail.");
 845                   assert(NULL == archive_entry_pathname_utf8(e));
 846                 */
 847
 848                 /* A group name that cannot be converted. */
 849                 archive_entry_copy_gname(e, "abc\314\214mno\374xyz");
 850                 failure("Converting invalid chars to Unicode should fail.");
 851                 assert(NULL == archive_entry_gname_w(e));
 852
 853                 /* A user name that cannot be converted. */
 854                 archive_entry_copy_uname(e, "abc\314\214mno\374xyz");
 855                 failure("Converting invalid chars to Unicode should fail.");
 856                 assert(NULL == archive_entry_uname_w(e));
 857
 858                 /* A hardlink target that cannot be converted. */
 859                 archive_entry_copy_hardlink(e, "abc\314\214mno\374xyz");
 860                 failure("Converting invalid chars to Unicode should fail.");
 861                 assert(NULL == archive_entry_hardlink_w(e));
 862
 863                 /* A symlink target that cannot be converted. */
 864                 archive_entry_copy_symlink(e, "abc\314\214mno\374xyz");
 865                 failure("Converting invalid chars to Unicode should fail.");
 866                 assert(NULL == archive_entry_symlink_w(e));
 867         }
 868
 869         l = 0x12345678L;
 870         wc = (wchar_t)l; /* Wide character too big for UTF-8. */
 871         if (NULL == setlocale(LC_ALL, "C") || (long)wc != l) {
 872                 skipping("Testing charset conversion failure requires 32-bit wchar_t and support for \"C\" locale.");
 873         } else {
 874                 /*
 875                  * Build the string L"xxx\U12345678yyy\u5678zzz" without
 876                  * using wcscpy or C99 \u#### syntax.
 877                  */
 878                 name = "xxxAyyyBzzz";
 879                 for (i = 0; i < (int)strlen(name); ++i)
 880                         wbuff[i] = name[i];
 881                 wbuff[3] = (wchar_t)0x12345678;
 882                 wbuff[7] = (wchar_t)0x5678;
 883                 /* A Unicode filename that cannot be converted to UTF-8. */
 884                 archive_entry_copy_pathname_w(e, wbuff);
 885                 failure("Converting wide characters from Unicode should fail.");
 886                 assertEqualString(NULL, archive_entry_pathname(e));
 887         }
 888
 889         /* Release the experimental entry. */
 890         archive_entry_free(e);
 891 }