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