contrib/libarchive/libarchive/test/test_acl_platform_posix1e.c

   1 /*-
   2  * Copyright (c) 2003-2008 Tim Kientzle
   3  * Copyright (c) 2017 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: head/lib/libarchive/test/test_acl_freebsd.c 189427 2009-03-06 04:21:23Z kientzle $");
  28
  29 #if ARCHIVE_ACL_POSIX1E
  30 #include <sys/acl.h>
  31 #if HAVE_ACL_GET_PERM
  32 #include <acl/libacl.h>
  33 #define ACL_GET_PERM acl_get_perm
  34 #elif HAVE_ACL_GET_PERM_NP
  35 #define ACL_GET_PERM acl_get_perm_np
  36 #endif
  37
  38 static struct archive_test_acl_t acls2[] = {
  39         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_EXECUTE | ARCHIVE_ENTRY_ACL_READ,
  40           ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },
  41         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,
  42           ARCHIVE_ENTRY_ACL_USER, 77, "user77" },
  43         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0,
  44           ARCHIVE_ENTRY_ACL_USER, 78, "user78" },
  45         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,
  46           ARCHIVE_ENTRY_ACL_GROUP_OBJ, -1, "" },
  47         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0007,
  48           ARCHIVE_ENTRY_ACL_GROUP, 78, "group78" },
  49         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
  50           ARCHIVE_ENTRY_ACL_WRITE | ARCHIVE_ENTRY_ACL_EXECUTE,
  51           ARCHIVE_ENTRY_ACL_OTHER, -1, "" },
  52         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
  53           ARCHIVE_ENTRY_ACL_WRITE | ARCHIVE_ENTRY_ACL_READ | ARCHIVE_ENTRY_ACL_EXECUTE,
  54           ARCHIVE_ENTRY_ACL_MASK, -1, "" },
  55 };
  56
  57 static int
  58 #if ARCHIVE_ACL_SUNOS
  59 acl_entry_get_perm(aclent_t *aclent)
  60 #else
  61 acl_entry_get_perm(acl_entry_t aclent)
  62 #endif
  63 {
  64         int permset = 0;
  65 #if ARCHIVE_ACL_FREEBSD || ARCHIVE_ACL_LIBACL
  66         acl_permset_t opaque_ps;
  67 #endif
  68
  69 #if ARCHIVE_ACL_SUNOS
  70         if (aclent->a_perm & 1)
  71                 permset |= ARCHIVE_ENTRY_ACL_EXECUTE;
  72         if (aclent->a_perm & 2)
  73                 permset |= ARCHIVE_ENTRY_ACL_WRITE;
  74         if (aclent->a_perm & 4)
  75                 permset |= ARCHIVE_ENTRY_ACL_READ;
  76 #else
  77         /* translate the silly opaque permset to a bitmap */
  78         acl_get_permset(aclent, &opaque_ps);
  79         if (ACL_GET_PERM(opaque_ps, ACL_EXECUTE))
  80                 permset |= ARCHIVE_ENTRY_ACL_EXECUTE;
  81         if (ACL_GET_PERM(opaque_ps, ACL_WRITE))
  82                 permset |= ARCHIVE_ENTRY_ACL_WRITE;
  83         if (ACL_GET_PERM(opaque_ps, ACL_READ))
  84                 permset |= ARCHIVE_ENTRY_ACL_READ;
  85 #endif
  86         return permset;
  87 }
  88
  89 #if 0
  90 static int
  91 acl_get_specific_entry(acl_t acl, acl_tag_t requested_tag_type, int requested_tag) {
  92         int entry_id = ACL_FIRST_ENTRY;
  93         acl_entry_t acl_entry;
  94         acl_tag_t acl_tag_type;
  95
  96         while (1 == acl_get_entry(acl, entry_id, &acl_entry)) {
  97                 /* After the first time... */
  98                 entry_id = ACL_NEXT_ENTRY;
  99
 100                 /* If this matches, return perm mask */
 101                 acl_get_tag_type(acl_entry, &acl_tag_type);
 102                 if (acl_tag_type == requested_tag_type) {
 103                         switch (acl_tag_type) {
 104                         case ACL_USER_OBJ:
 105                                 if ((uid_t)requested_tag == *(uid_t *)(acl_get_qualifier(acl_entry))) {
 106                                         return acl_entry_get_perm(acl_entry);
 107                                 }
 108                                 break;
 109                         case ACL_GROUP_OBJ:
 110                                 if ((gid_t)requested_tag == *(gid_t *)(acl_get_qualifier(acl_entry))) {
 111                                         return acl_entry_get_perm(acl_entry);
 112                                 }
 113                                 break;
 114                         case ACL_USER:
 115                         case ACL_GROUP:
 116                         case ACL_OTHER:
 117                                 return acl_entry_get_perm(acl_entry);
 118                         default:
 119                                 failure("Unexpected ACL tag type");
 120                                 assert(0);
 121                         }
 122                 }
 123
 124
 125         }
 126         return -1;
 127 }
 128 #endif
 129
 130 #if ARCHIVE_ACL_SUNOS
 131 static int
 132 acl_match(aclent_t *aclent, struct archive_test_acl_t *myacl)
 133 {
 134
 135         if (myacl->permset != acl_entry_get_perm(aclent))
 136                 return (0);
 137
 138         switch (aclent->a_type) {
 139         case DEF_USER_OBJ:
 140         case USER_OBJ:
 141                 if (myacl->tag != ARCHIVE_ENTRY_ACL_USER_OBJ) return (0);
 142                 break;
 143                 if (myacl->tag != ARCHIVE_ENTRY_ACL_USER)
 144                         return (0);
 145                 if ((uid_t)myacl->qual != aclent->a_id)
 146                         return (0);
 147                 break;
 148         case DEF_GROUP_OBJ:
 149         case GROUP_OBJ:
 150                 if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP_OBJ) return (0);
 151                 break;
 152         case DEF_GROUP:
 153         case GROUP:
 154                 if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP)
 155                         return (0);
 156                 if ((gid_t)myacl->qual != aclent->a_id)
 157                         return (0);
 158                 break;
 159         case DEF_CLASS_OBJ:
 160         case CLASS_OBJ:
 161                 if (myacl->tag != ARCHIVE_ENTRY_ACL_MASK) return (0);
 162                 break;
 163         case DEF_OTHER_OBJ:
 164         case OTHER_OBJ:
 165                 if (myacl->tag != ARCHIVE_ENTRY_ACL_OTHER) return (0);
 166                 break;
 167         }
 168         return (1);
 169 }
 170
 171 #else   /* ARCHIVE_ACL_FREEBSD || ARCHIVE_ACL_LIBACL */
 172 static int
 173 acl_match(acl_entry_t aclent, struct archive_test_acl_t *myacl)
 174 {
 175         gid_t g, *gp;
 176         uid_t u, *up;
 177         acl_tag_t tag_type;
 178
 179         if (myacl->permset != acl_entry_get_perm(aclent))
 180                 return (0);
 181
 182         acl_get_tag_type(aclent, &tag_type);
 183         switch (tag_type) {
 184         case ACL_USER_OBJ:
 185                 if (myacl->tag != ARCHIVE_ENTRY_ACL_USER_OBJ) return (0);
 186                 break;
 187         case ACL_USER:
 188                 if (myacl->tag != ARCHIVE_ENTRY_ACL_USER)
 189                         return (0);
 190                 up = acl_get_qualifier(aclent);
 191                 u = *up;
 192                 acl_free(up);
 193                 if ((uid_t)myacl->qual != u)
 194                         return (0);
 195                 break;
 196         case ACL_GROUP_OBJ:
 197                 if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP_OBJ) return (0);
 198                 break;
 199         case ACL_GROUP:
 200                 if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP)
 201                         return (0);
 202                 gp = acl_get_qualifier(aclent);
 203                 g = *gp;
 204                 acl_free(gp);
 205                 if ((gid_t)myacl->qual != g)
 206                         return (0);
 207                 break;
 208         case ACL_MASK:
 209                 if (myacl->tag != ARCHIVE_ENTRY_ACL_MASK) return (0);
 210                 break;
 211         case ACL_OTHER:
 212                 if (myacl->tag != ARCHIVE_ENTRY_ACL_OTHER) return (0);
 213                 break;
 214         }
 215         return (1);
 216 }
 217 #endif
 218
 219 static void
 220 compare_acls(
 221 #if ARCHIVE_ACL_SUNOS
 222     void *aclp, int aclcnt,
 223 #else
 224     acl_t acl,
 225 #endif
 226     struct archive_test_acl_t *myacls, int n)
 227 {
 228         int *marker;
 229         int matched;
 230         int i;
 231 #if ARCHIVE_ACL_SUNOS
 232         int e;
 233         aclent_t *acl_entry;
 234 #else
 235         int entry_id = ACL_FIRST_ENTRY;
 236         acl_entry_t acl_entry;
 237 #endif
 238
 239         /* Count ACL entries in myacls array and allocate an indirect array. */
 240         marker = malloc(sizeof(marker[0]) * n);
 241         if (marker == NULL)
 242                 return;
 243         for (i = 0; i < n; i++)
 244                 marker[i] = i;
 245
 246         /*
 247          * Iterate over acls in system acl object, try to match each
 248          * one with an item in the myacls array.
 249          */
 250 #if ARCHIVE_ACL_SUNOS
 251         for(e = 0; e < aclcnt; e++) {
 252                 acl_entry = &((aclent_t *)aclp)[e];
 253 #else
 254         while (1 == acl_get_entry(acl, entry_id, &acl_entry)) {
 255                 /* After the first time... */
 256                 entry_id = ACL_NEXT_ENTRY;
 257 #endif
 258
 259                 /* Search for a matching entry (tag and qualifier) */
 260                 for (i = 0, matched = 0; i < n && !matched; i++) {
 261                         if (acl_match(acl_entry, &myacls[marker[i]])) {
 262                                 /* We found a match; remove it. */
 263                                 marker[i] = marker[n - 1];
 264                                 n--;
 265                                 matched = 1;
 266                         }
 267                 }
 268
 269                 /* TODO: Print out more details in this case. */
 270                 failure("ACL entry on file that shouldn't be there");
 271                 assert(matched == 1);
 272         }
 273
 274         /* Dump entries in the myacls array that weren't in the system acl. */
 275         for (i = 0; i < n; ++i) {
 276                 failure(" ACL entry missing from file: "
 277                     "type=%#010x,permset=%#010x,tag=%d,qual=%d,name=``%s''\n",
 278                     myacls[marker[i]].type, myacls[marker[i]].permset,
 279                     myacls[marker[i]].tag, myacls[marker[i]].qual,
 280                     myacls[marker[i]].name);
 281                 assert(0); /* Record this as a failure. */
 282         }
 283         free(marker);
 284 }
 285 #endif
 286
 287 /*
 288  * Verify ACL restore-to-disk.  This test is Platform-specific.
 289  */
 290
 291 DEFINE_TEST(test_acl_platform_posix1e_restore)
 292 {
 293 #if !ARCHIVE_ACL_POSIX1E
 294         skipping("POSIX.1e ACLs are not supported on this platform");
 295 #else   /* ARCHIVE_ACL_POSIX1E */
 296         struct stat st;
 297         struct archive *a;
 298         struct archive_entry *ae;
 299 #if ARCHIVE_ACL_SUNOS
 300         void *aclp;
 301         int aclcnt;
 302 #else
 303         acl_t acl;
 304 #endif
 305
 306         assertMakeFile("pretest", 0644, "a");
 307
 308         if (setTestAcl("pretest") != ARCHIVE_TEST_ACL_TYPE_POSIX1E) {
 309                 skipping("POSIX.1e ACLs are not writable on this filesystem");
 310                 return;
 311         }
 312
 313         /* Create a write-to-disk object. */
 314         assert(NULL != (a = archive_write_disk_new()));
 315         archive_write_disk_set_options(a,
 316             ARCHIVE_EXTRACT_TIME | ARCHIVE_EXTRACT_PERM | ARCHIVE_EXTRACT_ACL);
 317
 318         /* Populate an archive entry with some metadata, including ACL info */
 319         ae = archive_entry_new();
 320         assert(ae != NULL);
 321         archive_entry_set_pathname(ae, "test0");
 322         archive_entry_set_mtime(ae, 123456, 7890);
 323         archive_entry_set_size(ae, 0);
 324         assertEntrySetAcls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
 325         assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
 326         archive_entry_free(ae);
 327
 328         /* Close the archive. */
 329         assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
 330         assertEqualInt(ARCHIVE_OK, archive_write_free(a));
 331
 332         /* Verify the data on disk. */
 333         assertEqualInt(0, stat("test0", &st));
 334         assertEqualInt(st.st_mtime, 123456);
 335 #if ARCHIVE_ACL_SUNOS
 336         aclp = sunacl_get(GETACL, &aclcnt, 0, "test0");
 337         failure("acl(): errno = %d (%s)", errno, strerror(errno));
 338         assert(aclp != NULL);
 339 #else
 340         acl = acl_get_file("test0", ACL_TYPE_ACCESS);
 341         failure("acl_get_file(): errno = %d (%s)", errno, strerror(errno));
 342         assert(acl != (acl_t)NULL);
 343 #endif
 344 #if ARCHIVE_ACL_SUNOS
 345         compare_acls(aclp, aclcnt, acls2, sizeof(acls2)/sizeof(acls2[0]));
 346         free(aclp);
 347         aclp = NULL;
 348 #else
 349         compare_acls(acl, acls2, sizeof(acls2)/sizeof(acls2[0]));
 350         acl_free(acl);
 351 #endif
 352
 353 #endif  /* ARCHIVE_ACL_POSIX1E */
 354 }
 355
 356 /*
 357  * Verify ACL read-from-disk.  This test is Platform-specific.
 358  */
 359 DEFINE_TEST(test_acl_platform_posix1e_read)
 360 {
 361 #if !ARCHIVE_ACL_POSIX1E
 362         skipping("POSIX.1e ACLs are not supported on this platform");
 363 #else /* ARCHIVE_ACL_POSIX1E */
 364         struct archive *a;
 365         struct archive_entry *ae;
 366         int n, fd, flags, dflags;
 367         char *acl_text;
 368         const char *func, *acl1_text, *acl2_text, *acl3_text;
 369 #if ARCHIVE_ACL_SUNOS
 370         void *aclp;
 371         int aclcnt;
 372 #else
 373         acl_t acl1, acl2, acl3;
 374 #endif
 375
 376         /*
 377          * Manually construct a directory and two files with
 378          * different ACLs.  This also serves to verify that ACLs
 379          * are supported on the local filesystem.
 380          */
 381
 382         /* Create a test file f1 with acl1 */
 383 #if ARCHIVE_ACL_SUNOS
 384         acl1_text = "user::rwx,"
 385             "group::rwx,"
 386             "other:rwx,"
 387             "user:1:rw-,"
 388             "group:15:r-x,"
 389             "mask:rwx";
 390         aclent_t aclp1[] = {
 391             { USER_OBJ, -1, 4 | 2 | 1 },
 392             { USER, 1, 4 | 2 },
 393             { GROUP_OBJ, -1, 4 | 2 | 1 },
 394             { GROUP, 15, 4 | 1 },
 395             { CLASS_OBJ, -1, 4 | 2 | 1 },
 396             { OTHER_OBJ, -1, 4 | 2 | 1 }
 397         };
 398 #else
 399         acl1_text = "user::rwx\n"
 400             "group::rwx\n"
 401             "other::rwx\n"
 402             "user:1:rw-\n"
 403             "group:15:r-x\n"
 404             "mask::rwx";
 405         acl1 = acl_from_text(acl1_text);
 406         failure("acl_from_text(): errno = %d (%s)", errno, strerror(errno));
 407         assert((void *)acl1 != NULL);
 408 #endif
 409         fd = open("f1", O_WRONLY | O_CREAT | O_EXCL, 0777);
 410         failure("Could not create test file?!");
 411         if (!assert(fd >= 0)) {
 412 #if !ARCHIVE_ACL_SUNOS
 413                 acl_free(acl1);
 414 #endif
 415                 return;
 416         }
 417 #if ARCHIVE_ACL_SUNOS
 418         /* Check if Solaris filesystem supports POSIX.1e ACLs */
 419         aclp = sunacl_get(GETACL, &aclcnt, fd, NULL);
 420         if (aclp == 0)
 421                 close(fd);
 422         if (errno == ENOSYS || errno == ENOTSUP) {
 423                 skipping("POSIX.1e ACLs are not supported on this filesystem");
 424                 return;
 425         }
 426         failure("facl(): errno = %d (%s)", errno, strerror(errno));
 427         assert(aclp != NULL);
 428
 429         func = "facl()";
 430         n = facl(fd, SETACL, (int)(sizeof(aclp1)/sizeof(aclp1[0])), aclp1);
 431 #else
 432         func = "acl_set_fd()";
 433         n = acl_set_fd(fd, acl1);
 434 #endif
 435 #if !ARCHIVE_ACL_SUNOS
 436         acl_free(acl1);
 437 #endif
 438
 439         if (n != 0) {
 440 #if ARCHIVE_ACL_SUNOS
 441                 if (errno == ENOSYS || errno == ENOTSUP)
 442 #else
 443                 if (errno == EOPNOTSUPP || errno == EINVAL)
 444 #endif
 445                 {
 446                         close(fd);
 447                         skipping("POSIX.1e ACLs are not supported on this filesystem");
 448                         return;
 449                 }
 450         }
 451         failure("%s: errno = %d (%s)", func, errno, strerror(errno));
 452         assertEqualInt(0, n);
 453
 454         close(fd);
 455
 456         assertMakeDir("d", 0700);
 457
 458         /*
 459          * Create file d/f1 with acl2
 460          *
 461          * This differs from acl1 in the u:1: and g:15: permissions.
 462          *
 463          * This file deliberately has the same name but a different ACL.
 464          * Github Issue #777 explains how libarchive's directory traversal
 465          * did not always correctly enter directories before attempting
 466          * to read ACLs, resulting in reading the ACL from a like-named
 467          * file in the wrong directory.
 468          */
 469 #if ARCHIVE_ACL_SUNOS
 470         acl2_text = "user::rwx,"
 471             "group::rwx,"
 472             "other:---,"
 473             "user:1:r--,"
 474             "group:15:r--,"
 475             "mask:rwx";
 476         aclent_t aclp2[] = {
 477             { USER_OBJ, -1, 4 | 2 | 1 },
 478             { USER, 1, 4 },
 479             { GROUP_OBJ, -1, 4 | 2 | 1},
 480             { GROUP, 15, 4 },
 481             { CLASS_OBJ, -1, 4 | 2 | 1},
 482             { OTHER_OBJ, -1, 0 }
 483         };
 484 #else
 485         acl2_text = "user::rwx\n"
 486             "group::rwx\n"
 487             "other::---\n"
 488             "user:1:r--\n"
 489             "group:15:r--\n"
 490             "mask::rwx";
 491         acl2 = acl_from_text(acl2_text);
 492         failure("acl_from_text(): errno = %d (%s)", errno, strerror(errno));
 493         assert((void *)acl2 != NULL);
 494 #endif
 495         fd = open("d/f1", O_WRONLY | O_CREAT | O_EXCL, 0777);
 496         failure("Could not create test file?!");
 497         if (!assert(fd >= 0)) {
 498 #if !ARCHIVE_ACL_SUNOS
 499                 acl_free(acl2);
 500 #endif
 501                 return;
 502         }
 503 #if ARCHIVE_ACL_SUNOS
 504         func = "facl()";
 505         n = facl(fd, SETACL, (int)(sizeof(aclp2) / sizeof(aclp2[0])), aclp2);
 506 #else
 507         func = "acl_set_fd()";
 508         n = acl_set_fd(fd, acl2);
 509         acl_free(acl2);
 510 #endif
 511         if (n != 0)
 512                 close(fd);
 513         failure("%s: errno = %d (%s)", func, errno, strerror(errno));
 514         assertEqualInt(0, n);
 515         close(fd);
 516
 517         /* Create nested directory d2 with default ACLs */
 518         assertMakeDir("d/d2", 0755);
 519
 520 #if ARCHIVE_ACL_SUNOS
 521         acl3_text = "user::rwx,"
 522             "group::r-x,"
 523             "other:r-x,"
 524             "user:2:r--,"
 525             "group:16:-w-,"
 526             "mask:rwx,"
 527             "default:user::rwx,"
 528             "default:user:1:r--,"
 529             "default:group::r-x,"
 530             "default:group:15:r--,"
 531             "default:mask:rwx,"
 532             "default:other:r-x";
 533         aclent_t aclp3[] = {
 534             { USER_OBJ, -1, 4 | 2 | 1 },
 535             { USER, 2, 4 },
 536             { GROUP_OBJ, -1, 4 | 1 },
 537             { GROUP, 16, 2 },
 538             { CLASS_OBJ, -1, 4 | 2 | 1 },
 539             { OTHER_OBJ, -1, 4 | 1 },
 540             { USER_OBJ | ACL_DEFAULT, -1, 4 | 2 | 1 },
 541             { USER | ACL_DEFAULT, 1, 4 },
 542             { GROUP_OBJ | ACL_DEFAULT, -1, 4 | 1 },
 543             { GROUP | ACL_DEFAULT, 15, 4 },
 544             { CLASS_OBJ | ACL_DEFAULT, -1, 4 | 2 | 1},
 545             { OTHER_OBJ | ACL_DEFAULT, -1, 4 | 1 }
 546         };
 547 #else
 548         acl3_text = "user::rwx\n"
 549             "user:1:r--\n"
 550             "group::r-x\n"
 551             "group:15:r--\n"
 552             "mask::rwx\n"
 553             "other::r-x";
 554         acl3 = acl_from_text(acl3_text);
 555         failure("acl_from_text(): errno = %d (%s)", errno, strerror(errno));
 556         assert((void *)acl3 != NULL);
 557 #endif
 558
 559 #if ARCHIVE_ACL_SUNOS
 560         func = "acl()";
 561         n = acl("d/d2", SETACL, (int)(sizeof(aclp3) / sizeof(aclp3[0])), aclp3);
 562 #else
 563         func = "acl_set_file()";
 564         n = acl_set_file("d/d2", ACL_TYPE_DEFAULT, acl3);
 565         acl_free(acl3);
 566 #endif
 567         failure("%s: errno = %d (%s)", func, errno, strerror(errno));
 568         assertEqualInt(0, n);
 569
 570         /* Create a read-from-disk object. */
 571         assert(NULL != (a = archive_read_disk_new()));
 572         assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "."));
 573         assert(NULL != (ae = archive_entry_new()));
 574
 575 #if ARCHIVE_ACL_SUNOS
 576         flags = ARCHIVE_ENTRY_ACL_TYPE_POSIX1E
 577             | ARCHIVE_ENTRY_ACL_STYLE_SEPARATOR_COMMA
 578             | ARCHIVE_ENTRY_ACL_STYLE_SOLARIS;
 579         dflags = flags;
 580 #else
 581         flags = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
 582         dflags = ARCHIVE_ENTRY_ACL_TYPE_DEFAULT;
 583 #endif
 584
 585         /* Walk the dir until we see both of the files */
 586         while (ARCHIVE_OK == archive_read_next_header2(a, ae)) {
 587                 archive_read_disk_descend(a);
 588                 if (strcmp(archive_entry_pathname(ae), "./f1") == 0) {
 589                         acl_text = archive_entry_acl_to_text(ae, NULL, flags);
 590                         assertEqualString(acl_text, acl1_text);
 591                         free(acl_text);
 592                 } else if (strcmp(archive_entry_pathname(ae), "./d/f1") == 0) {
 593                         acl_text = archive_entry_acl_to_text(ae, NULL, flags);
 594                         assertEqualString(acl_text, acl2_text);
 595                         free(acl_text);
 596                 } else if (strcmp(archive_entry_pathname(ae), "./d/d2") == 0) {
 597                         acl_text = archive_entry_acl_to_text(ae, NULL, dflags);
 598                         assertEqualString(acl_text, acl3_text);
 599                         free(acl_text);
 600                 }
 601         }
 602
 603         archive_entry_free(ae);
 604         assertEqualInt(ARCHIVE_OK, archive_free(a));
 605 #endif /* ARCHIVE_ACL_POSIX1E */
 606 }