1 /*-
2 * Copyright (c) 2016 Martin Matuska
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25 #include "test.h"
26
27 /*
28 * Test converting ACLs to text, both wide and non-wide
29 *
30 * This should work on all systems, regardless of whether local
31 * filesystems support ACLs or not.
32 */
33
34 static struct archive_test_acl_t acls0[] = {
35 { ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
36 ARCHIVE_ENTRY_ACL_EXECUTE |
37 ARCHIVE_ENTRY_ACL_READ |
38 ARCHIVE_ENTRY_ACL_WRITE,
39 ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },
40 { ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
41 ARCHIVE_ENTRY_ACL_EXECUTE |
42 ARCHIVE_ENTRY_ACL_READ,
43 ARCHIVE_ENTRY_ACL_USER, 100, "user100" },
44 { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0,
45 ARCHIVE_ENTRY_ACL_USER, 1000, "user1000" },
46 { ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
47 ARCHIVE_ENTRY_ACL_EXECUTE |
48 ARCHIVE_ENTRY_ACL_READ,
49 ARCHIVE_ENTRY_ACL_GROUP_OBJ, -1, "" },
50 { ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
51 ARCHIVE_ENTRY_ACL_EXECUTE |
52 ARCHIVE_ENTRY_ACL_READ |
53 ARCHIVE_ENTRY_ACL_WRITE,
54 ARCHIVE_ENTRY_ACL_GROUP, 78, "group78" },
55 { ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
56 ARCHIVE_ENTRY_ACL_READ |
57 ARCHIVE_ENTRY_ACL_EXECUTE,
58 ARCHIVE_ENTRY_ACL_OTHER, -1, "" },
59 { ARCHIVE_ENTRY_ACL_TYPE_DEFAULT,
60 ARCHIVE_ENTRY_ACL_EXECUTE |
61 ARCHIVE_ENTRY_ACL_READ,
62 ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },
63 { ARCHIVE_ENTRY_ACL_TYPE_DEFAULT,
64 ARCHIVE_ENTRY_ACL_EXECUTE |
65 ARCHIVE_ENTRY_ACL_READ,
66 ARCHIVE_ENTRY_ACL_GROUP_OBJ, -1, "" },
67 { ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, 0,
68 ARCHIVE_ENTRY_ACL_OTHER, -1, "" },
69 { ARCHIVE_ENTRY_ACL_TYPE_DEFAULT,
70 ARCHIVE_ENTRY_ACL_EXECUTE |
71 ARCHIVE_ENTRY_ACL_READ,
72 ARCHIVE_ENTRY_ACL_USER, 101, "user101"},
73 { ARCHIVE_ENTRY_ACL_TYPE_DEFAULT,
74 ARCHIVE_ENTRY_ACL_EXECUTE,
75 ARCHIVE_ENTRY_ACL_GROUP, 79, "group79" },
76 };
77
78 static struct archive_test_acl_t acls1[] = {
79 { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
80 ARCHIVE_ENTRY_ACL_READ_DATA |
81 ARCHIVE_ENTRY_ACL_WRITE_DATA |
82 ARCHIVE_ENTRY_ACL_APPEND_DATA |
83 ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
84 ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
85 ARCHIVE_ENTRY_ACL_READ_ACL |
86 ARCHIVE_ENTRY_ACL_WRITE_OWNER,
87 ARCHIVE_ENTRY_ACL_USER, 77, "user77" },
88 { ARCHIVE_ENTRY_ACL_TYPE_DENY,
89 ARCHIVE_ENTRY_ACL_WRITE_DATA |
90 ARCHIVE_ENTRY_ACL_APPEND_DATA |
91 ARCHIVE_ENTRY_ACL_DELETE_CHILD |
92 ARCHIVE_ENTRY_ACL_DELETE |
93 ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT |
94 ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT |
95 ARCHIVE_ENTRY_ACL_ENTRY_INHERIT_ONLY |
96 ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT,
97 ARCHIVE_ENTRY_ACL_USER, 101, "user101" },
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_ENTRY_INHERITED,
104 ARCHIVE_ENTRY_ACL_GROUP, 78, "group78" },
105 { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
106 ARCHIVE_ENTRY_ACL_READ_DATA |
107 ARCHIVE_ENTRY_ACL_WRITE_DATA |
108 ARCHIVE_ENTRY_ACL_EXECUTE |
109 ARCHIVE_ENTRY_ACL_APPEND_DATA |
110 ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
111 ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES |
112 ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
113 ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS |
114 ARCHIVE_ENTRY_ACL_READ_ACL |
115 ARCHIVE_ENTRY_ACL_WRITE_ACL |
116 ARCHIVE_ENTRY_ACL_WRITE_OWNER,
117 ARCHIVE_ENTRY_ACL_USER_OBJ, 0, "" },
118 { ARCHIVE_ENTRY_ACL_TYPE_ALLOW,
119 ARCHIVE_ENTRY_ACL_READ_DATA |
120 ARCHIVE_ENTRY_ACL_WRITE_DATA |
121 ARCHIVE_ENTRY_ACL_APPEND_DATA |
122 ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |
123 ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |
124 ARCHIVE_ENTRY_ACL_READ_ACL,
125 ARCHIVE_ENTRY_ACL_GROUP_OBJ, 0, "" },
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, 0, "" },
133 };
134
135 static const char* acltext[] = {
136 "user::rwx\n"
137 "group::r-x\n"
138 "other::r-x\n"
139 "user:user100:r-x\n"
140 "user:user1000:---\n"
141 "group:group78:rwx\n"
142 "default:user::r-x\n"
143 "default:group::r-x\n"
144 "default:other::---\n"
145 "default:user:user101:r-x\n"
146 "default:group:group79:--x",
147
148 "user::rwx\n"
149 "group::r-x\n"
150 "other::r-x\n"
151 "user:user100:r-x:100\n"
152 "user:user1000:---:1000\n"
153 "group:group78:rwx:78\n"
154 "default:user::r-x\n"
155 "default:group::r-x\n"
156 "default:other::---\n"
157 "default:user:user101:r-x:101\n"
158 "default:group:group79:--x:79",
159
160 "u::rwx\n"
161 "g::r-x\n"
162 "o::r-x\n"
163 "u:user100:r-x:100\n"
164 "u:user1000:---:1000\n"
165 "g:group78:rwx:78\n"
166 "d:user::r-x\n"
167 "d:group::r-x\n"
168 "d:other::---\n"
169 "d:user:user101:r-x:101\n"
170 "d:group:group79:--x:79",
171
172 "user::rwx\n"
173 "group::r-x\n"
174 "other::r-x\n"
175 "user:user100:r-x\n"
176 "user:user1000:---\n"
177 "group:group78:rwx",
178
179 "user::rwx,"
180 "group::r-x,"
181 "other::r-x,"
182 "user:user100:r-x,"
183 "user:user1000:---,"
184 "group:group78:rwx",
185
186 "user::rwx\n"
187 "group::r-x\n"
188 "other::r-x\n"
189 "user:user100:r-x:100\n"
190 "user:user1000:---:1000\n"
191 "group:group78:rwx:78",
192
193 "user::r-x\n"
194 "group::r-x\n"
195 "other::---\n"
196 "user:user101:r-x\n"
197 "group:group79:--x",
198
199 "user::r-x\n"
200 "group::r-x\n"
201 "other::---\n"
202 "user:user101:r-x:101\n"
203 "group:group79:--x:79",
204
205 "default:user::r-x\n"
206 "default:group::r-x\n"
207 "default:other::---\n"
208 "default:user:user101:r-x\n"
209 "default:group:group79:--x",
210
211 "user:user77:rw-p--a-R-c-o-:-------:allow\n"
212 "user:user101:-w-pdD--------:fdin---:deny\n"
213 "group:group78:r-----a-R-c---:------I:allow\n"
214 "owner@:rwxp--aARWcCo-:-------:allow\n"
215 "group@:rw-p--a-R-c---:-------:allow\n"
216 "everyone@:r-----a-R-c--s:-------:allow",
217
218 "user:user77:rw-p--a-R-c-o-:-------:allow:77\n"
219 "user:user101:-w-pdD--------:fdin---:deny:101\n"
220 "group:group78:r-----a-R-c---:------I:allow:78\n"
221 "owner@:rwxp--aARWcCo-:-------:allow\n"
222 "group@:rw-p--a-R-c---:-------:allow\n"
223 "everyone@:r-----a-R-c--s:-------:allow",
224
225 "user:user77:rwpaRco::allow:77\n"
226 "user:user101:wpdD:fdin:deny:101\n"
227 "group:group78:raRc:I:allow:78\n"
228 "owner@:rwxpaARWcCo::allow\n"
229 "group@:rwpaRc::allow\n"
230 "everyone@:raRcs::allow"
231 };
232
233 static wchar_t *
convert_s_to_ws(const char * s)234 convert_s_to_ws(const char *s)
235 {
236 size_t len;
237 wchar_t *ws = NULL;
238
239 if (s != NULL) {
240 len = strlen(s) + 1;
241 ws = malloc(len * sizeof(wchar_t));
242 assert(mbstowcs(ws, s, len) != (size_t)-1);
243 }
244
245 return (ws);
246 }
247
248 static void
compare_acl_text(struct archive_entry * ae,int flags,const char * s)249 compare_acl_text(struct archive_entry *ae, int flags, const char *s)
250 {
251 char *text;
252 wchar_t *wtext;
253 wchar_t *ws;
254 ssize_t slen;
255
256 ws = convert_s_to_ws(s);
257
258 text = archive_entry_acl_to_text(ae, &slen, flags);
259 assertEqualString(text, s);
260 if (text != NULL)
261 assertEqualInt(strlen(text), slen);
262 wtext = archive_entry_acl_to_text_w(ae, &slen, flags);
263 assertEqualWString(wtext, ws);
264 if (wtext != NULL) {
265 assertEqualInt(wcslen(wtext), slen);
266 }
267 free(text);
268 free(wtext);
269 free(ws);
270 }
271
DEFINE_TEST(test_acl_from_text)272 DEFINE_TEST(test_acl_from_text)
273 {
274 struct archive_entry *ae;
275 wchar_t *ws = NULL;
276
277 /* Create an empty archive_entry. */
278 assert((ae = archive_entry_new()) != NULL);
279
280 /* 1a. Read POSIX.1e access ACLs from text */
281 assertEqualInt(ARCHIVE_OK,
282 archive_entry_acl_from_text(ae, acltext[5],
283 ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
284 assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
285 ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0755);
286 assertEqualInt(6, archive_entry_acl_reset(ae,
287 ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
288
289 /* 1b. Now read POSIX.1e default ACLs and append them */
290 assertEqualInt(ARCHIVE_OK,
291 archive_entry_acl_from_text(ae, acltext[7],
292 ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));
293 assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
294 ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);
295 assertEqualInt(11, archive_entry_acl_reset(ae,
296 ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
297 archive_entry_acl_clear(ae);
298
299 /* 1a and 1b with wide strings */
300 ws = convert_s_to_ws(acltext[5]);
301
302 assertEqualInt(ARCHIVE_OK,
303 archive_entry_acl_from_text_w(ae, ws,
304 ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
305 assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
306 ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0755);
307 assertEqualInt(6, archive_entry_acl_reset(ae,
308 ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
309
310 free(ws);
311 ws = convert_s_to_ws(acltext[7]);
312
313 assertEqualInt(ARCHIVE_OK,
314 archive_entry_acl_from_text_w(ae, ws,
315 ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));
316 assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
317 ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);
318 assertEqualInt(11, archive_entry_acl_reset(ae,
319 ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
320 archive_entry_acl_clear(ae);
321
322 /* 2. Read POSIX.1e default ACLs from text */
323 assertEqualInt(ARCHIVE_OK,
324 archive_entry_acl_from_text(ae, acltext[7],
325 ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));
326 assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
327 ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, 0);
328 assertEqualInt(5, archive_entry_acl_reset(ae,
329 ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));
330 archive_entry_acl_clear(ae);
331
332 /* ws is still acltext[7] */
333 assertEqualInt(ARCHIVE_OK,
334 archive_entry_acl_from_text_w(ae, ws,
335 ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));
336 assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
337 ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, 0);
338 assertEqualInt(5, archive_entry_acl_reset(ae,
339 ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));
340 archive_entry_acl_clear(ae);
341
342 /* 3. Read POSIX.1e access and default ACLs from text */
343 assertEqualInt(ARCHIVE_OK,
344 archive_entry_acl_from_text(ae, acltext[1],
345 ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
346 assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
347 ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);
348 assertEqualInt(11, archive_entry_acl_reset(ae,
349 ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
350 archive_entry_acl_clear(ae);
351
352 free(ws);
353 ws = convert_s_to_ws(acltext[1]);
354 assertEqualInt(ARCHIVE_OK,
355 archive_entry_acl_from_text_w(ae, ws,
356 ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
357 assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
358 ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);
359 assertEqualInt(11, archive_entry_acl_reset(ae,
360 ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
361 archive_entry_acl_clear(ae);
362
363 /* 4. Read POSIX.1e access and default ACLs from text (short form) */
364 assertEqualInt(ARCHIVE_OK,
365 archive_entry_acl_from_text(ae, acltext[2],
366 ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
367 assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
368 ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);
369 assertEqualInt(11, archive_entry_acl_reset(ae,
370 ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
371 archive_entry_acl_clear(ae);
372
373 free(ws);
374 ws = convert_s_to_ws(acltext[2]);
375 assertEqualInt(ARCHIVE_OK,
376 archive_entry_acl_from_text_w(ae, ws,
377 ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
378 assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),
379 ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);
380 assertEqualInt(11, archive_entry_acl_reset(ae,
381 ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));
382 archive_entry_acl_clear(ae);
383
384 /* 5. Read NFSv4 ACLs from text */
385 assertEqualInt(ARCHIVE_OK,
386 archive_entry_acl_from_text(ae, acltext[10],
387 ARCHIVE_ENTRY_ACL_TYPE_NFS4));
388 assertEntryCompareAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
389 ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);
390 assertEqualInt(6, archive_entry_acl_reset(ae,
391 ARCHIVE_ENTRY_ACL_TYPE_NFS4));
392 archive_entry_acl_clear(ae);
393
394 free(ws);
395 ws = convert_s_to_ws(acltext[10]);
396
397 assertEqualInt(ARCHIVE_OK,
398 archive_entry_acl_from_text_w(ae, ws,
399 ARCHIVE_ENTRY_ACL_TYPE_NFS4));
400 assertEntryCompareAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),
401 ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);
402 assertEqualInt(6, archive_entry_acl_reset(ae,
403 ARCHIVE_ENTRY_ACL_TYPE_NFS4));
404 archive_entry_acl_clear(ae);
405
406 free(ws);
407 archive_entry_free(ae);
408 }
409
DEFINE_TEST(test_acl_to_text)410 DEFINE_TEST(test_acl_to_text)
411 {
412 struct archive_entry *ae;
413
414 /* Create an empty archive_entry. */
415 assert((ae = archive_entry_new()) != NULL);
416
417 /* Write POSIX.1e ACLs */
418 assertEntrySetAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]));
419
420 /* No flags should give output like getfacl(1) on linux */
421 compare_acl_text(ae, 0, acltext[0]);
422
423 /* This should give the same output as previous test */
424 compare_acl_text(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS |
425 ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, acltext[0]);
426
427 /* This should give the same output as previous two tests */
428 compare_acl_text(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS |
429 ARCHIVE_ENTRY_ACL_TYPE_DEFAULT |
430 ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT, acltext[0]);
431
432 /* POSIX.1e access and default ACLs with appended ID */
433 compare_acl_text(ae, ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID, acltext[1]);
434
435 /* POSIX.1e access acls only, like getfacl(1) on FreeBSD */
436 compare_acl_text(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS, acltext[3]);
437
438 /* POSIX.1e access acls separated with comma */
439 compare_acl_text(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS |
440 ARCHIVE_ENTRY_ACL_STYLE_SEPARATOR_COMMA,
441 acltext[4]);
442
443 /* POSIX.1e access acls with appended user or group ID */
444 compare_acl_text(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS |
445 ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID, acltext[5]);
446
447 /* POSIX.1e default acls */
448 compare_acl_text(ae, ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, acltext[6]);
449
450 /* POSIX.1e default acls with appended user or group ID */
451 compare_acl_text(ae, ARCHIVE_ENTRY_ACL_TYPE_DEFAULT |
452 ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID, acltext[7]);
453
454 /* POSIX.1e default acls prefixed with default: */
455 compare_acl_text(ae, ARCHIVE_ENTRY_ACL_TYPE_DEFAULT |
456 ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT, acltext[8]);
457
458 /* Write NFSv4 ACLs */
459 assertEntrySetAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]));
460
461 /* NFSv4 ACLs like getfacl(1) on FreeBSD */
462 compare_acl_text(ae, 0, acltext[9]);
463
464 /* NFSv4 ACLs like "getfacl -i" on FreeBSD */
465 compare_acl_text(ae, ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID, acltext[10]);
466
467 /* NFSv4 ACLs like "getfacl -i" on FreeBSD with stripped minus chars */
468 compare_acl_text(ae, ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID |
469 ARCHIVE_ENTRY_ACL_STYLE_COMPACT, acltext[11]);
470
471 archive_entry_free(ae);
472 }
473