contrib/libarchive/libarchive/test/test_acl_pax.c

   1 /*-
   2  * Copyright (c) 2003-2007 Tim Kientzle
   3  * Copyright (c) 2016 Martin Matuska
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26 #include "test.h"
  27 __FBSDID("$FreeBSD$");
  28
  29 /*
  30  * Exercise the system-independent portion of the ACL support.
  31  * Check that pax archive can save and restore POSIX.1e ACL data.
  32  *
  33  * This should work on all systems, regardless of whether local
  34  * filesystems support ACLs or not.
  35  */
  36
  37 static unsigned char buff[16384];
  38
  39 static struct archive_test_acl_t acls0[] = {
  40         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_EXECUTE,
  41           ARCHIVE_ENTRY_ACL_USER_OBJ, 0, "" },
  42         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,
  43           ARCHIVE_ENTRY_ACL_GROUP_OBJ, 0, "" },
  44         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_WRITE,
  45           ARCHIVE_ENTRY_ACL_OTHER, 0, "" },
  46 };
  47
  48 static struct archive_test_acl_t acls1[] = {
  49         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_EXECUTE,
  50           ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },
  51         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,
  52           ARCHIVE_ENTRY_ACL_USER, 77, "user77" },
  53         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,
  54           ARCHIVE_ENTRY_ACL_GROUP_OBJ, -1, "" },
  55         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_WRITE,
  56           ARCHIVE_ENTRY_ACL_OTHER, -1, "" },
  57 };
  58
  59 static struct archive_test_acl_t acls2[] = {
  60         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_EXECUTE | ARCHIVE_ENTRY_ACL_READ,
  61           ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },
  62         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,
  63           ARCHIVE_ENTRY_ACL_USER, 77, "user77" },
  64         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0,
  65           ARCHIVE_ENTRY_ACL_USER, 78, "user78" },
  66         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,
  67           ARCHIVE_ENTRY_ACL_GROUP_OBJ, -1, "" },
  68         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0007,
  69           ARCHIVE_ENTRY_ACL_GROUP, 78, "group78" },
  70         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_WRITE | ARCHIVE_ENTRY_ACL_EXECUTE,
  71           ARCHIVE_ENTRY_ACL_OTHER, -1, "" },
  72 };
  73
  74 static struct archive_test_acl_t acls3[] = {
  75         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
  76             ARCHIVE_ENTRY_ACL_READ_DATA |
  77             ARCHIVE_ENTRY_ACL_WRITE_DATA |
  78             ARCHIVE_ENTRY_ACL_EXECUTE |
  79             ARCHIVE_ENTRY_ACL_APPEND_DATA |
  80             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
  81             ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES |
  82             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
  83             ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS |
  84             ARCHIVE_ENTRY_ACL_READ_ACL |
  85             ARCHIVE_ENTRY_ACL_WRITE_ACL |
  86             ARCHIVE_ENTRY_ACL_WRITE_OWNER |
  87             ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
  88           ARCHIVE_ENTRY_ACL_USER_OBJ, 0, "" },
  89         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
  90             ARCHIVE_ENTRY_ACL_READ_DATA |
  91             ARCHIVE_ENTRY_ACL_WRITE_DATA |
  92             ARCHIVE_ENTRY_ACL_APPEND_DATA |
  93             ARCHIVE_ENTRY_ACL_READ_ACL |
  94             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
  95             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
  96             ARCHIVE_ENTRY_ACL_READ_ACL |
  97             ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
  98           ARCHIVE_ENTRY_ACL_GROUP_OBJ, 0, "" },
  99         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 100             ARCHIVE_ENTRY_ACL_READ_DATA |
 101             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
 102             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
 103             ARCHIVE_ENTRY_ACL_READ_ACL |
 104             ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
 105           ARCHIVE_ENTRY_ACL_EVERYONE, 0, "" },
 106 };
 107
 108 static struct archive_test_acl_t acls4[] = {
 109         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 110             ARCHIVE_ENTRY_ACL_READ_DATA |
 111             ARCHIVE_ENTRY_ACL_WRITE_DATA |
 112             ARCHIVE_ENTRY_ACL_APPEND_DATA |
 113             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
 114             ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES |
 115             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
 116             ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS |
 117             ARCHIVE_ENTRY_ACL_READ_ACL |
 118             ARCHIVE_ENTRY_ACL_WRITE_ACL |
 119             ARCHIVE_ENTRY_ACL_WRITE_OWNER |
 120             ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
 121           ARCHIVE_ENTRY_ACL_USER_OBJ, 0, "" },
 122         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 123             ARCHIVE_ENTRY_ACL_READ_DATA |
 124             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
 125             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
 126             ARCHIVE_ENTRY_ACL_READ_ACL |
 127             ARCHIVE_ENTRY_ACL_SYNCHRONIZE |
 128             ARCHIVE_ENTRY_ACL_ENTRY_INHERITED,
 129           ARCHIVE_ENTRY_ACL_USER, 77, "user77" },
 130         { ARCHIVE_ENTRY_ACL_TYPE_DENY,
 131             ARCHIVE_ENTRY_ACL_READ_DATA |
 132             ARCHIVE_ENTRY_ACL_WRITE_DATA |
 133             ARCHIVE_ENTRY_ACL_EXECUTE,
 134           ARCHIVE_ENTRY_ACL_USER, 78, "user78" },
 135         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 136             ARCHIVE_ENTRY_ACL_READ_DATA |
 137             ARCHIVE_ENTRY_ACL_WRITE_DATA |
 138             ARCHIVE_ENTRY_ACL_APPEND_DATA |
 139             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
 140             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
 141             ARCHIVE_ENTRY_ACL_READ_ACL |
 142             ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
 143           ARCHIVE_ENTRY_ACL_GROUP_OBJ, 0, "" },
 144         { ARCHIVE_ENTRY_ACL_TYPE_DENY,
 145             ARCHIVE_ENTRY_ACL_WRITE_DATA |
 146             ARCHIVE_ENTRY_ACL_APPEND_DATA |
 147             ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES |
 148             ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS |
 149             ARCHIVE_ENTRY_ACL_WRITE_ACL |
 150             ARCHIVE_ENTRY_ACL_WRITE_OWNER,
 151           ARCHIVE_ENTRY_ACL_GROUP, 78, "group78" },
 152         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 153             ARCHIVE_ENTRY_ACL_READ_DATA |
 154             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
 155             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
 156             ARCHIVE_ENTRY_ACL_READ_ACL |
 157             ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
 158           ARCHIVE_ENTRY_ACL_EVERYONE, 0, "" },
 159 };
 160
 161 static struct archive_test_acl_t acls5[] = {
 162         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 163             ARCHIVE_ENTRY_ACL_READ_DATA |
 164             ARCHIVE_ENTRY_ACL_WRITE_DATA |
 165             ARCHIVE_ENTRY_ACL_EXECUTE |
 166             ARCHIVE_ENTRY_ACL_APPEND_DATA |
 167             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
 168             ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES |
 169             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
 170             ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS |
 171             ARCHIVE_ENTRY_ACL_READ_ACL |
 172             ARCHIVE_ENTRY_ACL_WRITE_ACL |
 173             ARCHIVE_ENTRY_ACL_WRITE_OWNER |
 174             ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
 175           ARCHIVE_ENTRY_ACL_USER_OBJ, 0, "" },
 176         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 177             ARCHIVE_ENTRY_ACL_READ_DATA |
 178             ARCHIVE_ENTRY_ACL_WRITE_DATA |
 179             ARCHIVE_ENTRY_ACL_APPEND_DATA |
 180             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
 181             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
 182             ARCHIVE_ENTRY_ACL_READ_ACL |
 183             ARCHIVE_ENTRY_ACL_WRITE_OWNER |
 184             ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
 185           ARCHIVE_ENTRY_ACL_USER, 77, "user77" },
 186         { ARCHIVE_ENTRY_ACL_TYPE_AUDIT,
 187             ARCHIVE_ENTRY_ACL_WRITE_DATA |
 188             ARCHIVE_ENTRY_ACL_APPEND_DATA |
 189             ARCHIVE_ENTRY_ACL_ENTRY_SUCCESSFUL_ACCESS,
 190           ARCHIVE_ENTRY_ACL_USER, 77, "user77" },
 191         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 192             ARCHIVE_ENTRY_ACL_READ_DATA |
 193             ARCHIVE_ENTRY_ACL_WRITE_DATA |
 194             ARCHIVE_ENTRY_ACL_APPEND_DATA |
 195             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
 196             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
 197             ARCHIVE_ENTRY_ACL_READ_ACL |
 198             ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
 199           ARCHIVE_ENTRY_ACL_GROUP_OBJ, 0, "" },
 200         { ARCHIVE_ENTRY_ACL_TYPE_ALARM,
 201             ARCHIVE_ENTRY_ACL_READ_DATA |
 202             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
 203             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
 204             ARCHIVE_ENTRY_ACL_READ_ACL |
 205             ARCHIVE_ENTRY_ACL_ENTRY_FAILED_ACCESS,
 206           ARCHIVE_ENTRY_ACL_GROUP, 78, "group78" },
 207         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 208             ARCHIVE_ENTRY_ACL_READ_DATA |
 209             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
 210             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
 211             ARCHIVE_ENTRY_ACL_READ_ACL |
 212             ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
 213           ARCHIVE_ENTRY_ACL_EVERYONE, 0, "" },
 214 };
 215
 216 DEFINE_TEST(test_acl_pax_posix1e)
 217 {
 218         struct archive *a;
 219         struct archive_entry *ae;
 220         size_t used;
 221         FILE *f;
 222         void *reference;
 223         size_t reference_size;
 224
 225         /* Write an archive to memory. */
 226         assert(NULL != (a = archive_write_new()));
 227         assertA(0 == archive_write_set_format_pax(a));
 228         assertA(0 == archive_write_add_filter_none(a));
 229         assertA(0 == archive_write_set_bytes_per_block(a, 1));
 230         assertA(0 == archive_write_set_bytes_in_last_block(a, 1));
 231         assertA(0 == archive_write_open_memory(a, buff, sizeof(buff), &used));
 232
 233         /* Write a series of files to the archive with different ACL info. */
 234
 235         /* Create a simple archive_entry. */
 236         assert((ae = archive_entry_new()) != NULL);
 237         archive_entry_set_pathname(ae, "file");
 238         archive_entry_set_mode(ae, S_IFREG | 0777);
 239
 240         /* Basic owner/owning group should just update mode bits. */
 241         assertEntrySetAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]));
 242         assertA(0 == archive_write_header(a, ae));
 243
 244         /* With any extended ACL entry, we should read back a full set. */
 245         assertEntrySetAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]));
 246         assertA(0 == archive_write_header(a, ae));
 247
 248         /* A more extensive set of ACLs. */
 249         assertEntrySetAcls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
 250         assertA(0 == archive_write_header(a, ae));
 251
 252         /*
 253          * Check that clearing ACLs gets rid of them all by repeating
 254          * the first test.
 255          */
 256         assertEntrySetAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]));
 257         assertA(0 == archive_write_header(a, ae));
 258         archive_entry_free(ae);
 259
 260         /* Close out the archive. */
 261         assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
 262         assertEqualInt(ARCHIVE_OK, archive_write_free(a));
 263
 264         /* Write out the data we generated to a file for manual inspection. */
 265         assert(NULL != (f = fopen("testout", "wb")));
 266         assertEqualInt(used, (size_t)fwrite(buff, 1, (unsigned int)used, f));
 267         fclose(f);
 268
 269         /* Write out the reference data to a file for manual inspection. */
 270         extract_reference_file("test_acl_pax_posix1e.tar");
 271         reference = slurpfile(&reference_size, "test_acl_pax_posix1e.tar");
 272
 273         /* Assert that the generated data matches the built-in reference data.*/
 274         failure("Generated pax archive does not match reference; compare 'testout' to 'test_acl_pax_posix1e.tar' reference file.");
 275         assertEqualMem(buff, reference, reference_size);
 276         failure("Generated pax archive does not match reference; compare 'testout' to 'test_acl_pax_posix1e.tar' reference file.");
 277         assertEqualInt((int)used, reference_size);
 278         free(reference);
 279
 280         /* Read back each entry and check that the ACL data is right. */
 281         assert(NULL != (a = archive_read_new()));
 282         assertA(0 == archive_read_support_format_all(a));
 283         assertA(0 == archive_read_support_filter_all(a));
 284         assertA(0 == archive_read_open_memory(a, buff, used));
 285
 286         /* First item has no ACLs */
 287         assertA(0 == archive_read_next_header(a, &ae));
 288         failure("Basic ACLs shouldn't be stored as extended ACLs");
 289         assert(0 == archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 290         failure("Basic ACLs should set mode to 0142, not %04o",
 291             archive_entry_mode(ae)&0777);
 292         assert((archive_entry_mode(ae) & 0777) == 0142);
 293
 294         /* Second item has a few ACLs */
 295         assertA(0 == archive_read_next_header(a, &ae));
 296         failure("One extended ACL should flag all ACLs to be returned.");
 297         assert(4 == archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 298         assertEntryCompareAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
 299             ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0142);
 300         failure("Basic ACLs should set mode to 0142, not %04o",
 301             archive_entry_mode(ae)&0777);
 302         assert((archive_entry_mode(ae) & 0777) == 0142);
 303
 304         /* Third item has pretty extensive ACLs */
 305         assertA(0 == archive_read_next_header(a, &ae));
 306         assertEqualInt(6, archive_entry_acl_reset(ae,
 307             ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 308         assertEntryCompareAcls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]),
 309             ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0543);
 310         failure("Basic ACLs should set mode to 0543, not %04o",
 311             archive_entry_mode(ae)&0777);
 312         assert((archive_entry_mode(ae) & 0777) == 0543);
 313
 314         /* Fourth item has no ACLs */
 315         assertA(0 == archive_read_next_header(a, &ae));
 316         failure("Basic ACLs shouldn't be stored as extended ACLs");
 317         assert(0 == archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 318         failure("Basic ACLs should set mode to 0142, not %04o",
 319             archive_entry_mode(ae)&0777);
 320         assert((archive_entry_mode(ae) & 0777) == 0142);
 321
 322         /* Close the archive. */
 323         assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
 324         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 325 }
 326
 327 DEFINE_TEST(test_acl_pax_nfs4)
 328 {
 329         struct archive *a;
 330         struct archive_entry *ae;
 331         size_t used;
 332         FILE *f;
 333         void *reference;
 334         size_t reference_size;
 335
 336         /* Write an archive to memory. */
 337         assert(NULL != (a = archive_write_new()));
 338         assertA(0 == archive_write_set_format_pax(a));
 339         assertA(0 == archive_write_add_filter_none(a));
 340         assertA(0 == archive_write_set_bytes_per_block(a, 1));
 341         assertA(0 == archive_write_set_bytes_in_last_block(a, 1));
 342         assertA(0 == archive_write_open_memory(a, buff, sizeof(buff), &used));
 343
 344         /* Write a series of files to the archive with different ACL info. */
 345
 346         /* Create a simple archive_entry. */
 347         assert((ae = archive_entry_new()) != NULL);
 348         archive_entry_set_pathname(ae, "file");
 349         archive_entry_set_mode(ae, S_IFREG | 0777);
 350
 351         /* NFS4 ACLs mirroring 0754 file mode */
 352         assertEntrySetAcls(ae, acls3, sizeof(acls3)/sizeof(acls3[0]));
 353         assertA(0 == archive_write_header(a, ae));
 354
 355         /* A more extensive set of NFS4 ACLs. */
 356         assertEntrySetAcls(ae, acls4, sizeof(acls4)/sizeof(acls4[0]));
 357         assertA(0 == archive_write_header(a, ae));
 358
 359         /* Set with special (audit, alarm) NFS4 ACLs. */
 360         assertEntrySetAcls(ae, acls5, sizeof(acls5)/sizeof(acls5[0]));
 361         assertA(0 == archive_write_header(a, ae));
 362
 363         archive_entry_free(ae);
 364
 365         /* Close out the archive. */
 366         assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
 367         assertEqualInt(ARCHIVE_OK, archive_write_free(a));
 368
 369         /* Write out the data we generated to a file for manual inspection. */
 370         assert(NULL != (f = fopen("testout", "wb")));
 371         assertEqualInt(used, (size_t)fwrite(buff, 1, (unsigned int)used, f));
 372         fclose(f);
 373
 374         /* Write out the reference data to a file for manual inspection. */
 375         extract_reference_file("test_acl_pax_nfs4.tar");
 376         reference = slurpfile(&reference_size, "test_acl_pax_nfs4.tar");
 377
 378         /* Assert that the generated data matches the built-in reference data.*/
 379         failure("Generated pax archive does not match reference; compare 'testout' to 'test_acl_pax_nfs4.tar' reference file.");
 380         assertEqualMem(buff, reference, reference_size);
 381         failure("Generated pax archive does not match reference; compare 'testout' to 'test_acl_pax_nfs4.tar' reference file.");
 382         assertEqualInt((int)used, reference_size);
 383         free(reference);
 384
 385         /* Read back each entry and check that the ACL data is right. */
 386         assert(NULL != (a = archive_read_new()));
 387         assertA(0 == archive_read_support_format_all(a));
 388         assertA(0 == archive_read_support_filter_all(a));
 389         assertA(0 == archive_read_open_memory(a, buff, used));
 390
 391         /* First item has NFS4 ACLs mirroring file mode */
 392         assertA(0 == archive_read_next_header(a, &ae));
 393         assertEqualInt(3, archive_entry_acl_reset(ae,
 394             ARCHIVE_ENTRY_ACL_TYPE_ALLOW));
 395         assertEntryCompareAcls(ae, acls3, sizeof(acls3)/sizeof(acls3[0]),
 396             ARCHIVE_ENTRY_ACL_TYPE_ALLOW, 0);
 397
 398         /* Second item has has more fine-grained NFS4 ACLs */
 399         assertA(0 == archive_read_next_header(a, &ae));
 400         assertEqualInt(6, archive_entry_acl_reset(ae,
 401             ARCHIVE_ENTRY_ACL_TYPE_NFS4));
 402         assertEntryCompareAcls(ae, acls4, sizeof(acls4)/sizeof(acls4[0]),
 403             ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);
 404
 405         /* Third item has has audit and alarm NFS4 ACLs */
 406         assertA(0 == archive_read_next_header(a, &ae));
 407         assertEqualInt(6, archive_entry_acl_reset(ae,
 408             ARCHIVE_ENTRY_ACL_TYPE_NFS4));
 409         assertEntryCompareAcls(ae, acls5, sizeof(acls5)/sizeof(acls5[0]),
 410             ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);
 411
 412         /* Close the archive. */
 413         assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
 414         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 415 }