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