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