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         archive_test_set_acls(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         archive_test_set_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]));
 246         assertA(0 == archive_write_header(a, ae));
 247
 248
 249         /* A more extensive set of ACLs. */
 250         archive_test_set_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
 251         assertA(0 == archive_write_header(a, ae));
 252
 253         /*
 254          * Check that clearing ACLs gets rid of them all by repeating
 255          * the first test.
 256          */
 257         archive_test_set_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]));
 258         assertA(0 == archive_write_header(a, ae));
 259         archive_entry_free(ae);
 260
 261         /* Close out the archive. */
 262         assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
 263         assertEqualInt(ARCHIVE_OK, archive_write_free(a));
 264
 265         /* Write out the data we generated to a file for manual inspection. */
 266         assert(NULL != (f = fopen("testout", "wb")));
 267         assertEqualInt(used, (size_t)fwrite(buff, 1, (unsigned int)used, f));
 268         fclose(f);
 269
 270         /* Write out the reference data to a file for manual inspection. */
 271         extract_reference_file("test_acl_pax_posix1e.tar");
 272         reference = slurpfile(&reference_size, "test_acl_pax_posix1e.tar");
 273
 274         /* Assert that the generated data matches the built-in reference data.*/
 275         failure("Generated pax archive does not match reference; compare 'testout' to 'test_acl_pax_posix1e.tar' reference file.");
 276         assertEqualMem(buff, reference, reference_size);
 277         failure("Generated pax archive does not match reference; compare 'testout' to 'test_acl_pax_posix1e.tar' reference file.");
 278         assertEqualInt((int)used, reference_size);
 279         free(reference);
 280
 281         /* Read back each entry and check that the ACL data is right. */
 282         assert(NULL != (a = archive_read_new()));
 283         assertA(0 == archive_read_support_format_all(a));
 284         assertA(0 == archive_read_support_filter_all(a));
 285         assertA(0 == archive_read_open_memory(a, buff, used));
 286
 287         /* First item has no ACLs */
 288         assertA(0 == archive_read_next_header(a, &ae));
 289         failure("Basic ACLs shouldn't be stored as extended ACLs");
 290         assert(0 == archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 291         failure("Basic ACLs should set mode to 0142, not %04o",
 292             archive_entry_mode(ae)&0777);
 293         assert((archive_entry_mode(ae) & 0777) == 0142);
 294
 295         /* Second item has a few ACLs */
 296         assertA(0 == archive_read_next_header(a, &ae));
 297         failure("One extended ACL should flag all ACLs to be returned.");
 298         assert(4 == archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 299         archive_test_compare_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
 300             ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0142);
 301         failure("Basic ACLs should set mode to 0142, not %04o",
 302             archive_entry_mode(ae)&0777);
 303         assert((archive_entry_mode(ae) & 0777) == 0142);
 304
 305         /* Third item has pretty extensive ACLs */
 306         assertA(0 == archive_read_next_header(a, &ae));
 307         assertEqualInt(6, archive_entry_acl_reset(ae,
 308             ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 309         archive_test_compare_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]),
 310             ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0543);
 311         failure("Basic ACLs should set mode to 0543, not %04o",
 312             archive_entry_mode(ae)&0777);
 313         assert((archive_entry_mode(ae) & 0777) == 0543);
 314
 315         /* Fourth item has no ACLs */
 316         assertA(0 == archive_read_next_header(a, &ae));
 317         failure("Basic ACLs shouldn't be stored as extended ACLs");
 318         assert(0 == archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 319         failure("Basic ACLs should set mode to 0142, not %04o",
 320             archive_entry_mode(ae)&0777);
 321         assert((archive_entry_mode(ae) & 0777) == 0142);
 322
 323         /* Close the archive. */
 324         assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
 325         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 326 }
 327
 328 DEFINE_TEST(test_acl_pax_nfs4)
 329 {
 330         struct archive *a;
 331         struct archive_entry *ae;
 332         size_t used;
 333         FILE *f;
 334         void *reference;
 335         size_t reference_size;
 336
 337         /* Write an archive to memory. */
 338         assert(NULL != (a = archive_write_new()));
 339         assertA(0 == archive_write_set_format_pax(a));
 340         assertA(0 == archive_write_add_filter_none(a));
 341         assertA(0 == archive_write_set_bytes_per_block(a, 1));
 342         assertA(0 == archive_write_set_bytes_in_last_block(a, 1));
 343         assertA(0 == archive_write_open_memory(a, buff, sizeof(buff), &used));
 344
 345         /* Write a series of files to the archive with different ACL info. */
 346
 347         /* Create a simple archive_entry. */
 348         assert((ae = archive_entry_new()) != NULL);
 349         archive_entry_set_pathname(ae, "file");
 350         archive_entry_set_mode(ae, S_IFREG | 0777);
 351
 352         /* NFS4 ACLs mirroring 0754 file mode */
 353         archive_test_set_acls(ae, acls3, sizeof(acls3)/sizeof(acls3[0]));
 354         assertA(0 == archive_write_header(a, ae));
 355
 356         /* A more extensive set of NFS4 ACLs. */
 357         archive_test_set_acls(ae, acls4, sizeof(acls4)/sizeof(acls4[0]));
 358         assertA(0 == archive_write_header(a, ae));
 359
 360         /* Set with special (audit, alarm) NFS4 ACLs. */
 361         archive_test_set_acls(ae, acls5, sizeof(acls5)/sizeof(acls5[0]));
 362         assertA(0 == archive_write_header(a, ae));
 363
 364         archive_entry_free(ae);
 365
 366         /* Close out the archive. */
 367         assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
 368         assertEqualInt(ARCHIVE_OK, archive_write_free(a));
 369
 370         /* Write out the data we generated to a file for manual inspection. */
 371         assert(NULL != (f = fopen("testout", "wb")));
 372         assertEqualInt(used, (size_t)fwrite(buff, 1, (unsigned int)used, f));
 373         fclose(f);
 374
 375         /* Write out the reference data to a file for manual inspection. */
 376         extract_reference_file("test_acl_pax_nfs4.tar");
 377         reference = slurpfile(&reference_size, "test_acl_pax_nfs4.tar");
 378
 379         /* Assert that the generated data matches the built-in reference data.*/
 380         failure("Generated pax archive does not match reference; compare 'testout' to 'test_acl_pax_nfs4.tar' reference file.");
 381         assertEqualMem(buff, reference, reference_size);
 382         failure("Generated pax archive does not match reference; compare 'testout' to 'test_acl_pax_nfs4.tar' reference file.");
 383         assertEqualInt((int)used, reference_size);
 384         free(reference);
 385
 386         /* Read back each entry and check that the ACL data is right. */
 387         assert(NULL != (a = archive_read_new()));
 388         assertA(0 == archive_read_support_format_all(a));
 389         assertA(0 == archive_read_support_filter_all(a));
 390         assertA(0 == archive_read_open_memory(a, buff, used));
 391
 392         /* First item has NFS4 ACLs mirroring file mode */
 393         assertA(0 == archive_read_next_header(a, &ae));
 394         assertEqualInt(3, archive_entry_acl_reset(ae,
 395             ARCHIVE_ENTRY_ACL_TYPE_ALLOW));
 396         archive_test_compare_acls(ae, acls3, sizeof(acls3)/sizeof(acls3[0]),
 397             ARCHIVE_ENTRY_ACL_TYPE_ALLOW, 0);
 398
 399         /* Second item has has more fine-grained NFS4 ACLs */
 400         assertA(0 == archive_read_next_header(a, &ae));
 401         assertEqualInt(6, archive_entry_acl_reset(ae,
 402             ARCHIVE_ENTRY_ACL_TYPE_NFS4));
 403         archive_test_compare_acls(ae, acls4, sizeof(acls4)/sizeof(acls4[0]),
 404             ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);
 405
 406         /* Third item has has audit and alarm NFS4 ACLs */
 407         assertA(0 == archive_read_next_header(a, &ae));
 408         assertEqualInt(6, archive_entry_acl_reset(ae,
 409             ARCHIVE_ENTRY_ACL_TYPE_NFS4));
 410         archive_test_compare_acls(ae, acls5, sizeof(acls5)/sizeof(acls5[0]),
 411             ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);
 412
 413         /* Close the archive. */
 414         assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
 415         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 416 }