contrib/libarchive/libarchive/test/test_acl_platform_nfs4.c

   1 /*-
   2  * Copyright (c) 2003-2010 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$");
  28
  29 #if ARCHIVE_ACL_NFS4
  30 #if HAVE_SYS_ACL_H
  31 #define _ACL_PRIVATE
  32 #include <sys/acl.h>
  33 #endif
  34 #if HAVE_SYS_RICHACL_H
  35 #include <sys/richacl.h>
  36 #endif
  37 #if HAVE_MEMBERSHIP_H
  38 #include <membership.h>
  39 #endif
  40
  41 struct myacl_t {
  42         int type;
  43         int permset;
  44         int tag;
  45         int qual; /* GID or UID of user/group, depending on tag. */
  46         const char *name; /* Name of user/group, depending on tag. */
  47 };
  48
  49 static struct myacl_t acls_reg[] = {
  50 #if !ARCHIVE_ACL_DARWIN
  51         /* For this test, we need the file owner to be able to read and write the ACL. */
  52         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
  53           ARCHIVE_ENTRY_ACL_READ_DATA | ARCHIVE_ENTRY_ACL_READ_ACL | ARCHIVE_ENTRY_ACL_WRITE_ACL | ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS | ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES,
  54           ARCHIVE_ENTRY_ACL_USER_OBJ, -1, ""},
  55 #endif
  56         /* An entry for each type. */
  57         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_EXECUTE,
  58           ARCHIVE_ENTRY_ACL_USER, 108, "user108" },
  59         { ARCHIVE_ENTRY_ACL_TYPE_DENY, ARCHIVE_ENTRY_ACL_EXECUTE,
  60           ARCHIVE_ENTRY_ACL_USER, 109, "user109" },
  61
  62         /* An entry for each permission. */
  63         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_EXECUTE,
  64           ARCHIVE_ENTRY_ACL_USER, 112, "user112" },
  65         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_READ_DATA,
  66           ARCHIVE_ENTRY_ACL_USER, 113, "user113" },
  67         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_WRITE_DATA,
  68           ARCHIVE_ENTRY_ACL_USER, 115, "user115" },
  69         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_APPEND_DATA,
  70           ARCHIVE_ENTRY_ACL_USER, 117, "user117" },
  71         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS,
  72           ARCHIVE_ENTRY_ACL_USER, 119, "user119" },
  73         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS,
  74           ARCHIVE_ENTRY_ACL_USER, 120, "user120" },
  75         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES,
  76           ARCHIVE_ENTRY_ACL_USER, 122, "user122" },
  77         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES,
  78           ARCHIVE_ENTRY_ACL_USER, 123, "user123" },
  79         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_DELETE,
  80           ARCHIVE_ENTRY_ACL_USER, 124, "user124" },
  81         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_READ_ACL,
  82           ARCHIVE_ENTRY_ACL_USER, 125, "user125" },
  83         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_WRITE_ACL,
  84           ARCHIVE_ENTRY_ACL_USER, 126, "user126" },
  85         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_WRITE_OWNER,
  86           ARCHIVE_ENTRY_ACL_USER, 127, "user127" },
  87         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
  88           ARCHIVE_ENTRY_ACL_USER, 128, "user128" },
  89
  90         /* One entry for each qualifier. */
  91         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_EXECUTE,
  92           ARCHIVE_ENTRY_ACL_USER, 135, "user135" },
  93 //      { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_EXECUTE,
  94 //        ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },
  95         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_EXECUTE,
  96           ARCHIVE_ENTRY_ACL_GROUP, 136, "group136" },
  97 #if !ARCHIVE_ACL_DARWIN
  98         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_EXECUTE,
  99           ARCHIVE_ENTRY_ACL_GROUP_OBJ, -1, "" },
 100         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_EXECUTE,
 101           ARCHIVE_ENTRY_ACL_EVERYONE, -1, "" }
 102 #else   /* MacOS - mode 0654 */
 103         { ARCHIVE_ENTRY_ACL_TYPE_DENY, ARCHIVE_ENTRY_ACL_EXECUTE,
 104           ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },
 105         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 106             ARCHIVE_ENTRY_ACL_READ_DATA |
 107             ARCHIVE_ENTRY_ACL_WRITE_DATA |
 108             ARCHIVE_ENTRY_ACL_APPEND_DATA |
 109             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
 110             ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES |
 111             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
 112             ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS |
 113             ARCHIVE_ENTRY_ACL_READ_ACL |
 114             ARCHIVE_ENTRY_ACL_WRITE_ACL |
 115             ARCHIVE_ENTRY_ACL_WRITE_OWNER |
 116             ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
 117           ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },
 118         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 119             ARCHIVE_ENTRY_ACL_READ_DATA |
 120             ARCHIVE_ENTRY_ACL_EXECUTE |
 121             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
 122             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
 123             ARCHIVE_ENTRY_ACL_READ_ACL |
 124             ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
 125           ARCHIVE_ENTRY_ACL_GROUP_OBJ, -1, "" },
 126         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 127             ARCHIVE_ENTRY_ACL_READ_DATA |
 128             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
 129             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
 130             ARCHIVE_ENTRY_ACL_READ_ACL |
 131             ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
 132           ARCHIVE_ENTRY_ACL_EVERYONE, -1, "" }
 133 #endif
 134 };
 135
 136 static const int acls_reg_cnt = (int)(sizeof(acls_reg)/sizeof(acls_reg[0]));
 137
 138 static struct myacl_t acls_dir[] = {
 139         /* For this test, we need to be able to read and write the ACL. */
 140 #if !ARCHIVE_ACL_DARWIN
 141         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_READ_DATA | ARCHIVE_ENTRY_ACL_READ_ACL,
 142           ARCHIVE_ENTRY_ACL_USER_OBJ, -1, ""},
 143 #endif
 144
 145         /* An entry for each type. */
 146         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_LIST_DIRECTORY,
 147           ARCHIVE_ENTRY_ACL_USER, 101, "user101" },
 148         { ARCHIVE_ENTRY_ACL_TYPE_DENY, ARCHIVE_ENTRY_ACL_LIST_DIRECTORY,
 149           ARCHIVE_ENTRY_ACL_USER, 102, "user102" },
 150
 151         /* An entry for each permission. */
 152         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_LIST_DIRECTORY,
 153           ARCHIVE_ENTRY_ACL_USER, 201, "user201" },
 154         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_ADD_FILE,
 155           ARCHIVE_ENTRY_ACL_USER, 202, "user202" },
 156         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_ADD_SUBDIRECTORY,
 157           ARCHIVE_ENTRY_ACL_USER, 203, "user203" },
 158         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS,
 159           ARCHIVE_ENTRY_ACL_USER, 204, "user204" },
 160         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS,
 161           ARCHIVE_ENTRY_ACL_USER, 205, "user205" },
 162         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_DELETE_CHILD,
 163           ARCHIVE_ENTRY_ACL_USER, 206, "user206" },
 164         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES,
 165           ARCHIVE_ENTRY_ACL_USER, 207, "user207" },
 166         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES,
 167           ARCHIVE_ENTRY_ACL_USER, 208, "user208" },
 168         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_DELETE,
 169           ARCHIVE_ENTRY_ACL_USER, 209, "user209" },
 170         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_READ_ACL,
 171           ARCHIVE_ENTRY_ACL_USER, 210, "user210" },
 172         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_WRITE_ACL,
 173           ARCHIVE_ENTRY_ACL_USER, 211, "user211" },
 174         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_WRITE_OWNER,
 175           ARCHIVE_ENTRY_ACL_USER, 212, "user212" },
 176         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
 177           ARCHIVE_ENTRY_ACL_USER, 213, "user213" },
 178
 179         /* One entry with each inheritance value. */
 180         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 181           ARCHIVE_ENTRY_ACL_READ_DATA | ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT,
 182           ARCHIVE_ENTRY_ACL_USER, 301, "user301" },
 183         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 184           ARCHIVE_ENTRY_ACL_READ_DATA | ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT,
 185           ARCHIVE_ENTRY_ACL_USER, 302, "user302" },
 186         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 187           ARCHIVE_ENTRY_ACL_READ_DATA |
 188           ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT |
 189           ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT,
 190           ARCHIVE_ENTRY_ACL_USER, 303, "user303" },
 191         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 192           ARCHIVE_ENTRY_ACL_READ_DATA |
 193           ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT |
 194           ARCHIVE_ENTRY_ACL_ENTRY_INHERIT_ONLY,
 195           ARCHIVE_ENTRY_ACL_USER, 304, "user304" },
 196 #if !defined(ARCHIVE_ACL_SUNOS_NFS4) || defined(ACE_INHERITED_ACE)
 197         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 198           ARCHIVE_ENTRY_ACL_READ_DATA | ARCHIVE_ENTRY_ACL_ENTRY_INHERITED,
 199           ARCHIVE_ENTRY_ACL_USER, 305, "user305" },
 200 #endif
 201
 202 #if 0
 203         /* FreeBSD does not support audit entries. */
 204         { ARCHIVE_ENTRY_ACL_TYPE_AUDIT,
 205           ARCHIVE_ENTRY_ACL_READ_DATA | ARCHIVE_ENTRY_ACL_ENTRY_SUCCESSFUL_ACCESS,
 206           ARCHIVE_ENTRY_ACL_USER, 401, "user401" },
 207         { ARCHIVE_ENTRY_ACL_TYPE_AUDIT,
 208           ARCHIVE_ENTRY_ACL_READ_DATA | ARCHIVE_ENTRY_ACL_ENTRY_FAILED_ACCESS,
 209           ARCHIVE_ENTRY_ACL_USER, 402, "user402" },
 210 #endif
 211
 212         /* One entry for each qualifier. */
 213         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_LIST_DIRECTORY,
 214           ARCHIVE_ENTRY_ACL_USER, 501, "user501" },
 215         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_LIST_DIRECTORY,
 216           ARCHIVE_ENTRY_ACL_GROUP, 502, "group502" },
 217 #if !ARCHIVE_ACL_DARWIN
 218         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_LIST_DIRECTORY,
 219           ARCHIVE_ENTRY_ACL_GROUP_OBJ, -1, "" },
 220         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_LIST_DIRECTORY,
 221           ARCHIVE_ENTRY_ACL_EVERYONE, -1, "" }
 222 #else   /* MacOS - mode 0654 */
 223         { ARCHIVE_ENTRY_ACL_TYPE_DENY, ARCHIVE_ENTRY_ACL_EXECUTE,
 224           ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },
 225         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 226             ARCHIVE_ENTRY_ACL_READ_DATA |
 227             ARCHIVE_ENTRY_ACL_WRITE_DATA |
 228             ARCHIVE_ENTRY_ACL_APPEND_DATA |
 229             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
 230             ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES |
 231             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
 232             ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS |
 233             ARCHIVE_ENTRY_ACL_READ_ACL |
 234             ARCHIVE_ENTRY_ACL_WRITE_ACL |
 235             ARCHIVE_ENTRY_ACL_WRITE_OWNER |
 236             ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
 237           ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },
 238         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 239             ARCHIVE_ENTRY_ACL_READ_DATA |
 240             ARCHIVE_ENTRY_ACL_EXECUTE |
 241             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
 242             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
 243             ARCHIVE_ENTRY_ACL_READ_ACL |
 244             ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
 245           ARCHIVE_ENTRY_ACL_GROUP_OBJ, -1, "" },
 246         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
 247             ARCHIVE_ENTRY_ACL_READ_DATA |
 248             ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
 249             ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
 250             ARCHIVE_ENTRY_ACL_READ_ACL |
 251             ARCHIVE_ENTRY_ACL_SYNCHRONIZE,
 252           ARCHIVE_ENTRY_ACL_EVERYONE, -1, "" }
 253 #endif
 254 };
 255
 256 static const int acls_dir_cnt = (int)(sizeof(acls_dir)/sizeof(acls_dir[0]));
 257
 258 static void
 259 set_acls(struct archive_entry *ae, struct myacl_t *acls, int start, int end)
 260 {
 261         int i;
 262
 263         archive_entry_acl_clear(ae);
 264 #if !ARCHIVE_ACL_DARWIN
 265         if (start > 0) {
 266                 assertEqualInt(ARCHIVE_OK,
 267                         archive_entry_acl_add_entry(ae,
 268                             acls[0].type, acls[0].permset, acls[0].tag,
 269                             acls[0].qual, acls[0].name));
 270         }
 271 #endif
 272         for (i = start; i < end; i++) {
 273                 assertEqualInt(ARCHIVE_OK,
 274                     archive_entry_acl_add_entry(ae,
 275                         acls[i].type, acls[i].permset, acls[i].tag,
 276                         acls[i].qual, acls[i].name));
 277         }
 278 }
 279
 280 static int
 281 #if ARCHIVE_ACL_SUNOS_NFS4
 282 acl_permset_to_bitmap(uint32_t mask)
 283 #elif ARCHIVE_ACL_LIBRICHACL
 284 acl_permset_to_bitmap(unsigned int mask)
 285 #else
 286 acl_permset_to_bitmap(acl_permset_t opaque_ps)
 287 #endif
 288 {
 289         static struct { int portable; int machine; } perms[] = {
 290 #ifdef ARCHIVE_ACL_SUNOS_NFS4   /* Solaris NFSv4 ACL permissions */
 291                 {ARCHIVE_ENTRY_ACL_EXECUTE, ACE_EXECUTE},
 292                 {ARCHIVE_ENTRY_ACL_READ_DATA, ACE_READ_DATA},
 293                 {ARCHIVE_ENTRY_ACL_LIST_DIRECTORY, ACE_LIST_DIRECTORY},
 294                 {ARCHIVE_ENTRY_ACL_WRITE_DATA, ACE_WRITE_DATA},
 295                 {ARCHIVE_ENTRY_ACL_ADD_FILE, ACE_ADD_FILE},
 296                 {ARCHIVE_ENTRY_ACL_APPEND_DATA, ACE_APPEND_DATA},
 297                 {ARCHIVE_ENTRY_ACL_ADD_SUBDIRECTORY, ACE_ADD_SUBDIRECTORY},
 298                 {ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS, ACE_READ_NAMED_ATTRS},
 299                 {ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS, ACE_WRITE_NAMED_ATTRS},
 300                 {ARCHIVE_ENTRY_ACL_DELETE_CHILD, ACE_DELETE_CHILD},
 301                 {ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES, ACE_READ_ATTRIBUTES},
 302                 {ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES, ACE_WRITE_ATTRIBUTES},
 303                 {ARCHIVE_ENTRY_ACL_DELETE, ACE_DELETE},
 304                 {ARCHIVE_ENTRY_ACL_READ_ACL, ACE_READ_ACL},
 305                 {ARCHIVE_ENTRY_ACL_WRITE_ACL, ACE_WRITE_ACL},
 306                 {ARCHIVE_ENTRY_ACL_WRITE_OWNER, ACE_WRITE_OWNER},
 307                 {ARCHIVE_ENTRY_ACL_SYNCHRONIZE, ACE_SYNCHRONIZE}
 308 #elif ARCHIVE_ACL_DARWIN        /* MacOS NFSv4 ACL permissions */
 309                 {ARCHIVE_ENTRY_ACL_READ_DATA, ACL_READ_DATA},
 310                 {ARCHIVE_ENTRY_ACL_LIST_DIRECTORY, ACL_LIST_DIRECTORY},
 311                 {ARCHIVE_ENTRY_ACL_WRITE_DATA, ACL_WRITE_DATA},
 312                 {ARCHIVE_ENTRY_ACL_ADD_FILE, ACL_ADD_FILE},
 313                 {ARCHIVE_ENTRY_ACL_EXECUTE, ACL_EXECUTE},
 314                 {ARCHIVE_ENTRY_ACL_DELETE, ACL_DELETE},
 315                 {ARCHIVE_ENTRY_ACL_APPEND_DATA, ACL_APPEND_DATA},
 316                 {ARCHIVE_ENTRY_ACL_ADD_SUBDIRECTORY, ACL_ADD_SUBDIRECTORY},
 317                 {ARCHIVE_ENTRY_ACL_DELETE_CHILD, ACL_DELETE_CHILD},
 318                 {ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES, ACL_READ_ATTRIBUTES},
 319                 {ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES, ACL_WRITE_ATTRIBUTES},
 320                 {ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS, ACL_READ_EXTATTRIBUTES},
 321                 {ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS, ACL_WRITE_EXTATTRIBUTES},
 322                 {ARCHIVE_ENTRY_ACL_READ_ACL, ACL_READ_SECURITY},
 323                 {ARCHIVE_ENTRY_ACL_WRITE_ACL, ACL_WRITE_SECURITY},
 324                 {ARCHIVE_ENTRY_ACL_WRITE_OWNER, ACL_CHANGE_OWNER},
 325 #if HAVE_DECL_ACL_SYNCHRONIZE
 326                 {ARCHIVE_ENTRY_ACL_SYNCHRONIZE, ACL_SYNCHRONIZE}
 327 #endif
 328 #elif ARCHIVE_ACL_LIBRICHACL
 329                 {ARCHIVE_ENTRY_ACL_EXECUTE, RICHACE_EXECUTE},
 330                 {ARCHIVE_ENTRY_ACL_READ_DATA, RICHACE_READ_DATA},
 331                 {ARCHIVE_ENTRY_ACL_LIST_DIRECTORY, RICHACE_LIST_DIRECTORY},
 332                 {ARCHIVE_ENTRY_ACL_WRITE_DATA, RICHACE_WRITE_DATA},
 333                 {ARCHIVE_ENTRY_ACL_ADD_FILE, RICHACE_ADD_FILE},
 334                 {ARCHIVE_ENTRY_ACL_APPEND_DATA, RICHACE_APPEND_DATA},
 335                 {ARCHIVE_ENTRY_ACL_ADD_SUBDIRECTORY, RICHACE_ADD_SUBDIRECTORY},
 336                 {ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS, RICHACE_READ_NAMED_ATTRS},
 337                 {ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS, RICHACE_WRITE_NAMED_ATTRS},
 338                 {ARCHIVE_ENTRY_ACL_DELETE_CHILD, RICHACE_DELETE_CHILD},
 339                 {ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES, RICHACE_READ_ATTRIBUTES},
 340                 {ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES, RICHACE_WRITE_ATTRIBUTES},
 341                 {ARCHIVE_ENTRY_ACL_DELETE, RICHACE_DELETE},
 342                 {ARCHIVE_ENTRY_ACL_READ_ACL, RICHACE_READ_ACL},
 343                 {ARCHIVE_ENTRY_ACL_WRITE_ACL, RICHACE_WRITE_ACL},
 344                 {ARCHIVE_ENTRY_ACL_WRITE_OWNER, RICHACE_WRITE_OWNER},
 345                 {ARCHIVE_ENTRY_ACL_SYNCHRONIZE, RICHACE_SYNCHRONIZE}
 346 #else   /* FreeBSD NFSv4 ACL permissions */
 347                 {ARCHIVE_ENTRY_ACL_EXECUTE, ACL_EXECUTE},
 348                 {ARCHIVE_ENTRY_ACL_READ_DATA, ACL_READ_DATA},
 349                 {ARCHIVE_ENTRY_ACL_LIST_DIRECTORY, ACL_LIST_DIRECTORY},
 350                 {ARCHIVE_ENTRY_ACL_WRITE_DATA, ACL_WRITE_DATA},
 351                 {ARCHIVE_ENTRY_ACL_ADD_FILE, ACL_ADD_FILE},
 352                 {ARCHIVE_ENTRY_ACL_APPEND_DATA, ACL_APPEND_DATA},
 353                 {ARCHIVE_ENTRY_ACL_ADD_SUBDIRECTORY, ACL_ADD_SUBDIRECTORY},
 354                 {ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS, ACL_READ_NAMED_ATTRS},
 355                 {ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS, ACL_WRITE_NAMED_ATTRS},
 356                 {ARCHIVE_ENTRY_ACL_DELETE_CHILD, ACL_DELETE_CHILD},
 357                 {ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES, ACL_READ_ATTRIBUTES},
 358                 {ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES, ACL_WRITE_ATTRIBUTES},
 359                 {ARCHIVE_ENTRY_ACL_DELETE, ACL_DELETE},
 360                 {ARCHIVE_ENTRY_ACL_READ_ACL, ACL_READ_ACL},
 361                 {ARCHIVE_ENTRY_ACL_WRITE_ACL, ACL_WRITE_ACL},
 362                 {ARCHIVE_ENTRY_ACL_WRITE_OWNER, ACL_WRITE_OWNER},
 363                 {ARCHIVE_ENTRY_ACL_SYNCHRONIZE, ACL_SYNCHRONIZE}
 364 #endif
 365         };
 366         int i, permset = 0;
 367
 368         for (i = 0; i < (int)(sizeof(perms)/sizeof(perms[0])); ++i)
 369 #if ARCHIVE_ACL_SUNOS_NFS4 || ARCHIVE_ACL_LIBRICHACL
 370                 if (mask & perms[i].machine)
 371 #else
 372                 if (acl_get_perm_np(opaque_ps, perms[i].machine))
 373 #endif
 374                         permset |= perms[i].portable;
 375         return permset;
 376 }
 377
 378 static int
 379 #if ARCHIVE_ACL_SUNOS_NFS4
 380 acl_flagset_to_bitmap(uint16_t flags)
 381 #elif ARCHIVE_ACL_LIBRICHACL
 382 acl_flagset_to_bitmap(int flags)
 383 #else
 384 acl_flagset_to_bitmap(acl_flagset_t opaque_fs)
 385 #endif
 386 {
 387         static struct { int portable; int machine; } perms[] = {
 388 #if ARCHIVE_ACL_SUNOS_NFS4      /* Solaris NFSv4 ACL inheritance flags */
 389                 {ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT, ACE_FILE_INHERIT_ACE},
 390                 {ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT, ACE_DIRECTORY_INHERIT_ACE},
 391                 {ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT, ACE_NO_PROPAGATE_INHERIT_ACE},
 392                 {ARCHIVE_ENTRY_ACL_ENTRY_INHERIT_ONLY, ACE_INHERIT_ONLY_ACE},
 393                 {ARCHIVE_ENTRY_ACL_ENTRY_SUCCESSFUL_ACCESS, ACE_SUCCESSFUL_ACCESS_ACE_FLAG},
 394                 {ARCHIVE_ENTRY_ACL_ENTRY_FAILED_ACCESS, ACE_FAILED_ACCESS_ACE_FLAG},
 395 #ifdef ACE_INHERITED_ACE
 396                 {ARCHIVE_ENTRY_ACL_ENTRY_INHERITED, ACE_INHERITED_ACE}
 397 #endif
 398 #elif ARCHIVE_ACL_DARWIN        /* MacOS NFSv4 ACL inheritance flags */
 399                 {ARCHIVE_ENTRY_ACL_ENTRY_INHERITED, ACL_ENTRY_INHERITED},
 400                 {ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT, ACL_ENTRY_FILE_INHERIT},
 401                 {ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT, ACL_ENTRY_DIRECTORY_INHERIT},
 402                 {ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT, ACL_ENTRY_LIMIT_INHERIT},
 403                 {ARCHIVE_ENTRY_ACL_ENTRY_INHERIT_ONLY, ACL_ENTRY_ONLY_INHERIT}
 404 #elif ARCHIVE_ACL_LIBRICHACL
 405                 {ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT, RICHACE_FILE_INHERIT_ACE},
 406                 {ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT, RICHACE_DIRECTORY_INHERIT_ACE},
 407                 {ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT, RICHACE_NO_PROPAGATE_INHERIT_ACE},
 408                 {ARCHIVE_ENTRY_ACL_ENTRY_INHERIT_ONLY, RICHACE_INHERIT_ONLY_ACE},
 409                 {ARCHIVE_ENTRY_ACL_ENTRY_INHERITED, RICHACE_INHERITED_ACE}
 410 #else   /* FreeBSD NFSv4 ACL inheritance flags */
 411                 {ARCHIVE_ENTRY_ACL_ENTRY_INHERITED, ACL_ENTRY_INHERITED},
 412                 {ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT, ACL_ENTRY_FILE_INHERIT},
 413                 {ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT, ACL_ENTRY_DIRECTORY_INHERIT},
 414                 {ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT, ACL_ENTRY_NO_PROPAGATE_INHERIT},
 415                 {ARCHIVE_ENTRY_ACL_ENTRY_SUCCESSFUL_ACCESS, ACL_ENTRY_SUCCESSFUL_ACCESS},
 416                 {ARCHIVE_ENTRY_ACL_ENTRY_FAILED_ACCESS, ACL_ENTRY_FAILED_ACCESS},
 417                 {ARCHIVE_ENTRY_ACL_ENTRY_INHERIT_ONLY, ACL_ENTRY_INHERIT_ONLY}
 418 #endif
 419         };
 420         int i, flagset = 0;
 421
 422         for (i = 0; i < (int)(sizeof(perms)/sizeof(perms[0])); ++i)
 423 #if ARCHIVE_ACL_SUNOS_NFS4 || ARCHIVE_ACL_LIBRICHACL
 424                 if (flags & perms[i].machine)
 425 #else
 426                 if (acl_get_flag_np(opaque_fs, perms[i].machine))
 427 #endif
 428                         flagset |= perms[i].portable;
 429         return flagset;
 430 }
 431
 432 #if ARCHIVE_ACL_SUNOS_NFS4
 433 static int
 434 acl_match(ace_t *ace, struct myacl_t *myacl)
 435 {
 436         int perms;
 437
 438         perms = acl_permset_to_bitmap(ace->a_access_mask) | acl_flagset_to_bitmap(ace->a_flags);
 439
 440         if (perms != myacl->permset)
 441                 return (0);
 442
 443         switch (ace->a_type) {
 444         case ACE_ACCESS_ALLOWED_ACE_TYPE:
 445                 if (myacl->type != ARCHIVE_ENTRY_ACL_TYPE_ALLOW)
 446                         return (0);
 447                 break;
 448         case ACE_ACCESS_DENIED_ACE_TYPE:
 449                 if (myacl->type != ARCHIVE_ENTRY_ACL_TYPE_DENY)
 450                         return (0);
 451                 break;
 452         case ACE_SYSTEM_AUDIT_ACE_TYPE:
 453                 if (myacl->type != ARCHIVE_ENTRY_ACL_TYPE_AUDIT)
 454                         return (0);
 455                 break;
 456         case ACE_SYSTEM_ALARM_ACE_TYPE:
 457                 if (myacl->type != ARCHIVE_ENTRY_ACL_TYPE_ALARM)
 458                         return (0);
 459                 break;
 460         default:
 461                 return (0);
 462         }
 463
 464         if (ace->a_flags & ACE_OWNER) {
 465                 if (myacl->tag != ARCHIVE_ENTRY_ACL_USER_OBJ)
 466                         return (0);
 467         } else if (ace->a_flags & ACE_GROUP) {
 468                 if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP_OBJ)
 469                         return (0);
 470         } else if (ace->a_flags & ACE_EVERYONE) {
 471                 if (myacl->tag != ARCHIVE_ENTRY_ACL_EVERYONE)
 472                         return (0);
 473         } else if (ace->a_flags & ACE_IDENTIFIER_GROUP) {
 474                 if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP)
 475                         return (0);
 476                 if ((gid_t)myacl->qual != ace->a_who)
 477                         return (0);
 478         } else {
 479                 if (myacl->tag != ARCHIVE_ENTRY_ACL_USER)
 480                         return (0);
 481                 if ((uid_t)myacl->qual != ace->a_who)
 482                         return (0);
 483         }
 484         return (1);
 485 }
 486 #elif ARCHIVE_ACL_LIBRICHACL
 487 static int
 488 acl_match(struct richace *richace, struct myacl_t *myacl)
 489 {
 490         int perms;
 491
 492         perms = acl_permset_to_bitmap(richace->e_mask) |
 493             acl_flagset_to_bitmap(richace->e_flags);
 494
 495         if (perms != myacl->permset)
 496                 return (0);
 497
 498         switch (richace->e_type) {
 499         case RICHACE_ACCESS_ALLOWED_ACE_TYPE:
 500                 if (myacl->type != ARCHIVE_ENTRY_ACL_TYPE_ALLOW)
 501                         return (0);
 502                 break;
 503         case RICHACE_ACCESS_DENIED_ACE_TYPE:
 504                 if (myacl->type != ARCHIVE_ENTRY_ACL_TYPE_DENY)
 505                         return (0);
 506                 break;
 507         default:
 508                 return (0);
 509         }
 510
 511         if (richace->e_flags & RICHACE_SPECIAL_WHO) {
 512                 switch (richace->e_id) {
 513                 case RICHACE_OWNER_SPECIAL_ID:
 514                         if (myacl->tag != ARCHIVE_ENTRY_ACL_USER_OBJ)
 515                                 return (0);
 516                         break;
 517                 case RICHACE_GROUP_SPECIAL_ID:
 518                         if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP_OBJ)
 519                                 return (0);
 520                         break;
 521                 case RICHACE_EVERYONE_SPECIAL_ID:
 522                         if (myacl->tag != ARCHIVE_ENTRY_ACL_EVERYONE)
 523                                 return (0);
 524                         break;
 525                 default:
 526                         /* Invalid e_id */
 527                         return (0);
 528                 }
 529         } else if (richace->e_flags & RICHACE_IDENTIFIER_GROUP) {
 530                 if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP)
 531                         return (0);
 532                 if ((gid_t)myacl->qual != richace->e_id)
 533                         return (0);
 534         } else {
 535                 if (myacl->tag != ARCHIVE_ENTRY_ACL_USER)
 536                         return (0);
 537                 if ((uid_t)myacl->qual != richace->e_id)
 538                         return (0);
 539         }
 540         return (1);
 541 }
 542 #elif ARCHIVE_ACL_DARWIN
 543 static int
 544 acl_match(acl_entry_t aclent, struct myacl_t *myacl)
 545 {
 546         void *q;
 547         uid_t ugid;
 548         int r, idtype;
 549         acl_tag_t tag_type;
 550         acl_permset_t opaque_ps;
 551         acl_flagset_t opaque_fs;
 552         int perms;
 553
 554         acl_get_tag_type(aclent, &tag_type);
 555
 556         /* translate the silly opaque permset to a bitmap */
 557         acl_get_permset(aclent, &opaque_ps);
 558         acl_get_flagset_np(aclent, &opaque_fs);
 559         perms = acl_permset_to_bitmap(opaque_ps) | acl_flagset_to_bitmap(opaque_fs);
 560         if (perms != myacl->permset)
 561                 return (0);
 562
 563         r = 0;
 564         switch (tag_type) {
 565         case ACL_EXTENDED_ALLOW:
 566                 if (myacl->type != ARCHIVE_ENTRY_ACL_TYPE_ALLOW)
 567                         return (0);
 568                 break;
 569         case ACL_EXTENDED_DENY:
 570                 if (myacl->type != ARCHIVE_ENTRY_ACL_TYPE_DENY)
 571                         return (0);
 572                 break;
 573         default:
 574                 return (0);
 575         }
 576         q = acl_get_qualifier(aclent);
 577         if (q == NULL)
 578                 return (0);
 579         r = mbr_uuid_to_id((const unsigned char *)q, &ugid, &idtype);
 580         acl_free(q);
 581         if (r != 0)
 582                 return (0);
 583         switch (idtype) {
 584                 case ID_TYPE_UID:
 585                         if (myacl->tag != ARCHIVE_ENTRY_ACL_USER)
 586                                 return (0);
 587                         if ((uid_t)myacl->qual != ugid)
 588                                 return (0);
 589                         break;
 590                 case ID_TYPE_GID:
 591                         if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP)
 592                                 return (0);
 593                         if ((gid_t)myacl->qual != ugid)
 594                                 return (0);
 595                         break;
 596                 default:
 597                         return (0);
 598         }
 599         return (1);
 600 }
 601 #else /* ARCHIVE_ACL_FREEBSD_NFS4 */
 602 static int
 603 acl_match(acl_entry_t aclent, struct myacl_t *myacl)
 604 {
 605         gid_t g, *gp;
 606         uid_t u, *up;
 607         acl_entry_type_t entry_type;
 608         acl_tag_t tag_type;
 609         acl_permset_t opaque_ps;
 610         acl_flagset_t opaque_fs;
 611         int perms;
 612
 613         acl_get_tag_type(aclent, &tag_type);
 614         acl_get_entry_type_np(aclent, &entry_type);
 615
 616         /* translate the silly opaque permset to a bitmap */
 617         acl_get_permset(aclent, &opaque_ps);
 618         acl_get_flagset_np(aclent, &opaque_fs);
 619         perms = acl_permset_to_bitmap(opaque_ps) | acl_flagset_to_bitmap(opaque_fs);
 620         if (perms != myacl->permset)
 621                 return (0);
 622
 623         switch (entry_type) {
 624         case ACL_ENTRY_TYPE_ALLOW:
 625                 if (myacl->type != ARCHIVE_ENTRY_ACL_TYPE_ALLOW)
 626                         return (0);
 627                 break;
 628         case ACL_ENTRY_TYPE_DENY:
 629                 if (myacl->type != ARCHIVE_ENTRY_ACL_TYPE_DENY)
 630                         return (0);
 631                 break;
 632         case ACL_ENTRY_TYPE_AUDIT:
 633                 if (myacl->type != ARCHIVE_ENTRY_ACL_TYPE_AUDIT)
 634                         return (0);
 635         case ACL_ENTRY_TYPE_ALARM:
 636                 if (myacl->type != ARCHIVE_ENTRY_ACL_TYPE_ALARM)
 637                         return (0);
 638         default:
 639                 return (0);
 640         }
 641
 642         switch (tag_type) {
 643         case ACL_USER_OBJ:
 644                 if (myacl->tag != ARCHIVE_ENTRY_ACL_USER_OBJ) return (0);
 645                 break;
 646         case ACL_USER:
 647                 if (myacl->tag != ARCHIVE_ENTRY_ACL_USER)
 648                         return (0);
 649                 up = acl_get_qualifier(aclent);
 650                 u = *up;
 651                 acl_free(up);
 652                 if ((uid_t)myacl->qual != u)
 653                         return (0);
 654                 break;
 655         case ACL_GROUP_OBJ:
 656                 if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP_OBJ) return (0);
 657                 break;
 658         case ACL_GROUP:
 659                 if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP)
 660                         return (0);
 661                 gp = acl_get_qualifier(aclent);
 662                 g = *gp;
 663                 acl_free(gp);
 664                 if ((gid_t)myacl->qual != g)
 665                         return (0);
 666                 break;
 667         case ACL_MASK:
 668                 if (myacl->tag != ARCHIVE_ENTRY_ACL_MASK) return (0);
 669                 break;
 670         case ACL_EVERYONE:
 671                 if (myacl->tag != ARCHIVE_ENTRY_ACL_EVERYONE) return (0);
 672                 break;
 673         }
 674         return (1);
 675 }
 676 #endif  /* various ARCHIVE_ACL_NFS4 implementations */
 677
 678 static void
 679 compare_acls(
 680 #if ARCHIVE_ACL_SUNOS_NFS4
 681     void *aclp,
 682     int aclcnt,
 683 #elif ARCHIVE_ACL_LIBRICHACL
 684     struct richacl *richacl,
 685 #else
 686     acl_t acl,
 687 #endif
 688     struct myacl_t *myacls, const char *filename, int start, int end)
 689 {
 690         int *marker;
 691         int matched;
 692         int i, n;
 693 #if ARCHIVE_ACL_SUNOS_NFS4
 694         int e;
 695         ace_t *acl_entry;
 696 #elif ARCHIVE_ACL_LIBRICHACL
 697         int e;
 698         struct richace *acl_entry;
 699         int aclcnt;
 700 #else
 701         int entry_id = ACL_FIRST_ENTRY;
 702         acl_entry_t acl_entry;
 703 #if ARCHIVE_ACL_DARWIN
 704         const int acl_get_entry_ret = 0;
 705 #else
 706         const int acl_get_entry_ret = 1;
 707 #endif
 708 #endif
 709
 710 #if ARCHIVE_ACL_SUNOS_NFS4
 711         if (aclp == NULL)
 712                 return;
 713 #elif ARCHIVE_ACL_LIBRICHACL
 714         if (richacl == NULL)
 715                 return;
 716         aclcnt = richacl->a_count;
 717 #else
 718         if (acl == NULL)
 719                 return;
 720 #endif
 721
 722         n = end - start;
 723         marker = malloc(sizeof(marker[0]) * (n + 1));
 724         for (i = 0; i < n; i++)
 725                 marker[i] = i + start;
 726 #if !ARCHIVE_ACL_DARWIN
 727         /* Always include the first ACE. */
 728         if (start > 0) {
 729           marker[n] = 0;
 730           ++n;
 731         }
 732 #endif
 733
 734         /*
 735          * Iterate over acls in system acl object, try to match each
 736          * one with an item in the myacls array.
 737          */
 738 #if ARCHIVE_ACL_SUNOS_NFS4 || ARCHIVE_ACL_LIBRICHACL
 739         for (e = 0; e < aclcnt; e++)
 740 #else
 741         while (acl_get_entry_ret == acl_get_entry(acl, entry_id, &acl_entry))
 742 #endif
 743         {
 744 #if ARCHIVE_ACL_SUNOS_NFS4
 745                 acl_entry = &((ace_t *)aclp)[e];
 746 #elif ARCHIVE_ACL_LIBRICHACL
 747                 acl_entry = &(richacl->a_entries[e]);
 748 #else
 749                 /* After the first time... */
 750                 entry_id = ACL_NEXT_ENTRY;
 751 #endif
 752                 /* Search for a matching entry (tag and qualifier) */
 753                 for (i = 0, matched = 0; i < n && !matched; i++) {
 754                         if (acl_match(acl_entry, &myacls[marker[i]])) {
 755                                 /* We found a match; remove it. */
 756                                 marker[i] = marker[n - 1];
 757                                 n--;
 758                                 matched = 1;
 759                         }
 760                 }
 761
 762                 failure("ACL entry on file %s that shouldn't be there",
 763                     filename);
 764                 assert(matched == 1);
 765         }
 766
 767         /* Dump entries in the myacls array that weren't in the system acl. */
 768         for (i = 0; i < n; ++i) {
 769                 failure(" ACL entry %d missing from %s: "
 770                     "type=%#010x,permset=%#010x,tag=%d,qual=%d,name=``%s''\n",
 771                     marker[i], filename,
 772                     myacls[marker[i]].type, myacls[marker[i]].permset,
 773                     myacls[marker[i]].tag, myacls[marker[i]].qual,
 774                     myacls[marker[i]].name);
 775                 assert(0); /* Record this as a failure. */
 776         }
 777         free(marker);
 778 }
 779
 780 static void
 781 compare_entry_acls(struct archive_entry *ae, struct myacl_t *myacls, const char *filename, int start, int end)
 782 {
 783         int *marker;
 784         int matched;
 785         int i, n;
 786         int type, permset, tag, qual;
 787         const char *name;
 788
 789         /* Count ACL entries in myacls array and allocate an indirect array. */
 790         n = end - start;
 791         marker = malloc(sizeof(marker[0]) * (n + 1));
 792         for (i = 0; i < n; i++)
 793                 marker[i] = i + start;
 794         /* Always include the first ACE. */
 795         if (start > 0) {
 796           marker[n] = 0;
 797           ++n;
 798         }
 799
 800         /*
 801          * Iterate over acls in entry, try to match each
 802          * one with an item in the myacls array.
 803          */
 804         assertEqualInt(n, archive_entry_acl_reset(ae,
 805             ARCHIVE_ENTRY_ACL_TYPE_NFS4));
 806         while (ARCHIVE_OK == archive_entry_acl_next(ae,
 807             ARCHIVE_ENTRY_ACL_TYPE_NFS4, &type, &permset, &tag, &qual, &name)) {
 808
 809                 /* Search for a matching entry (tag and qualifier) */
 810                 for (i = 0, matched = 0; i < n && !matched; i++) {
 811                         if (tag == myacls[marker[i]].tag
 812                             && qual == myacls[marker[i]].qual
 813                             && permset == myacls[marker[i]].permset
 814                             && type == myacls[marker[i]].type) {
 815                                 /* We found a match; remove it. */
 816                                 marker[i] = marker[n - 1];
 817                                 n--;
 818                                 matched = 1;
 819                         }
 820                 }
 821
 822                 failure("ACL entry on file that shouldn't be there: "
 823                         "type=%#010x,permset=%#010x,tag=%d,qual=%d",
 824                         type,permset,tag,qual);
 825                 assert(matched == 1);
 826         }
 827
 828         /* Dump entries in the myacls array that weren't in the system acl. */
 829         for (i = 0; i < n; ++i) {
 830                 failure(" ACL entry %d missing from %s: "
 831                     "type=%#010x,permset=%#010x,tag=%d,qual=%d,name=``%s''\n",
 832                     marker[i], filename,
 833                     myacls[marker[i]].type, myacls[marker[i]].permset,
 834                     myacls[marker[i]].tag, myacls[marker[i]].qual,
 835                     myacls[marker[i]].name);
 836                 assert(0); /* Record this as a failure. */
 837         }
 838         free(marker);
 839 }
 840 #endif  /* ARCHIVE_ACL_NFS4 */
 841
 842 /*
 843  * Verify ACL restore-to-disk.  This test is Platform-specific.
 844  */
 845
 846 DEFINE_TEST(test_acl_platform_nfs4)
 847 {
 848 #if !ARCHIVE_ACL_NFS4
 849         skipping("NFS4 ACLs are not supported on this platform");
 850 #else /* ARCHIVE_ACL_NFS4 */
 851         char buff[64];
 852         int i;
 853         struct stat st;
 854         struct archive *a;
 855         struct archive_entry *ae;
 856 #if ARCHIVE_ACL_DARWIN /* On MacOS we skip trivial ACLs in some tests */
 857         const int regcnt = acls_reg_cnt - 4;
 858         const int dircnt = acls_dir_cnt - 4;
 859 #else
 860         const int regcnt = acls_reg_cnt;
 861         const int dircnt = acls_dir_cnt;
 862 #endif
 863 #if ARCHIVE_ACL_SUNOS_NFS4
 864         void *aclp;
 865         int aclcnt;
 866 #elif ARCHIVE_ACL_LIBRICHACL
 867         struct richacl *richacl;
 868 #else   /* !ARCHIVE_ACL_SUNOS_NFS4 */
 869         acl_t acl;
 870 #endif
 871
 872         assertMakeFile("pretest", 0644, "a");
 873
 874         if (setTestAcl("pretest") != ARCHIVE_TEST_ACL_TYPE_NFS4) {
 875                 skipping("NFS4 ACLs are not writable on this filesystem");
 876                 return;
 877         }
 878
 879         /* Create a write-to-disk object. */
 880         assert(NULL != (a = archive_write_disk_new()));
 881         archive_write_disk_set_options(a,
 882             ARCHIVE_EXTRACT_TIME | ARCHIVE_EXTRACT_PERM | ARCHIVE_EXTRACT_ACL);
 883
 884         /* Populate an archive entry with some metadata, including ACL info */
 885         ae = archive_entry_new();
 886         assert(ae != NULL);
 887         archive_entry_set_pathname(ae, "testall");
 888         archive_entry_set_filetype(ae, AE_IFREG);
 889         archive_entry_set_perm(ae, 0654);
 890         archive_entry_set_mtime(ae, 123456, 7890);
 891         archive_entry_set_size(ae, 0);
 892         set_acls(ae, acls_reg, 0, acls_reg_cnt);
 893
 894         /* Write the entry to disk, including ACLs. */
 895         assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
 896
 897         /* Likewise for a dir. */
 898         archive_entry_set_pathname(ae, "dirall");
 899         archive_entry_set_filetype(ae, AE_IFDIR);
 900         archive_entry_set_perm(ae, 0654);
 901         archive_entry_set_mtime(ae, 123456, 7890);
 902         set_acls(ae, acls_dir, 0, acls_dir_cnt);
 903         assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
 904
 905         for (i = 0; i < acls_dir_cnt; ++i) {
 906           sprintf(buff, "dir%d", i);
 907           archive_entry_set_pathname(ae, buff);
 908           archive_entry_set_filetype(ae, AE_IFDIR);
 909           archive_entry_set_perm(ae, 0654);
 910           archive_entry_set_mtime(ae, 123456 + i, 7891 + i);
 911           set_acls(ae, acls_dir, i, i + 1);
 912           assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
 913         }
 914
 915         archive_entry_free(ae);
 916
 917         /* Close the archive. */
 918         assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
 919         assertEqualInt(ARCHIVE_OK, archive_write_free(a));
 920
 921         /* Verify the data on disk. */
 922         assertEqualInt(0, stat("testall", &st));
 923         assertEqualInt(st.st_mtime, 123456);
 924 #if ARCHIVE_ACL_SUNOS_NFS4
 925         aclp = sunacl_get(ACE_GETACL, &aclcnt, 0, "testall");
 926         failure("acl(\"%s\"): errno = %d (%s)", "testall", errno,
 927             strerror(errno));
 928         assert(aclp != NULL);
 929 #elif ARCHIVE_ACL_LIBRICHACL
 930         richacl = richacl_get_file("testall");
 931         failure("richacl_get_file(\"%s\"): errno = %d (%s)", "testall", errno,
 932             strerror(errno));
 933         assert(richacl != NULL);
 934 #else
 935 #if ARCHIVE_ACL_DARWIN
 936         acl = acl_get_file("testall", ACL_TYPE_EXTENDED);
 937 #else
 938         acl = acl_get_file("testall", ACL_TYPE_NFS4);
 939 #endif
 940         failure("acl_get_file(\"%s\"): errno = %d (%s)", "testall", errno,
 941             strerror(errno));
 942         assert(acl != (acl_t)NULL);
 943 #endif
 944 #if ARCHIVE_ACL_SUNOS_NFS4
 945         compare_acls(aclp, aclcnt, acls_reg, "testall", 0, regcnt);
 946         free(aclp);
 947         aclp = NULL;
 948 #elif ARCHIVE_ACL_LIBRICHACL
 949         compare_acls(richacl, acls_reg, "testall", 0, regcnt);
 950         richacl_free(richacl);
 951 #else
 952         compare_acls(acl, acls_reg, "testall", 0, regcnt);
 953         acl_free(acl);
 954 #endif
 955
 956
 957         /* Verify single-permission dirs on disk. */
 958         for (i = 0; i < dircnt; ++i) {
 959                 sprintf(buff, "dir%d", i);
 960                 assertEqualInt(0, stat(buff, &st));
 961                 assertEqualInt(st.st_mtime, 123456 + i);
 962 #if ARCHIVE_ACL_SUNOS_NFS4
 963                 aclp = sunacl_get(ACE_GETACL, &aclcnt, 0, buff);
 964                 failure("acl(\"%s\"): errno = %d (%s)", buff, errno,
 965                     strerror(errno));
 966                 assert(aclp != NULL);
 967 #elif ARCHIVE_ACL_LIBRICHACL
 968                 richacl = richacl_get_file(buff);
 969                 /* First and last two dir do not return a richacl */
 970                 if ((i == 0 || i >= dircnt - 2) && richacl == NULL &&
 971                     errno == ENODATA)
 972                         continue;
 973                 failure("richacl_get_file(\"%s\"): errno = %d (%s)", buff,
 974                     errno, strerror(errno));
 975                 assert(richacl != NULL);
 976 #else
 977 #if ARCHIVE_ACL_DARWIN
 978                 acl = acl_get_file(buff, ACL_TYPE_EXTENDED);
 979 #else
 980                 acl = acl_get_file(buff, ACL_TYPE_NFS4);
 981 #endif
 982                 failure("acl_get_file(\"%s\"): errno = %d (%s)", buff, errno,
 983                     strerror(errno));
 984                 assert(acl != (acl_t)NULL);
 985 #endif
 986 #if ARCHIVE_ACL_SUNOS_NFS4
 987                 compare_acls(aclp, aclcnt, acls_dir, buff, i, i + 1);
 988                 free(aclp);
 989                 aclp = NULL;
 990 #elif ARCHIVE_ACL_LIBRICHACL
 991                 compare_acls(richacl, acls_dir, buff, i, i + 1);
 992                 richacl_free(richacl);
 993 #else
 994                 compare_acls(acl, acls_dir, buff, i, i + 1);
 995                 acl_free(acl);
 996 #endif
 997         }
 998
 999         /* Verify "dirall" on disk. */
1000         assertEqualInt(0, stat("dirall", &st));
1001         assertEqualInt(st.st_mtime, 123456);
1002 #if ARCHIVE_ACL_SUNOS_NFS4
1003         aclp = sunacl_get(ACE_GETACL, &aclcnt, 0, "dirall");
1004         failure("acl(\"%s\"): errno = %d (%s)", "dirall", errno,
1005             strerror(errno));
1006         assert(aclp != NULL);
1007 #elif ARCHIVE_ACL_LIBRICHACL
1008         richacl = richacl_get_file("dirall");
1009         failure("richacl_get_file(\"%s\"): errno = %d (%s)", "dirall",
1010             errno, strerror(errno));
1011         assert(richacl != NULL);
1012 #else
1013 #if ARCHIVE_ACL_DARWIN
1014         acl = acl_get_file("dirall", ACL_TYPE_EXTENDED);
1015 #else
1016         acl = acl_get_file("dirall", ACL_TYPE_NFS4);
1017 #endif
1018         failure("acl_get_file(\"%s\"): errno = %d (%s)", "dirall", errno,
1019             strerror(errno));
1020         assert(acl != (acl_t)NULL);
1021 #endif
1022 #if ARCHIVE_ACL_SUNOS_NFS4
1023         compare_acls(aclp, aclcnt, acls_dir, "dirall", 0, dircnt);
1024         free(aclp);
1025         aclp = NULL;
1026 #elif ARCHIVE_ACL_LIBRICHACL
1027         compare_acls(richacl, acls_dir, "dirall", 0, dircnt);
1028         richacl_free(richacl);
1029 #else
1030         compare_acls(acl, acls_dir, "dirall", 0, dircnt);
1031         acl_free(acl);
1032 #endif
1033
1034         /* Read and compare ACL via archive_read_disk */
1035         a = archive_read_disk_new();
1036         assert(a != NULL);
1037         ae = archive_entry_new();
1038         assert(ae != NULL);
1039         archive_entry_set_pathname(ae, "testall");
1040         assertEqualInt(ARCHIVE_OK,
1041                        archive_read_disk_entry_from_file(a, ae, -1, NULL));
1042         compare_entry_acls(ae, acls_reg, "testall", 0, acls_reg_cnt);
1043         archive_entry_free(ae);
1044         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1045
1046         /* Read and compare ACL via archive_read_disk */
1047         a = archive_read_disk_new();
1048         assert(a != NULL);
1049         ae = archive_entry_new();
1050         assert(ae != NULL);
1051         archive_entry_set_pathname(ae, "dirall");
1052         assertEqualInt(ARCHIVE_OK,
1053         archive_read_disk_entry_from_file(a, ae, -1, NULL));
1054         compare_entry_acls(ae, acls_dir, "dirall", 0, acls_dir_cnt);
1055         archive_entry_free(ae);
1056         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1057 #endif /* ARCHIVE_ACL_NFS4 */
1058 }