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