test_acl_pax.c revision 313571
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: stable/10/contrib/libarchive/libarchive/test/test_acl_pax.c 313571 2017-02-11 00:56:18Z mm $"); 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 37static unsigned char buff[16384]; 38 39static 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 48static 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 59static 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 74static 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 108static 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 161static 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 216DEFINE_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 archive_test_set_acls(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 archive_test_set_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0])); 246 assertA(0 == archive_write_header(a, ae)); 247 248 249 /* A more extensive set of ACLs. */ 250 archive_test_set_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0])); 251 assertA(0 == archive_write_header(a, ae)); 252 253 /* 254 * Check that clearing ACLs gets rid of them all by repeating 255 * the first test. 256 */ 257 archive_test_set_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0])); 258 assertA(0 == archive_write_header(a, ae)); 259 archive_entry_free(ae); 260 261 /* Close out the archive. */ 262 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a)); 263 assertEqualInt(ARCHIVE_OK, archive_write_free(a)); 264 265 /* Write out the data we generated to a file for manual inspection. */ 266 assert(NULL != (f = fopen("testout", "wb"))); 267 assertEqualInt(used, (size_t)fwrite(buff, 1, (unsigned int)used, f)); 268 fclose(f); 269 270 /* Write out the reference data to a file for manual inspection. */ 271 extract_reference_file("test_acl_pax_posix1e.tar"); 272 reference = slurpfile(&reference_size, "test_acl_pax_posix1e.tar"); 273 274 /* Assert that the generated data matches the built-in reference data.*/ 275 failure("Generated pax archive does not match reference; compare 'testout' to 'test_acl_pax_posix1e.tar' reference file."); 276 assertEqualMem(buff, reference, reference_size); 277 failure("Generated pax archive does not match reference; compare 'testout' to 'test_acl_pax_posix1e.tar' reference file."); 278 assertEqualInt((int)used, reference_size); 279 free(reference); 280 281 /* Read back each entry and check that the ACL data is right. */ 282 assert(NULL != (a = archive_read_new())); 283 assertA(0 == archive_read_support_format_all(a)); 284 assertA(0 == archive_read_support_filter_all(a)); 285 assertA(0 == archive_read_open_memory(a, buff, used)); 286 287 /* First item has no ACLs */ 288 assertA(0 == archive_read_next_header(a, &ae)); 289 failure("Basic ACLs shouldn't be stored as extended ACLs"); 290 assert(0 == archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS)); 291 failure("Basic ACLs should set mode to 0142, not %04o", 292 archive_entry_mode(ae)&0777); 293 assert((archive_entry_mode(ae) & 0777) == 0142); 294 295 /* Second item has a few ACLs */ 296 assertA(0 == archive_read_next_header(a, &ae)); 297 failure("One extended ACL should flag all ACLs to be returned."); 298 assert(4 == archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS)); 299 archive_test_compare_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]), 300 ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0142); 301 failure("Basic ACLs should set mode to 0142, not %04o", 302 archive_entry_mode(ae)&0777); 303 assert((archive_entry_mode(ae) & 0777) == 0142); 304 305 /* Third item has pretty extensive ACLs */ 306 assertA(0 == archive_read_next_header(a, &ae)); 307 assertEqualInt(6, archive_entry_acl_reset(ae, 308 ARCHIVE_ENTRY_ACL_TYPE_ACCESS)); 309 archive_test_compare_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]), 310 ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0543); 311 failure("Basic ACLs should set mode to 0543, not %04o", 312 archive_entry_mode(ae)&0777); 313 assert((archive_entry_mode(ae) & 0777) == 0543); 314 315 /* Fourth item has no ACLs */ 316 assertA(0 == archive_read_next_header(a, &ae)); 317 failure("Basic ACLs shouldn't be stored as extended ACLs"); 318 assert(0 == archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS)); 319 failure("Basic ACLs should set mode to 0142, not %04o", 320 archive_entry_mode(ae)&0777); 321 assert((archive_entry_mode(ae) & 0777) == 0142); 322 323 /* Close the archive. */ 324 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 325 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 326} 327 328DEFINE_TEST(test_acl_pax_nfs4) 329{ 330 struct archive *a; 331 struct archive_entry *ae; 332 size_t used; 333 FILE *f; 334 void *reference; 335 size_t reference_size; 336 337 /* Write an archive to memory. */ 338 assert(NULL != (a = archive_write_new())); 339 assertA(0 == archive_write_set_format_pax(a)); 340 assertA(0 == archive_write_add_filter_none(a)); 341 assertA(0 == archive_write_set_bytes_per_block(a, 1)); 342 assertA(0 == archive_write_set_bytes_in_last_block(a, 1)); 343 assertA(0 == archive_write_open_memory(a, buff, sizeof(buff), &used)); 344 345 /* Write a series of files to the archive with different ACL info. */ 346 347 /* Create a simple archive_entry. */ 348 assert((ae = archive_entry_new()) != NULL); 349 archive_entry_set_pathname(ae, "file"); 350 archive_entry_set_mode(ae, S_IFREG | 0777); 351 352 /* NFS4 ACLs mirroring 0754 file mode */ 353 archive_test_set_acls(ae, acls3, sizeof(acls3)/sizeof(acls3[0])); 354 assertA(0 == archive_write_header(a, ae)); 355 356 /* A more extensive set of NFS4 ACLs. */ 357 archive_test_set_acls(ae, acls4, sizeof(acls4)/sizeof(acls4[0])); 358 assertA(0 == archive_write_header(a, ae)); 359 360 /* Set with special (audit, alarm) NFS4 ACLs. */ 361 archive_test_set_acls(ae, acls5, sizeof(acls5)/sizeof(acls5[0])); 362 assertA(0 == archive_write_header(a, ae)); 363 364 archive_entry_free(ae); 365 366 /* Close out the archive. */ 367 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a)); 368 assertEqualInt(ARCHIVE_OK, archive_write_free(a)); 369 370 /* Write out the data we generated to a file for manual inspection. */ 371 assert(NULL != (f = fopen("testout", "wb"))); 372 assertEqualInt(used, (size_t)fwrite(buff, 1, (unsigned int)used, f)); 373 fclose(f); 374 375 /* Write out the reference data to a file for manual inspection. */ 376 extract_reference_file("test_acl_pax_nfs4.tar"); 377 reference = slurpfile(&reference_size, "test_acl_pax_nfs4.tar"); 378 379 /* Assert that the generated data matches the built-in reference data.*/ 380 failure("Generated pax archive does not match reference; compare 'testout' to 'test_acl_pax_nfs4.tar' reference file."); 381 assertEqualMem(buff, reference, reference_size); 382 failure("Generated pax archive does not match reference; compare 'testout' to 'test_acl_pax_nfs4.tar' reference file."); 383 assertEqualInt((int)used, reference_size); 384 free(reference); 385 386 /* Read back each entry and check that the ACL data is right. */ 387 assert(NULL != (a = archive_read_new())); 388 assertA(0 == archive_read_support_format_all(a)); 389 assertA(0 == archive_read_support_filter_all(a)); 390 assertA(0 == archive_read_open_memory(a, buff, used)); 391 392 /* First item has NFS4 ACLs mirroring file mode */ 393 assertA(0 == archive_read_next_header(a, &ae)); 394 assertEqualInt(3, archive_entry_acl_reset(ae, 395 ARCHIVE_ENTRY_ACL_TYPE_ALLOW)); 396 archive_test_compare_acls(ae, acls3, sizeof(acls3)/sizeof(acls3[0]), 397 ARCHIVE_ENTRY_ACL_TYPE_ALLOW, 0); 398 399 /* Second item has has more fine-grained NFS4 ACLs */ 400 assertA(0 == archive_read_next_header(a, &ae)); 401 assertEqualInt(6, archive_entry_acl_reset(ae, 402 ARCHIVE_ENTRY_ACL_TYPE_NFS4)); 403 archive_test_compare_acls(ae, acls4, sizeof(acls4)/sizeof(acls4[0]), 404 ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0); 405 406 /* Third item has has audit and alarm NFS4 ACLs */ 407 assertA(0 == archive_read_next_header(a, &ae)); 408 assertEqualInt(6, archive_entry_acl_reset(ae, 409 ARCHIVE_ENTRY_ACL_TYPE_NFS4)); 410 archive_test_compare_acls(ae, acls5, sizeof(acls5)/sizeof(acls5[0]), 411 ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0); 412 413 /* Close the archive. */ 414 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 415 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 416} 417