1fa9e4066Sahrens /*
2fa9e4066Sahrens * CDDL HEADER START
3fa9e4066Sahrens *
4fa9e4066Sahrens * The contents of this file are subject to the terms of the
5f48205beScasper * Common Development and Distribution License (the "License").
6f48205beScasper * You may not use this file except in compliance with the License.
7fa9e4066Sahrens *
8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing.
10fa9e4066Sahrens * See the License for the specific language governing permissions
11fa9e4066Sahrens * and limitations under the License.
12fa9e4066Sahrens *
13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each
14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the
16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying
17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner]
18fa9e4066Sahrens *
19fa9e4066Sahrens * CDDL HEADER END
20fa9e4066Sahrens */
21fa9e4066Sahrens /*
2227dd1e87SMark Shellenbaum * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
231eb4e906SKevin Crowe * Copyright 2014 Nexenta Systems, Inc. All rights reserved.
24*70561057SGordon Ross * Copyright 2023 RackTop Systems, Inc.
25fa9e4066Sahrens */
26fa9e4066Sahrens
27fa9e4066Sahrens #include <sys/types.h>
28fa9e4066Sahrens #include <sys/stat.h>
29b819cea2SGordon Ross #include <sys/errno.h>
30da6c28aaSamw #include <sys/avl.h>
31b819cea2SGordon Ross #if defined(_KERNEL) || defined(_FAKE_KERNEL)
32b819cea2SGordon Ross #include <sys/debug.h>
33b819cea2SGordon Ross #include <sys/kmem.h>
34fa9e4066Sahrens #include <sys/systm.h>
35da6c28aaSamw #include <sys/sysmacros.h>
36da6c28aaSamw #include <acl/acl_common.h>
37fa9e4066Sahrens #else
38fa9e4066Sahrens #include <errno.h>
39fa9e4066Sahrens #include <stdlib.h>
40da6c28aaSamw #include <stddef.h>
41fa9e4066Sahrens #include <strings.h>
42da6c28aaSamw #include <unistd.h>
43fa9e4066Sahrens #include <assert.h>
44da6c28aaSamw #include <grp.h>
45da6c28aaSamw #include <pwd.h>
46da6c28aaSamw #include <acl_common.h>
47fa9e4066Sahrens #define ASSERT assert
48fa9e4066Sahrens #endif
49fa9e4066Sahrens
50da6c28aaSamw #define ACE_POSIX_SUPPORTED_BITS (ACE_READ_DATA | \
51da6c28aaSamw ACE_WRITE_DATA | ACE_APPEND_DATA | ACE_EXECUTE | \
52da6c28aaSamw ACE_READ_ATTRIBUTES | ACE_READ_ACL | ACE_WRITE_ACL)
53da6c28aaSamw
54da6c28aaSamw
55da6c28aaSamw #define ACL_SYNCHRONIZE_SET_DENY 0x0000001
56da6c28aaSamw #define ACL_SYNCHRONIZE_SET_ALLOW 0x0000002
57da6c28aaSamw #define ACL_SYNCHRONIZE_ERR_DENY 0x0000004
58da6c28aaSamw #define ACL_SYNCHRONIZE_ERR_ALLOW 0x0000008
59da6c28aaSamw
60da6c28aaSamw #define ACL_WRITE_OWNER_SET_DENY 0x0000010
61da6c28aaSamw #define ACL_WRITE_OWNER_SET_ALLOW 0x0000020
62da6c28aaSamw #define ACL_WRITE_OWNER_ERR_DENY 0x0000040
63da6c28aaSamw #define ACL_WRITE_OWNER_ERR_ALLOW 0x0000080
64da6c28aaSamw
65da6c28aaSamw #define ACL_DELETE_SET_DENY 0x0000100
66da6c28aaSamw #define ACL_DELETE_SET_ALLOW 0x0000200
67da6c28aaSamw #define ACL_DELETE_ERR_DENY 0x0000400
68da6c28aaSamw #define ACL_DELETE_ERR_ALLOW 0x0000800
69da6c28aaSamw
70da6c28aaSamw #define ACL_WRITE_ATTRS_OWNER_SET_DENY 0x0001000
71da6c28aaSamw #define ACL_WRITE_ATTRS_OWNER_SET_ALLOW 0x0002000
72da6c28aaSamw #define ACL_WRITE_ATTRS_OWNER_ERR_DENY 0x0004000
73da6c28aaSamw #define ACL_WRITE_ATTRS_OWNER_ERR_ALLOW 0x0008000
74da6c28aaSamw
75da6c28aaSamw #define ACL_WRITE_ATTRS_WRITER_SET_DENY 0x0010000
76da6c28aaSamw #define ACL_WRITE_ATTRS_WRITER_SET_ALLOW 0x0020000
77da6c28aaSamw #define ACL_WRITE_ATTRS_WRITER_ERR_DENY 0x0040000
78da6c28aaSamw #define ACL_WRITE_ATTRS_WRITER_ERR_ALLOW 0x0080000
79da6c28aaSamw
80da6c28aaSamw #define ACL_WRITE_NAMED_WRITER_SET_DENY 0x0100000
81da6c28aaSamw #define ACL_WRITE_NAMED_WRITER_SET_ALLOW 0x0200000
82da6c28aaSamw #define ACL_WRITE_NAMED_WRITER_ERR_DENY 0x0400000
83da6c28aaSamw #define ACL_WRITE_NAMED_WRITER_ERR_ALLOW 0x0800000
84da6c28aaSamw
85da6c28aaSamw #define ACL_READ_NAMED_READER_SET_DENY 0x1000000
86da6c28aaSamw #define ACL_READ_NAMED_READER_SET_ALLOW 0x2000000
87da6c28aaSamw #define ACL_READ_NAMED_READER_ERR_DENY 0x4000000
88da6c28aaSamw #define ACL_READ_NAMED_READER_ERR_ALLOW 0x8000000
89da6c28aaSamw
90da6c28aaSamw
91da6c28aaSamw #define ACE_VALID_MASK_BITS (\
92da6c28aaSamw ACE_READ_DATA | \
93da6c28aaSamw ACE_LIST_DIRECTORY | \
94da6c28aaSamw ACE_WRITE_DATA | \
95da6c28aaSamw ACE_ADD_FILE | \
96da6c28aaSamw ACE_APPEND_DATA | \
97da6c28aaSamw ACE_ADD_SUBDIRECTORY | \
98da6c28aaSamw ACE_READ_NAMED_ATTRS | \
99da6c28aaSamw ACE_WRITE_NAMED_ATTRS | \
100da6c28aaSamw ACE_EXECUTE | \
101da6c28aaSamw ACE_DELETE_CHILD | \
102da6c28aaSamw ACE_READ_ATTRIBUTES | \
103da6c28aaSamw ACE_WRITE_ATTRIBUTES | \
104da6c28aaSamw ACE_DELETE | \
105da6c28aaSamw ACE_READ_ACL | \
106da6c28aaSamw ACE_WRITE_ACL | \
107da6c28aaSamw ACE_WRITE_OWNER | \
108da6c28aaSamw ACE_SYNCHRONIZE)
109da6c28aaSamw
110da6c28aaSamw #define ACE_MASK_UNDEFINED 0x80000000
111da6c28aaSamw
112da6c28aaSamw #define ACE_VALID_FLAG_BITS (ACE_FILE_INHERIT_ACE | \
113da6c28aaSamw ACE_DIRECTORY_INHERIT_ACE | \
114da6c28aaSamw ACE_NO_PROPAGATE_INHERIT_ACE | ACE_INHERIT_ONLY_ACE | \
115da6c28aaSamw ACE_SUCCESSFUL_ACCESS_ACE_FLAG | ACE_FAILED_ACCESS_ACE_FLAG | \
116da6c28aaSamw ACE_IDENTIFIER_GROUP | ACE_OWNER | ACE_GROUP | ACE_EVERYONE)
117da6c28aaSamw
118da6c28aaSamw /*
119da6c28aaSamw * ACL conversion helpers
120da6c28aaSamw */
121da6c28aaSamw
122da6c28aaSamw typedef enum {
123da6c28aaSamw ace_unused,
124da6c28aaSamw ace_user_obj,
125da6c28aaSamw ace_user,
126da6c28aaSamw ace_group, /* includes GROUP and GROUP_OBJ */
127da6c28aaSamw ace_other_obj
128da6c28aaSamw } ace_to_aent_state_t;
129da6c28aaSamw
130da6c28aaSamw typedef struct acevals {
131da6c28aaSamw uid_t key;
132da6c28aaSamw avl_node_t avl;
133da6c28aaSamw uint32_t mask;
134da6c28aaSamw uint32_t allowed;
135da6c28aaSamw uint32_t denied;
136da6c28aaSamw int aent_type;
137da6c28aaSamw } acevals_t;
138da6c28aaSamw
139da6c28aaSamw typedef struct ace_list {
140da6c28aaSamw acevals_t user_obj;
141da6c28aaSamw avl_tree_t user;
142da6c28aaSamw int numusers;
143da6c28aaSamw acevals_t group_obj;
144da6c28aaSamw avl_tree_t group;
145da6c28aaSamw int numgroups;
146da6c28aaSamw acevals_t other_obj;
147da6c28aaSamw uint32_t acl_mask;
148da6c28aaSamw int hasmask;
149da6c28aaSamw int dfacl_flag;
150da6c28aaSamw ace_to_aent_state_t state;
151da6c28aaSamw int seen; /* bitmask of all aclent_t a_type values seen */
152da6c28aaSamw } ace_list_t;
153fa9e4066Sahrens
154fa9e4066Sahrens /*
155fa9e4066Sahrens * Generic shellsort, from K&R (1st ed, p 58.), somewhat modified.
156fa9e4066Sahrens * v = Ptr to array/vector of objs
157fa9e4066Sahrens * n = # objs in the array
158fa9e4066Sahrens * s = size of each obj (must be multiples of a word size)
159fa9e4066Sahrens * f = ptr to function to compare two objs
160fa9e4066Sahrens * returns (-1 = less than, 0 = equal, 1 = greater than
161fa9e4066Sahrens */
162fa9e4066Sahrens void
ksort(caddr_t v,int n,int s,int (* f)())163fa9e4066Sahrens ksort(caddr_t v, int n, int s, int (*f)())
164fa9e4066Sahrens {
165fa9e4066Sahrens int g, i, j, ii;
166fa9e4066Sahrens unsigned int *p1, *p2;
167fa9e4066Sahrens unsigned int tmp;
168fa9e4066Sahrens
169fa9e4066Sahrens /* No work to do */
170fa9e4066Sahrens if (v == NULL || n <= 1)
171fa9e4066Sahrens return;
172fa9e4066Sahrens
173fa9e4066Sahrens /* Sanity check on arguments */
174fa9e4066Sahrens ASSERT(((uintptr_t)v & 0x3) == 0 && (s & 0x3) == 0);
175fa9e4066Sahrens ASSERT(s > 0);
176fa9e4066Sahrens for (g = n / 2; g > 0; g /= 2) {
177fa9e4066Sahrens for (i = g; i < n; i++) {
178fa9e4066Sahrens for (j = i - g; j >= 0 &&
179da6c28aaSamw (*f)(v + j * s, v + (j + g) * s) == 1;
180da6c28aaSamw j -= g) {
181fa9e4066Sahrens p1 = (void *)(v + j * s);
182fa9e4066Sahrens p2 = (void *)(v + (j + g) * s);
183fa9e4066Sahrens for (ii = 0; ii < s / 4; ii++) {
184fa9e4066Sahrens tmp = *p1;
185fa9e4066Sahrens *p1++ = *p2;
186fa9e4066Sahrens *p2++ = tmp;
187fa9e4066Sahrens }
188fa9e4066Sahrens }
189fa9e4066Sahrens }
190fa9e4066Sahrens }
191fa9e4066Sahrens }
192fa9e4066Sahrens
193fa9e4066Sahrens /*
194fa9e4066Sahrens * Compare two acls, all fields. Returns:
195fa9e4066Sahrens * -1 (less than)
196fa9e4066Sahrens * 0 (equal)
197fa9e4066Sahrens * +1 (greater than)
198fa9e4066Sahrens */
199fa9e4066Sahrens int
cmp2acls(void * a,void * b)200fa9e4066Sahrens cmp2acls(void *a, void *b)
201fa9e4066Sahrens {
202fa9e4066Sahrens aclent_t *x = (aclent_t *)a;
203fa9e4066Sahrens aclent_t *y = (aclent_t *)b;
204fa9e4066Sahrens
205fa9e4066Sahrens /* Compare types */
206fa9e4066Sahrens if (x->a_type < y->a_type)
207fa9e4066Sahrens return (-1);
208fa9e4066Sahrens if (x->a_type > y->a_type)
209fa9e4066Sahrens return (1);
210fa9e4066Sahrens /* Equal types; compare id's */
211fa9e4066Sahrens if (x->a_id < y->a_id)
212fa9e4066Sahrens return (-1);
213fa9e4066Sahrens if (x->a_id > y->a_id)
214fa9e4066Sahrens return (1);
215fa9e4066Sahrens /* Equal ids; compare perms */
216fa9e4066Sahrens if (x->a_perm < y->a_perm)
217fa9e4066Sahrens return (-1);
218fa9e4066Sahrens if (x->a_perm > y->a_perm)
219fa9e4066Sahrens return (1);
220fa9e4066Sahrens /* Totally equal */
221fa9e4066Sahrens return (0);
222fa9e4066Sahrens }
223da6c28aaSamw
224da6c28aaSamw /*ARGSUSED*/
225da6c28aaSamw static void *
cacl_realloc(void * ptr,size_t size,size_t new_size)226da6c28aaSamw cacl_realloc(void *ptr, size_t size, size_t new_size)
227da6c28aaSamw {
228b819cea2SGordon Ross #if defined(_KERNEL) || defined(_FAKE_KERNEL)
229da6c28aaSamw void *tmp;
230da6c28aaSamw
231da6c28aaSamw tmp = kmem_alloc(new_size, KM_SLEEP);
232da6c28aaSamw (void) memcpy(tmp, ptr, (size < new_size) ? size : new_size);
233da6c28aaSamw kmem_free(ptr, size);
234da6c28aaSamw return (tmp);
235da6c28aaSamw #else
236da6c28aaSamw return (realloc(ptr, new_size));
237da6c28aaSamw #endif
238da6c28aaSamw }
239da6c28aaSamw
240da6c28aaSamw static int
cacl_malloc(void ** ptr,size_t size)241da6c28aaSamw cacl_malloc(void **ptr, size_t size)
242da6c28aaSamw {
243b819cea2SGordon Ross #if defined(_KERNEL) || defined(_FAKE_KERNEL)
244da6c28aaSamw *ptr = kmem_zalloc(size, KM_SLEEP);
245da6c28aaSamw return (0);
246da6c28aaSamw #else
247da6c28aaSamw *ptr = calloc(1, size);
248da6c28aaSamw if (*ptr == NULL)
249da6c28aaSamw return (errno);
250da6c28aaSamw
251da6c28aaSamw return (0);
252da6c28aaSamw #endif
253da6c28aaSamw }
254da6c28aaSamw
255da6c28aaSamw /*ARGSUSED*/
256da6c28aaSamw static void
cacl_free(void * ptr,size_t size)257da6c28aaSamw cacl_free(void *ptr, size_t size)
258da6c28aaSamw {
259b819cea2SGordon Ross #if defined(_KERNEL) || defined(_FAKE_KERNEL)
260da6c28aaSamw kmem_free(ptr, size);
261da6c28aaSamw #else
262da6c28aaSamw free(ptr);
263da6c28aaSamw #endif
264da6c28aaSamw }
265da6c28aaSamw
266da6c28aaSamw acl_t *
acl_alloc(enum acl_type type)267da6c28aaSamw acl_alloc(enum acl_type type)
268da6c28aaSamw {
269da6c28aaSamw acl_t *aclp;
270da6c28aaSamw
271da6c28aaSamw if (cacl_malloc((void **)&aclp, sizeof (acl_t)) != 0)
272da6c28aaSamw return (NULL);
273da6c28aaSamw
274da6c28aaSamw aclp->acl_aclp = NULL;
275da6c28aaSamw aclp->acl_cnt = 0;
276da6c28aaSamw
277da6c28aaSamw switch (type) {
278da6c28aaSamw case ACE_T:
279da6c28aaSamw aclp->acl_type = ACE_T;
280da6c28aaSamw aclp->acl_entry_size = sizeof (ace_t);
281da6c28aaSamw break;
282da6c28aaSamw case ACLENT_T:
283da6c28aaSamw aclp->acl_type = ACLENT_T;
284da6c28aaSamw aclp->acl_entry_size = sizeof (aclent_t);
285da6c28aaSamw break;
286da6c28aaSamw default:
287da6c28aaSamw acl_free(aclp);
288da6c28aaSamw aclp = NULL;
289da6c28aaSamw }
290da6c28aaSamw return (aclp);
291da6c28aaSamw }
292da6c28aaSamw
293da6c28aaSamw /*
294da6c28aaSamw * Free acl_t structure
295da6c28aaSamw */
296da6c28aaSamw void
acl_free(acl_t * aclp)297da6c28aaSamw acl_free(acl_t *aclp)
298da6c28aaSamw {
299da6c28aaSamw int acl_size;
300da6c28aaSamw
301da6c28aaSamw if (aclp == NULL)
302da6c28aaSamw return;
303da6c28aaSamw
304da6c28aaSamw if (aclp->acl_aclp) {
305da6c28aaSamw acl_size = aclp->acl_cnt * aclp->acl_entry_size;
306da6c28aaSamw cacl_free(aclp->acl_aclp, acl_size);
307da6c28aaSamw }
308da6c28aaSamw
309da6c28aaSamw cacl_free(aclp, sizeof (acl_t));
310da6c28aaSamw }
311da6c28aaSamw
312da6c28aaSamw static uint32_t
access_mask_set(int haswriteperm,int hasreadperm,int isowner,int isallow)313da6c28aaSamw access_mask_set(int haswriteperm, int hasreadperm, int isowner, int isallow)
314da6c28aaSamw {
315da6c28aaSamw uint32_t access_mask = 0;
316da6c28aaSamw int acl_produce;
317da6c28aaSamw int synchronize_set = 0, write_owner_set = 0;
318da6c28aaSamw int delete_set = 0, write_attrs_set = 0;
319da6c28aaSamw int read_named_set = 0, write_named_set = 0;
320da6c28aaSamw
321da6c28aaSamw acl_produce = (ACL_SYNCHRONIZE_SET_ALLOW |
322da6c28aaSamw ACL_WRITE_ATTRS_OWNER_SET_ALLOW |
323da6c28aaSamw ACL_WRITE_ATTRS_WRITER_SET_DENY);
324da6c28aaSamw
325da6c28aaSamw if (isallow) {
326da6c28aaSamw synchronize_set = ACL_SYNCHRONIZE_SET_ALLOW;
327da6c28aaSamw write_owner_set = ACL_WRITE_OWNER_SET_ALLOW;
328da6c28aaSamw delete_set = ACL_DELETE_SET_ALLOW;
329da6c28aaSamw if (hasreadperm)
330da6c28aaSamw read_named_set = ACL_READ_NAMED_READER_SET_ALLOW;
331da6c28aaSamw if (haswriteperm)
332da6c28aaSamw write_named_set = ACL_WRITE_NAMED_WRITER_SET_ALLOW;
333da6c28aaSamw if (isowner)
334da6c28aaSamw write_attrs_set = ACL_WRITE_ATTRS_OWNER_SET_ALLOW;
335da6c28aaSamw else if (haswriteperm)
336da6c28aaSamw write_attrs_set = ACL_WRITE_ATTRS_WRITER_SET_ALLOW;
337da6c28aaSamw } else {
338da6c28aaSamw
339da6c28aaSamw synchronize_set = ACL_SYNCHRONIZE_SET_DENY;
340da6c28aaSamw write_owner_set = ACL_WRITE_OWNER_SET_DENY;
341da6c28aaSamw delete_set = ACL_DELETE_SET_DENY;
342da6c28aaSamw if (hasreadperm)
343da6c28aaSamw read_named_set = ACL_READ_NAMED_READER_SET_DENY;
344da6c28aaSamw if (haswriteperm)
345da6c28aaSamw write_named_set = ACL_WRITE_NAMED_WRITER_SET_DENY;
346da6c28aaSamw if (isowner)
347da6c28aaSamw write_attrs_set = ACL_WRITE_ATTRS_OWNER_SET_DENY;
348da6c28aaSamw else if (haswriteperm)
349da6c28aaSamw write_attrs_set = ACL_WRITE_ATTRS_WRITER_SET_DENY;
350da6c28aaSamw else
351da6c28aaSamw /*
352da6c28aaSamw * If the entity is not the owner and does not
353da6c28aaSamw * have write permissions ACE_WRITE_ATTRIBUTES will
354da6c28aaSamw * always go in the DENY ACE.
355da6c28aaSamw */
356da6c28aaSamw access_mask |= ACE_WRITE_ATTRIBUTES;
357da6c28aaSamw }
358da6c28aaSamw
359da6c28aaSamw if (acl_produce & synchronize_set)
360da6c28aaSamw access_mask |= ACE_SYNCHRONIZE;
361da6c28aaSamw if (acl_produce & write_owner_set)
362da6c28aaSamw access_mask |= ACE_WRITE_OWNER;
363da6c28aaSamw if (acl_produce & delete_set)
364da6c28aaSamw access_mask |= ACE_DELETE;
365da6c28aaSamw if (acl_produce & write_attrs_set)
366da6c28aaSamw access_mask |= ACE_WRITE_ATTRIBUTES;
367da6c28aaSamw if (acl_produce & read_named_set)
368da6c28aaSamw access_mask |= ACE_READ_NAMED_ATTRS;
369da6c28aaSamw if (acl_produce & write_named_set)
370da6c28aaSamw access_mask |= ACE_WRITE_NAMED_ATTRS;
371da6c28aaSamw
372da6c28aaSamw return (access_mask);
373da6c28aaSamw }
374da6c28aaSamw
375da6c28aaSamw /*
376da6c28aaSamw * Given an mode_t, convert it into an access_mask as used
377da6c28aaSamw * by nfsace, assuming aclent_t -> nfsace semantics.
378da6c28aaSamw */
379da6c28aaSamw static uint32_t
mode_to_ace_access(mode_t mode,boolean_t isdir,int isowner,int isallow)380a3c49ce1SAlbert Lee mode_to_ace_access(mode_t mode, boolean_t isdir, int isowner, int isallow)
381da6c28aaSamw {
382da6c28aaSamw uint32_t access = 0;
383da6c28aaSamw int haswriteperm = 0;
384da6c28aaSamw int hasreadperm = 0;
385da6c28aaSamw
386da6c28aaSamw if (isallow) {
387da6c28aaSamw haswriteperm = (mode & S_IWOTH);
388da6c28aaSamw hasreadperm = (mode & S_IROTH);
389da6c28aaSamw } else {
390da6c28aaSamw haswriteperm = !(mode & S_IWOTH);
391da6c28aaSamw hasreadperm = !(mode & S_IROTH);
392da6c28aaSamw }
393da6c28aaSamw
394da6c28aaSamw /*
395da6c28aaSamw * The following call takes care of correctly setting the following
396da6c28aaSamw * mask bits in the access_mask:
397da6c28aaSamw * ACE_SYNCHRONIZE, ACE_WRITE_OWNER, ACE_DELETE,
398da6c28aaSamw * ACE_WRITE_ATTRIBUTES, ACE_WRITE_NAMED_ATTRS, ACE_READ_NAMED_ATTRS
399da6c28aaSamw */
400da6c28aaSamw access = access_mask_set(haswriteperm, hasreadperm, isowner, isallow);
401da6c28aaSamw
402da6c28aaSamw if (isallow) {
403da6c28aaSamw access |= ACE_READ_ACL | ACE_READ_ATTRIBUTES;
404da6c28aaSamw if (isowner)
405da6c28aaSamw access |= ACE_WRITE_ACL;
406da6c28aaSamw } else {
407da6c28aaSamw if (! isowner)
408da6c28aaSamw access |= ACE_WRITE_ACL;
409da6c28aaSamw }
410da6c28aaSamw
411da6c28aaSamw /* read */
412da6c28aaSamw if (mode & S_IROTH) {
413da6c28aaSamw access |= ACE_READ_DATA;
414da6c28aaSamw }
415da6c28aaSamw /* write */
416da6c28aaSamw if (mode & S_IWOTH) {
417da6c28aaSamw access |= ACE_WRITE_DATA |
418da6c28aaSamw ACE_APPEND_DATA;
419da6c28aaSamw if (isdir)
420da6c28aaSamw access |= ACE_DELETE_CHILD;
421da6c28aaSamw }
422da6c28aaSamw /* exec */
423a3c49ce1SAlbert Lee if (mode & S_IXOTH) {
424da6c28aaSamw access |= ACE_EXECUTE;
425da6c28aaSamw }
426da6c28aaSamw
427da6c28aaSamw return (access);
428da6c28aaSamw }
429da6c28aaSamw
430da6c28aaSamw /*
431da6c28aaSamw * Given an nfsace (presumably an ALLOW entry), make a
432da6c28aaSamw * corresponding DENY entry at the address given.
433da6c28aaSamw */
434da6c28aaSamw static void
ace_make_deny(ace_t * allow,ace_t * deny,int isdir,int isowner)435da6c28aaSamw ace_make_deny(ace_t *allow, ace_t *deny, int isdir, int isowner)
436da6c28aaSamw {
437da6c28aaSamw (void) memcpy(deny, allow, sizeof (ace_t));
438da6c28aaSamw
439da6c28aaSamw deny->a_who = allow->a_who;
440da6c28aaSamw
441da6c28aaSamw deny->a_type = ACE_ACCESS_DENIED_ACE_TYPE;
442da6c28aaSamw deny->a_access_mask ^= ACE_POSIX_SUPPORTED_BITS;
443da6c28aaSamw if (isdir)
444da6c28aaSamw deny->a_access_mask ^= ACE_DELETE_CHILD;
445da6c28aaSamw
446da6c28aaSamw deny->a_access_mask &= ~(ACE_SYNCHRONIZE | ACE_WRITE_OWNER |
447da6c28aaSamw ACE_DELETE | ACE_WRITE_ATTRIBUTES | ACE_READ_NAMED_ATTRS |
448da6c28aaSamw ACE_WRITE_NAMED_ATTRS);
449da6c28aaSamw deny->a_access_mask |= access_mask_set((allow->a_access_mask &
450da6c28aaSamw ACE_WRITE_DATA), (allow->a_access_mask & ACE_READ_DATA), isowner,
451da6c28aaSamw B_FALSE);
452da6c28aaSamw }
453da6c28aaSamw /*
454da6c28aaSamw * Make an initial pass over an array of aclent_t's. Gather
455da6c28aaSamw * information such as an ACL_MASK (if any), number of users,
456da6c28aaSamw * number of groups, and whether the array needs to be sorted.
457da6c28aaSamw */
458da6c28aaSamw static int
ln_aent_preprocess(aclent_t * aclent,int n,int * hasmask,mode_t * mask,int * numuser,int * numgroup,int * needsort)459da6c28aaSamw ln_aent_preprocess(aclent_t *aclent, int n,
460da6c28aaSamw int *hasmask, mode_t *mask,
461da6c28aaSamw int *numuser, int *numgroup, int *needsort)
462da6c28aaSamw {
463da6c28aaSamw int error = 0;
464da6c28aaSamw int i;
465da6c28aaSamw int curtype = 0;
466da6c28aaSamw
467da6c28aaSamw *hasmask = 0;
468da6c28aaSamw *mask = 07;
469da6c28aaSamw *needsort = 0;
470da6c28aaSamw *numuser = 0;
471da6c28aaSamw *numgroup = 0;
472da6c28aaSamw
473da6c28aaSamw for (i = 0; i < n; i++) {
474da6c28aaSamw if (aclent[i].a_type < curtype)
475da6c28aaSamw *needsort = 1;
476da6c28aaSamw else if (aclent[i].a_type > curtype)
477da6c28aaSamw curtype = aclent[i].a_type;
478da6c28aaSamw if (aclent[i].a_type & USER)
479da6c28aaSamw (*numuser)++;
480da6c28aaSamw if (aclent[i].a_type & (GROUP | GROUP_OBJ))
481da6c28aaSamw (*numgroup)++;
482da6c28aaSamw if (aclent[i].a_type & CLASS_OBJ) {
483da6c28aaSamw if (*hasmask) {
484da6c28aaSamw error = EINVAL;
485da6c28aaSamw goto out;
486da6c28aaSamw } else {
487da6c28aaSamw *hasmask = 1;
488da6c28aaSamw *mask = aclent[i].a_perm;
489da6c28aaSamw }
490da6c28aaSamw }
491da6c28aaSamw }
492da6c28aaSamw
493da6c28aaSamw if ((! *hasmask) && (*numuser + *numgroup > 1)) {
494da6c28aaSamw error = EINVAL;
495da6c28aaSamw goto out;
496da6c28aaSamw }
497da6c28aaSamw
498da6c28aaSamw out:
499da6c28aaSamw return (error);
500da6c28aaSamw }
501da6c28aaSamw
502da6c28aaSamw /*
503da6c28aaSamw * Convert an array of aclent_t into an array of nfsace entries,
504da6c28aaSamw * following POSIX draft -> nfsv4 conversion semantics as outlined in
505da6c28aaSamw * the IETF draft.
506da6c28aaSamw */
507da6c28aaSamw static int
ln_aent_to_ace(aclent_t * aclent,int n,ace_t ** acepp,int * rescount,int isdir)508da6c28aaSamw ln_aent_to_ace(aclent_t *aclent, int n, ace_t **acepp, int *rescount, int isdir)
509da6c28aaSamw {
510da6c28aaSamw int error = 0;
511da6c28aaSamw mode_t mask;
512da6c28aaSamw int numuser, numgroup, needsort;
513da6c28aaSamw int resultsize = 0;
514da6c28aaSamw int i, groupi = 0, skip;
515da6c28aaSamw ace_t *acep, *result = NULL;
516da6c28aaSamw int hasmask;
517da6c28aaSamw
518da6c28aaSamw error = ln_aent_preprocess(aclent, n, &hasmask, &mask,
519da6c28aaSamw &numuser, &numgroup, &needsort);
520da6c28aaSamw if (error != 0)
521da6c28aaSamw goto out;
522da6c28aaSamw
523da6c28aaSamw /* allow + deny for each aclent */
524da6c28aaSamw resultsize = n * 2;
525da6c28aaSamw if (hasmask) {
526da6c28aaSamw /*
527da6c28aaSamw * stick extra deny on the group_obj and on each
528da6c28aaSamw * user|group for the mask (the group_obj was added
529da6c28aaSamw * into the count for numgroup)
530da6c28aaSamw */
531da6c28aaSamw resultsize += numuser + numgroup;
532da6c28aaSamw /* ... and don't count the mask itself */
533da6c28aaSamw resultsize -= 2;
534da6c28aaSamw }
535da6c28aaSamw
536da6c28aaSamw /* sort the source if necessary */
537da6c28aaSamw if (needsort)
538da6c28aaSamw ksort((caddr_t)aclent, n, sizeof (aclent_t), cmp2acls);
539da6c28aaSamw
540da6c28aaSamw if (cacl_malloc((void **)&result, resultsize * sizeof (ace_t)) != 0)
541da6c28aaSamw goto out;
542da6c28aaSamw
543da6c28aaSamw acep = result;
544da6c28aaSamw
545da6c28aaSamw for (i = 0; i < n; i++) {
546da6c28aaSamw /*
547da6c28aaSamw * don't process CLASS_OBJ (mask); mask was grabbed in
548da6c28aaSamw * ln_aent_preprocess()
549da6c28aaSamw */
550da6c28aaSamw if (aclent[i].a_type & CLASS_OBJ)
551da6c28aaSamw continue;
552da6c28aaSamw
553da6c28aaSamw /* If we need an ACL_MASK emulator, prepend it now */
554da6c28aaSamw if ((hasmask) &&
555da6c28aaSamw (aclent[i].a_type & (USER | GROUP | GROUP_OBJ))) {
556da6c28aaSamw acep->a_type = ACE_ACCESS_DENIED_ACE_TYPE;
557da6c28aaSamw acep->a_flags = 0;
558da6c28aaSamw if (aclent[i].a_type & GROUP_OBJ) {
559da6c28aaSamw acep->a_who = (uid_t)-1;
560da6c28aaSamw acep->a_flags |=
561da6c28aaSamw (ACE_IDENTIFIER_GROUP|ACE_GROUP);
562da6c28aaSamw } else if (aclent[i].a_type & USER) {
563da6c28aaSamw acep->a_who = aclent[i].a_id;
564da6c28aaSamw } else {
565da6c28aaSamw acep->a_who = aclent[i].a_id;
566da6c28aaSamw acep->a_flags |= ACE_IDENTIFIER_GROUP;
567da6c28aaSamw }
568da6c28aaSamw if (aclent[i].a_type & ACL_DEFAULT) {
569da6c28aaSamw acep->a_flags |= ACE_INHERIT_ONLY_ACE |
570da6c28aaSamw ACE_FILE_INHERIT_ACE |
571da6c28aaSamw ACE_DIRECTORY_INHERIT_ACE;
572da6c28aaSamw }
573da6c28aaSamw /*
574da6c28aaSamw * Set the access mask for the prepended deny
575da6c28aaSamw * ace. To do this, we invert the mask (found
576da6c28aaSamw * in ln_aent_preprocess()) then convert it to an
577da6c28aaSamw * DENY ace access_mask.
578da6c28aaSamw */
579da6c28aaSamw acep->a_access_mask = mode_to_ace_access((mask ^ 07),
580da6c28aaSamw isdir, 0, 0);
581da6c28aaSamw acep += 1;
582da6c28aaSamw }
583da6c28aaSamw
584da6c28aaSamw /* handle a_perm -> access_mask */
585da6c28aaSamw acep->a_access_mask = mode_to_ace_access(aclent[i].a_perm,
586da6c28aaSamw isdir, aclent[i].a_type & USER_OBJ, 1);
587da6c28aaSamw
588da6c28aaSamw /* emulate a default aclent */
589da6c28aaSamw if (aclent[i].a_type & ACL_DEFAULT) {
590da6c28aaSamw acep->a_flags |= ACE_INHERIT_ONLY_ACE |
591da6c28aaSamw ACE_FILE_INHERIT_ACE |
592da6c28aaSamw ACE_DIRECTORY_INHERIT_ACE;
593da6c28aaSamw }
594da6c28aaSamw
595da6c28aaSamw /*
596da6c28aaSamw * handle a_perm and a_id
597da6c28aaSamw *
598da6c28aaSamw * this must be done last, since it involves the
599da6c28aaSamw * corresponding deny aces, which are handled
600da6c28aaSamw * differently for each different a_type.
601da6c28aaSamw */
602da6c28aaSamw if (aclent[i].a_type & USER_OBJ) {
603da6c28aaSamw acep->a_who = (uid_t)-1;
604da6c28aaSamw acep->a_flags |= ACE_OWNER;
605da6c28aaSamw ace_make_deny(acep, acep + 1, isdir, B_TRUE);
606da6c28aaSamw acep += 2;
607da6c28aaSamw } else if (aclent[i].a_type & USER) {
608da6c28aaSamw acep->a_who = aclent[i].a_id;
609da6c28aaSamw ace_make_deny(acep, acep + 1, isdir, B_FALSE);
610da6c28aaSamw acep += 2;
611da6c28aaSamw } else if (aclent[i].a_type & (GROUP_OBJ | GROUP)) {
612da6c28aaSamw if (aclent[i].a_type & GROUP_OBJ) {
613da6c28aaSamw acep->a_who = (uid_t)-1;
614da6c28aaSamw acep->a_flags |= ACE_GROUP;
615da6c28aaSamw } else {
616da6c28aaSamw acep->a_who = aclent[i].a_id;
617da6c28aaSamw }
618da6c28aaSamw acep->a_flags |= ACE_IDENTIFIER_GROUP;
619da6c28aaSamw /*
620da6c28aaSamw * Set the corresponding deny for the group ace.
621da6c28aaSamw *
622da6c28aaSamw * The deny aces go after all of the groups, unlike
623da6c28aaSamw * everything else, where they immediately follow
624da6c28aaSamw * the allow ace.
625da6c28aaSamw *
626da6c28aaSamw * We calculate "skip", the number of slots to
627da6c28aaSamw * skip ahead for the deny ace, here.
628da6c28aaSamw *
629da6c28aaSamw * The pattern is:
630da6c28aaSamw * MD1 A1 MD2 A2 MD3 A3 D1 D2 D3
631da6c28aaSamw * thus, skip is
632da6c28aaSamw * (2 * numgroup) - 1 - groupi
633da6c28aaSamw * (2 * numgroup) to account for MD + A
634da6c28aaSamw * - 1 to account for the fact that we're on the
635da6c28aaSamw * access (A), not the mask (MD)
636da6c28aaSamw * - groupi to account for the fact that we have
637da6c28aaSamw * passed up groupi number of MD's.
638da6c28aaSamw */
639da6c28aaSamw skip = (2 * numgroup) - 1 - groupi;
640da6c28aaSamw ace_make_deny(acep, acep + skip, isdir, B_FALSE);
641da6c28aaSamw /*
642da6c28aaSamw * If we just did the last group, skip acep past
643da6c28aaSamw * all of the denies; else, just move ahead one.
644da6c28aaSamw */
645da6c28aaSamw if (++groupi >= numgroup)
646da6c28aaSamw acep += numgroup + 1;
647da6c28aaSamw else
648da6c28aaSamw acep += 1;
649da6c28aaSamw } else if (aclent[i].a_type & OTHER_OBJ) {
650da6c28aaSamw acep->a_who = (uid_t)-1;
651da6c28aaSamw acep->a_flags |= ACE_EVERYONE;
652da6c28aaSamw ace_make_deny(acep, acep + 1, isdir, B_FALSE);
653da6c28aaSamw acep += 2;
654da6c28aaSamw } else {
655da6c28aaSamw error = EINVAL;
656da6c28aaSamw goto out;
657da6c28aaSamw }
658da6c28aaSamw }
659da6c28aaSamw
660da6c28aaSamw *acepp = result;
661da6c28aaSamw *rescount = resultsize;
662da6c28aaSamw
663da6c28aaSamw out:
664da6c28aaSamw if (error != 0) {
665da6c28aaSamw if ((result != NULL) && (resultsize > 0)) {
666da6c28aaSamw cacl_free(result, resultsize * sizeof (ace_t));
667da6c28aaSamw }
668da6c28aaSamw }
669da6c28aaSamw
670da6c28aaSamw return (error);
671da6c28aaSamw }
672da6c28aaSamw
673da6c28aaSamw static int
convert_aent_to_ace(aclent_t * aclentp,int aclcnt,boolean_t isdir,ace_t ** retacep,int * retacecnt)674a3c49ce1SAlbert Lee convert_aent_to_ace(aclent_t *aclentp, int aclcnt, boolean_t isdir,
675da6c28aaSamw ace_t **retacep, int *retacecnt)
676da6c28aaSamw {
677da6c28aaSamw ace_t *acep;
678da6c28aaSamw ace_t *dfacep;
679da6c28aaSamw int acecnt = 0;
680da6c28aaSamw int dfacecnt = 0;
681da6c28aaSamw int dfaclstart = 0;
682da6c28aaSamw int dfaclcnt = 0;
683da6c28aaSamw aclent_t *aclp;
684da6c28aaSamw int i;
685da6c28aaSamw int error;
686da6c28aaSamw int acesz, dfacesz;
687da6c28aaSamw
688da6c28aaSamw ksort((caddr_t)aclentp, aclcnt, sizeof (aclent_t), cmp2acls);
689da6c28aaSamw
690da6c28aaSamw for (i = 0, aclp = aclentp; i < aclcnt; aclp++, i++) {
691da6c28aaSamw if (aclp->a_type & ACL_DEFAULT)
692da6c28aaSamw break;
693da6c28aaSamw }
694da6c28aaSamw
695da6c28aaSamw if (i < aclcnt) {
696da6c28aaSamw dfaclstart = i;
697da6c28aaSamw dfaclcnt = aclcnt - i;
698da6c28aaSamw }
699da6c28aaSamw
700a3c49ce1SAlbert Lee if (dfaclcnt && !isdir) {
701da6c28aaSamw return (EINVAL);
702da6c28aaSamw }
703da6c28aaSamw
704da6c28aaSamw error = ln_aent_to_ace(aclentp, i, &acep, &acecnt, isdir);
705da6c28aaSamw if (error)
706da6c28aaSamw return (error);
707da6c28aaSamw
708da6c28aaSamw if (dfaclcnt) {
709da6c28aaSamw error = ln_aent_to_ace(&aclentp[dfaclstart], dfaclcnt,
710da6c28aaSamw &dfacep, &dfacecnt, isdir);
711da6c28aaSamw if (error) {
712da6c28aaSamw if (acep) {
713da6c28aaSamw cacl_free(acep, acecnt * sizeof (ace_t));
714da6c28aaSamw }
715da6c28aaSamw return (error);
716da6c28aaSamw }
717da6c28aaSamw }
718da6c28aaSamw
719da6c28aaSamw if (dfacecnt != 0) {
720da6c28aaSamw acesz = sizeof (ace_t) * acecnt;
721da6c28aaSamw dfacesz = sizeof (ace_t) * dfacecnt;
722da6c28aaSamw acep = cacl_realloc(acep, acesz, acesz + dfacesz);
723da6c28aaSamw if (acep == NULL)
724da6c28aaSamw return (ENOMEM);
725da6c28aaSamw if (dfaclcnt) {
726da6c28aaSamw (void) memcpy(acep + acecnt, dfacep, dfacesz);
727da6c28aaSamw }
728da6c28aaSamw }
729da6c28aaSamw if (dfaclcnt)
730da6c28aaSamw cacl_free(dfacep, dfacecnt * sizeof (ace_t));
731da6c28aaSamw
732da6c28aaSamw *retacecnt = acecnt + dfacecnt;
733da6c28aaSamw *retacep = acep;
734da6c28aaSamw return (0);
735da6c28aaSamw }
736da6c28aaSamw
737da6c28aaSamw static int
ace_mask_to_mode(uint32_t mask,o_mode_t * modep,boolean_t isdir)738a3c49ce1SAlbert Lee ace_mask_to_mode(uint32_t mask, o_mode_t *modep, boolean_t isdir)
739da6c28aaSamw {
740da6c28aaSamw int error = 0;
741da6c28aaSamw o_mode_t mode = 0;
742da6c28aaSamw uint32_t bits, wantbits;
743da6c28aaSamw
744da6c28aaSamw /* read */
745da6c28aaSamw if (mask & ACE_READ_DATA)
746da6c28aaSamw mode |= S_IROTH;
747da6c28aaSamw
748da6c28aaSamw /* write */
749da6c28aaSamw wantbits = (ACE_WRITE_DATA | ACE_APPEND_DATA);
750da6c28aaSamw if (isdir)
751da6c28aaSamw wantbits |= ACE_DELETE_CHILD;
752da6c28aaSamw bits = mask & wantbits;
753da6c28aaSamw if (bits != 0) {
754da6c28aaSamw if (bits != wantbits) {
755da6c28aaSamw error = ENOTSUP;
756da6c28aaSamw goto out;
757da6c28aaSamw }
758da6c28aaSamw mode |= S_IWOTH;
759da6c28aaSamw }
760da6c28aaSamw
761da6c28aaSamw /* exec */
762da6c28aaSamw if (mask & ACE_EXECUTE) {
763da6c28aaSamw mode |= S_IXOTH;
764da6c28aaSamw }
765da6c28aaSamw
766da6c28aaSamw *modep = mode;
767da6c28aaSamw
768da6c28aaSamw out:
769da6c28aaSamw return (error);
770da6c28aaSamw }
771da6c28aaSamw
772da6c28aaSamw static void
acevals_init(acevals_t * vals,uid_t key)773da6c28aaSamw acevals_init(acevals_t *vals, uid_t key)
774da6c28aaSamw {
775da6c28aaSamw bzero(vals, sizeof (*vals));
776da6c28aaSamw vals->allowed = ACE_MASK_UNDEFINED;
777da6c28aaSamw vals->denied = ACE_MASK_UNDEFINED;
778da6c28aaSamw vals->mask = ACE_MASK_UNDEFINED;
779da6c28aaSamw vals->key = key;
780da6c28aaSamw }
781da6c28aaSamw
782da6c28aaSamw static void
ace_list_init(ace_list_t * al,int dfacl_flag)783da6c28aaSamw ace_list_init(ace_list_t *al, int dfacl_flag)
784da6c28aaSamw {
7857e12ceb3SToomas Soome acevals_init(&al->user_obj, 0);
7867e12ceb3SToomas Soome acevals_init(&al->group_obj, 0);
7877e12ceb3SToomas Soome acevals_init(&al->other_obj, 0);
788da6c28aaSamw al->numusers = 0;
789da6c28aaSamw al->numgroups = 0;
790da6c28aaSamw al->acl_mask = 0;
791da6c28aaSamw al->hasmask = 0;
792da6c28aaSamw al->state = ace_unused;
793da6c28aaSamw al->seen = 0;
794da6c28aaSamw al->dfacl_flag = dfacl_flag;
795da6c28aaSamw }
796da6c28aaSamw
797da6c28aaSamw /*
798da6c28aaSamw * Find or create an acevals holder for a given id and avl tree.
799da6c28aaSamw *
800da6c28aaSamw * Note that only one thread will ever touch these avl trees, so
801da6c28aaSamw * there is no need for locking.
802da6c28aaSamw */
803da6c28aaSamw static acevals_t *
acevals_find(ace_t * ace,avl_tree_t * avl,int * num)804da6c28aaSamw acevals_find(ace_t *ace, avl_tree_t *avl, int *num)
805da6c28aaSamw {
806da6c28aaSamw acevals_t key, *rc;
807da6c28aaSamw avl_index_t where;
808da6c28aaSamw
809da6c28aaSamw key.key = ace->a_who;
810da6c28aaSamw rc = avl_find(avl, &key, &where);
811da6c28aaSamw if (rc != NULL)
812da6c28aaSamw return (rc);
813da6c28aaSamw
814da6c28aaSamw /* this memory is freed by ln_ace_to_aent()->ace_list_free() */
815da6c28aaSamw if (cacl_malloc((void **)&rc, sizeof (acevals_t)) != 0)
816da6c28aaSamw return (NULL);
817da6c28aaSamw
818da6c28aaSamw acevals_init(rc, ace->a_who);
819da6c28aaSamw avl_insert(avl, rc, where);
820da6c28aaSamw (*num)++;
821da6c28aaSamw
822da6c28aaSamw return (rc);
823da6c28aaSamw }
824da6c28aaSamw
825da6c28aaSamw static int
access_mask_check(ace_t * acep,int mask_bit,int isowner)826da6c28aaSamw access_mask_check(ace_t *acep, int mask_bit, int isowner)
827da6c28aaSamw {
828da6c28aaSamw int set_deny, err_deny;
829da6c28aaSamw int set_allow, err_allow;
830da6c28aaSamw int acl_consume;
831da6c28aaSamw int haswriteperm, hasreadperm;
832da6c28aaSamw
833da6c28aaSamw if (acep->a_type == ACE_ACCESS_DENIED_ACE_TYPE) {
834da6c28aaSamw haswriteperm = (acep->a_access_mask & ACE_WRITE_DATA) ? 0 : 1;
835da6c28aaSamw hasreadperm = (acep->a_access_mask & ACE_READ_DATA) ? 0 : 1;
836da6c28aaSamw } else {
837da6c28aaSamw haswriteperm = (acep->a_access_mask & ACE_WRITE_DATA) ? 1 : 0;
838da6c28aaSamw hasreadperm = (acep->a_access_mask & ACE_READ_DATA) ? 1 : 0;
839da6c28aaSamw }
840da6c28aaSamw
841da6c28aaSamw acl_consume = (ACL_SYNCHRONIZE_ERR_DENY |
842da6c28aaSamw ACL_DELETE_ERR_DENY |
843da6c28aaSamw ACL_WRITE_OWNER_ERR_DENY |
844da6c28aaSamw ACL_WRITE_OWNER_ERR_ALLOW |
845da6c28aaSamw ACL_WRITE_ATTRS_OWNER_SET_ALLOW |
846da6c28aaSamw ACL_WRITE_ATTRS_OWNER_ERR_DENY |
847da6c28aaSamw ACL_WRITE_ATTRS_WRITER_SET_DENY |
848da6c28aaSamw ACL_WRITE_ATTRS_WRITER_ERR_ALLOW |
849da6c28aaSamw ACL_WRITE_NAMED_WRITER_ERR_DENY |
850da6c28aaSamw ACL_READ_NAMED_READER_ERR_DENY);
851da6c28aaSamw
852da6c28aaSamw if (mask_bit == ACE_SYNCHRONIZE) {
853da6c28aaSamw set_deny = ACL_SYNCHRONIZE_SET_DENY;
854da6c28aaSamw err_deny = ACL_SYNCHRONIZE_ERR_DENY;
855da6c28aaSamw set_allow = ACL_SYNCHRONIZE_SET_ALLOW;
856da6c28aaSamw err_allow = ACL_SYNCHRONIZE_ERR_ALLOW;
857da6c28aaSamw } else if (mask_bit == ACE_WRITE_OWNER) {
858da6c28aaSamw set_deny = ACL_WRITE_OWNER_SET_DENY;
859da6c28aaSamw err_deny = ACL_WRITE_OWNER_ERR_DENY;
860da6c28aaSamw set_allow = ACL_WRITE_OWNER_SET_ALLOW;
861da6c28aaSamw err_allow = ACL_WRITE_OWNER_ERR_ALLOW;
862da6c28aaSamw } else if (mask_bit == ACE_DELETE) {
863da6c28aaSamw set_deny = ACL_DELETE_SET_DENY;
864da6c28aaSamw err_deny = ACL_DELETE_ERR_DENY;
865da6c28aaSamw set_allow = ACL_DELETE_SET_ALLOW;
866da6c28aaSamw err_allow = ACL_DELETE_ERR_ALLOW;
867da6c28aaSamw } else if (mask_bit == ACE_WRITE_ATTRIBUTES) {
868da6c28aaSamw if (isowner) {
869da6c28aaSamw set_deny = ACL_WRITE_ATTRS_OWNER_SET_DENY;
870da6c28aaSamw err_deny = ACL_WRITE_ATTRS_OWNER_ERR_DENY;
871da6c28aaSamw set_allow = ACL_WRITE_ATTRS_OWNER_SET_ALLOW;
872da6c28aaSamw err_allow = ACL_WRITE_ATTRS_OWNER_ERR_ALLOW;
873da6c28aaSamw } else if (haswriteperm) {
874da6c28aaSamw set_deny = ACL_WRITE_ATTRS_WRITER_SET_DENY;
875da6c28aaSamw err_deny = ACL_WRITE_ATTRS_WRITER_ERR_DENY;
876da6c28aaSamw set_allow = ACL_WRITE_ATTRS_WRITER_SET_ALLOW;
877da6c28aaSamw err_allow = ACL_WRITE_ATTRS_WRITER_ERR_ALLOW;
878da6c28aaSamw } else {
879ef9416a8SToomas Soome if (((acep->a_access_mask & mask_bit) != 0) &&
880ef9416a8SToomas Soome (acep->a_type == ACE_ACCESS_ALLOWED_ACE_TYPE)) {
881da6c28aaSamw return (ENOTSUP);
882da6c28aaSamw }
883da6c28aaSamw return (0);
884da6c28aaSamw }
885da6c28aaSamw } else if (mask_bit == ACE_READ_NAMED_ATTRS) {
886da6c28aaSamw if (!hasreadperm)
887da6c28aaSamw return (0);
888da6c28aaSamw
889da6c28aaSamw set_deny = ACL_READ_NAMED_READER_SET_DENY;
890da6c28aaSamw err_deny = ACL_READ_NAMED_READER_ERR_DENY;
891da6c28aaSamw set_allow = ACL_READ_NAMED_READER_SET_ALLOW;
892da6c28aaSamw err_allow = ACL_READ_NAMED_READER_ERR_ALLOW;
893da6c28aaSamw } else if (mask_bit == ACE_WRITE_NAMED_ATTRS) {
894da6c28aaSamw if (!haswriteperm)
895da6c28aaSamw return (0);
896da6c28aaSamw
897da6c28aaSamw set_deny = ACL_WRITE_NAMED_WRITER_SET_DENY;
898da6c28aaSamw err_deny = ACL_WRITE_NAMED_WRITER_ERR_DENY;
899da6c28aaSamw set_allow = ACL_WRITE_NAMED_WRITER_SET_ALLOW;
900da6c28aaSamw err_allow = ACL_WRITE_NAMED_WRITER_ERR_ALLOW;
901da6c28aaSamw } else {
902da6c28aaSamw return (EINVAL);
903da6c28aaSamw }
904da6c28aaSamw
905da6c28aaSamw if (acep->a_type == ACE_ACCESS_DENIED_ACE_TYPE) {
906da6c28aaSamw if (acl_consume & set_deny) {
907da6c28aaSamw if (!(acep->a_access_mask & mask_bit)) {
908da6c28aaSamw return (ENOTSUP);
909da6c28aaSamw }
910da6c28aaSamw } else if (acl_consume & err_deny) {
911da6c28aaSamw if (acep->a_access_mask & mask_bit) {
912da6c28aaSamw return (ENOTSUP);
913da6c28aaSamw }
914da6c28aaSamw }
915da6c28aaSamw } else {
916da6c28aaSamw /* ACE_ACCESS_ALLOWED_ACE_TYPE */
917da6c28aaSamw if (acl_consume & set_allow) {
918da6c28aaSamw if (!(acep->a_access_mask & mask_bit)) {
919da6c28aaSamw return (ENOTSUP);
920da6c28aaSamw }
921da6c28aaSamw } else if (acl_consume & err_allow) {
922da6c28aaSamw if (acep->a_access_mask & mask_bit) {
923da6c28aaSamw return (ENOTSUP);
924da6c28aaSamw }
925da6c28aaSamw }
926da6c28aaSamw }
927da6c28aaSamw return (0);
928da6c28aaSamw }
929da6c28aaSamw
930da6c28aaSamw static int
ace_to_aent_legal(ace_t * acep)931da6c28aaSamw ace_to_aent_legal(ace_t *acep)
932da6c28aaSamw {
933da6c28aaSamw int error = 0;
934da6c28aaSamw int isowner;
935da6c28aaSamw
936da6c28aaSamw /* only ALLOW or DENY */
937da6c28aaSamw if ((acep->a_type != ACE_ACCESS_ALLOWED_ACE_TYPE) &&
938da6c28aaSamw (acep->a_type != ACE_ACCESS_DENIED_ACE_TYPE)) {
939da6c28aaSamw error = ENOTSUP;
940da6c28aaSamw goto out;
941da6c28aaSamw }
942da6c28aaSamw
943da6c28aaSamw /* check for invalid flags */
944da6c28aaSamw if (acep->a_flags & ~(ACE_VALID_FLAG_BITS)) {
945da6c28aaSamw error = EINVAL;
946da6c28aaSamw goto out;
947da6c28aaSamw }
948da6c28aaSamw
949da6c28aaSamw /* some flags are illegal */
950da6c28aaSamw if (acep->a_flags & (ACE_SUCCESSFUL_ACCESS_ACE_FLAG |
951da6c28aaSamw ACE_FAILED_ACCESS_ACE_FLAG |
952da6c28aaSamw ACE_NO_PROPAGATE_INHERIT_ACE)) {
953da6c28aaSamw error = ENOTSUP;
954da6c28aaSamw goto out;
955da6c28aaSamw }
956da6c28aaSamw
957da6c28aaSamw /* check for invalid masks */
958da6c28aaSamw if (acep->a_access_mask & ~(ACE_VALID_MASK_BITS)) {
959da6c28aaSamw error = EINVAL;
960da6c28aaSamw goto out;
961da6c28aaSamw }
962da6c28aaSamw
963da6c28aaSamw if ((acep->a_flags & ACE_OWNER)) {
964da6c28aaSamw isowner = 1;
965da6c28aaSamw } else {
966da6c28aaSamw isowner = 0;
967da6c28aaSamw }
968da6c28aaSamw
969da6c28aaSamw error = access_mask_check(acep, ACE_SYNCHRONIZE, isowner);
970da6c28aaSamw if (error)
971da6c28aaSamw goto out;
972da6c28aaSamw
973da6c28aaSamw error = access_mask_check(acep, ACE_WRITE_OWNER, isowner);
974da6c28aaSamw if (error)
975da6c28aaSamw goto out;
976da6c28aaSamw
977da6c28aaSamw error = access_mask_check(acep, ACE_DELETE, isowner);
978da6c28aaSamw if (error)
979da6c28aaSamw goto out;
980da6c28aaSamw
981da6c28aaSamw error = access_mask_check(acep, ACE_WRITE_ATTRIBUTES, isowner);
982da6c28aaSamw if (error)
983da6c28aaSamw goto out;
984da6c28aaSamw
985da6c28aaSamw error = access_mask_check(acep, ACE_READ_NAMED_ATTRS, isowner);
986da6c28aaSamw if (error)
987da6c28aaSamw goto out;
988da6c28aaSamw
989da6c28aaSamw error = access_mask_check(acep, ACE_WRITE_NAMED_ATTRS, isowner);
990da6c28aaSamw if (error)
991da6c28aaSamw goto out;
992da6c28aaSamw
993da6c28aaSamw /* more detailed checking of masks */
994da6c28aaSamw if (acep->a_type == ACE_ACCESS_ALLOWED_ACE_TYPE) {
995da6c28aaSamw if (! (acep->a_access_mask & ACE_READ_ATTRIBUTES)) {
996da6c28aaSamw error = ENOTSUP;
997da6c28aaSamw goto out;
998da6c28aaSamw }
999da6c28aaSamw if ((acep->a_access_mask & ACE_WRITE_DATA) &&
1000da6c28aaSamw (! (acep->a_access_mask & ACE_APPEND_DATA))) {
1001da6c28aaSamw error = ENOTSUP;
1002da6c28aaSamw goto out;
1003da6c28aaSamw }
1004da6c28aaSamw if ((! (acep->a_access_mask & ACE_WRITE_DATA)) &&
1005da6c28aaSamw (acep->a_access_mask & ACE_APPEND_DATA)) {
1006da6c28aaSamw error = ENOTSUP;
1007da6c28aaSamw goto out;
1008da6c28aaSamw }
1009da6c28aaSamw }
1010da6c28aaSamw
1011da6c28aaSamw /* ACL enforcement */
1012da6c28aaSamw if ((acep->a_access_mask & ACE_READ_ACL) &&
1013da6c28aaSamw (acep->a_type != ACE_ACCESS_ALLOWED_ACE_TYPE)) {
1014da6c28aaSamw error = ENOTSUP;
1015da6c28aaSamw goto out;
1016da6c28aaSamw }
1017da6c28aaSamw if (acep->a_access_mask & ACE_WRITE_ACL) {
1018da6c28aaSamw if ((acep->a_type == ACE_ACCESS_DENIED_ACE_TYPE) &&
1019da6c28aaSamw (isowner)) {
1020da6c28aaSamw error = ENOTSUP;
1021da6c28aaSamw goto out;
1022da6c28aaSamw }
1023da6c28aaSamw if ((acep->a_type == ACE_ACCESS_ALLOWED_ACE_TYPE) &&
1024da6c28aaSamw (! isowner)) {
1025da6c28aaSamw error = ENOTSUP;
1026da6c28aaSamw goto out;
1027da6c28aaSamw }
1028da6c28aaSamw }
1029da6c28aaSamw
1030da6c28aaSamw out:
1031da6c28aaSamw return (error);
1032da6c28aaSamw }
1033da6c28aaSamw
1034da6c28aaSamw static int
ace_allow_to_mode(uint32_t mask,o_mode_t * modep,boolean_t isdir)1035a3c49ce1SAlbert Lee ace_allow_to_mode(uint32_t mask, o_mode_t *modep, boolean_t isdir)
1036da6c28aaSamw {
1037da6c28aaSamw /* ACE_READ_ACL and ACE_READ_ATTRIBUTES must both be set */
1038da6c28aaSamw if ((mask & (ACE_READ_ACL | ACE_READ_ATTRIBUTES)) !=
1039da6c28aaSamw (ACE_READ_ACL | ACE_READ_ATTRIBUTES)) {
1040da6c28aaSamw return (ENOTSUP);
1041da6c28aaSamw }
1042da6c28aaSamw
1043da6c28aaSamw return (ace_mask_to_mode(mask, modep, isdir));
1044da6c28aaSamw }
1045da6c28aaSamw
1046da6c28aaSamw static int
acevals_to_aent(acevals_t * vals,aclent_t * dest,ace_list_t * list,uid_t owner,gid_t group,boolean_t isdir)1047da6c28aaSamw acevals_to_aent(acevals_t *vals, aclent_t *dest, ace_list_t *list,
1048a3c49ce1SAlbert Lee uid_t owner, gid_t group, boolean_t isdir)
1049da6c28aaSamw {
1050da6c28aaSamw int error;
1051da6c28aaSamw uint32_t flips = ACE_POSIX_SUPPORTED_BITS;
1052da6c28aaSamw
1053da6c28aaSamw if (isdir)
1054da6c28aaSamw flips |= ACE_DELETE_CHILD;
1055da6c28aaSamw if (vals->allowed != (vals->denied ^ flips)) {
1056da6c28aaSamw error = ENOTSUP;
1057da6c28aaSamw goto out;
1058da6c28aaSamw }
1059da6c28aaSamw if ((list->hasmask) && (list->acl_mask != vals->mask) &&
1060da6c28aaSamw (vals->aent_type & (USER | GROUP | GROUP_OBJ))) {
1061da6c28aaSamw error = ENOTSUP;
1062da6c28aaSamw goto out;
1063da6c28aaSamw }
1064da6c28aaSamw error = ace_allow_to_mode(vals->allowed, &dest->a_perm, isdir);
1065da6c28aaSamw if (error != 0)
1066da6c28aaSamw goto out;
1067da6c28aaSamw dest->a_type = vals->aent_type;
1068da6c28aaSamw if (dest->a_type & (USER | GROUP)) {
1069da6c28aaSamw dest->a_id = vals->key;
1070da6c28aaSamw } else if (dest->a_type & USER_OBJ) {
1071da6c28aaSamw dest->a_id = owner;
1072da6c28aaSamw } else if (dest->a_type & GROUP_OBJ) {
1073da6c28aaSamw dest->a_id = group;
1074da6c28aaSamw } else if (dest->a_type & OTHER_OBJ) {
1075da6c28aaSamw dest->a_id = 0;
1076da6c28aaSamw } else {
1077da6c28aaSamw error = EINVAL;
1078da6c28aaSamw goto out;
1079da6c28aaSamw }
1080da6c28aaSamw
1081da6c28aaSamw out:
1082da6c28aaSamw return (error);
1083da6c28aaSamw }
1084da6c28aaSamw
1085da6c28aaSamw
1086da6c28aaSamw static int
ace_list_to_aent(ace_list_t * list,aclent_t ** aclentp,int * aclcnt,uid_t owner,gid_t group,boolean_t isdir)1087da6c28aaSamw ace_list_to_aent(ace_list_t *list, aclent_t **aclentp, int *aclcnt,
1088a3c49ce1SAlbert Lee uid_t owner, gid_t group, boolean_t isdir)
1089da6c28aaSamw {
1090da6c28aaSamw int error = 0;
1091da6c28aaSamw aclent_t *aent, *result = NULL;
1092da6c28aaSamw acevals_t *vals;
1093da6c28aaSamw int resultcount;
1094da6c28aaSamw
1095da6c28aaSamw if ((list->seen & (USER_OBJ | GROUP_OBJ | OTHER_OBJ)) !=
1096da6c28aaSamw (USER_OBJ | GROUP_OBJ | OTHER_OBJ)) {
1097b2ce6e4eSToomas Soome return (ENOTSUP);
1098da6c28aaSamw }
1099b2ce6e4eSToomas Soome
1100da6c28aaSamw if ((! list->hasmask) && (list->numusers + list->numgroups > 0)) {
1101b2ce6e4eSToomas Soome return (ENOTSUP);
1102da6c28aaSamw }
1103da6c28aaSamw
1104da6c28aaSamw resultcount = 3 + list->numusers + list->numgroups;
1105da6c28aaSamw /*
1106da6c28aaSamw * This must be the same condition as below, when we add the CLASS_OBJ
1107da6c28aaSamw * (aka ACL mask)
1108da6c28aaSamw */
1109da6c28aaSamw if ((list->hasmask) || (! list->dfacl_flag))
1110da6c28aaSamw resultcount += 1;
1111da6c28aaSamw
1112da6c28aaSamw if (cacl_malloc((void **)&result,
1113da6c28aaSamw resultcount * sizeof (aclent_t)) != 0) {
1114da6c28aaSamw error = ENOMEM;
1115da6c28aaSamw goto out;
1116da6c28aaSamw }
1117da6c28aaSamw aent = result;
1118da6c28aaSamw
1119da6c28aaSamw /* USER_OBJ */
1120da6c28aaSamw if (!(list->user_obj.aent_type & USER_OBJ)) {
1121da6c28aaSamw error = EINVAL;
1122da6c28aaSamw goto out;
1123da6c28aaSamw }
1124da6c28aaSamw
1125da6c28aaSamw error = acevals_to_aent(&list->user_obj, aent, list, owner, group,
1126da6c28aaSamw isdir);
1127da6c28aaSamw
1128da6c28aaSamw if (error != 0)
1129da6c28aaSamw goto out;
1130da6c28aaSamw ++aent;
1131da6c28aaSamw /* USER */
1132da6c28aaSamw vals = NULL;
1133da6c28aaSamw for (vals = avl_first(&list->user); vals != NULL;
1134da6c28aaSamw vals = AVL_NEXT(&list->user, vals)) {
1135da6c28aaSamw if (!(vals->aent_type & USER)) {
1136da6c28aaSamw error = EINVAL;
1137da6c28aaSamw goto out;
1138da6c28aaSamw }
1139da6c28aaSamw error = acevals_to_aent(vals, aent, list, owner, group,
1140da6c28aaSamw isdir);
1141da6c28aaSamw if (error != 0)
1142da6c28aaSamw goto out;
1143da6c28aaSamw ++aent;
1144da6c28aaSamw }
1145da6c28aaSamw /* GROUP_OBJ */
1146da6c28aaSamw if (!(list->group_obj.aent_type & GROUP_OBJ)) {
1147da6c28aaSamw error = EINVAL;
1148da6c28aaSamw goto out;
1149da6c28aaSamw }
1150da6c28aaSamw error = acevals_to_aent(&list->group_obj, aent, list, owner, group,
1151da6c28aaSamw isdir);
1152da6c28aaSamw if (error != 0)
1153da6c28aaSamw goto out;
1154da6c28aaSamw ++aent;
1155da6c28aaSamw /* GROUP */
1156da6c28aaSamw vals = NULL;
1157da6c28aaSamw for (vals = avl_first(&list->group); vals != NULL;
1158da6c28aaSamw vals = AVL_NEXT(&list->group, vals)) {
1159da6c28aaSamw if (!(vals->aent_type & GROUP)) {
1160da6c28aaSamw error = EINVAL;
1161da6c28aaSamw goto out;
1162da6c28aaSamw }
1163da6c28aaSamw error = acevals_to_aent(vals, aent, list, owner, group,
1164da6c28aaSamw isdir);
1165da6c28aaSamw if (error != 0)
1166da6c28aaSamw goto out;
1167da6c28aaSamw ++aent;
1168da6c28aaSamw }
1169da6c28aaSamw /*
1170da6c28aaSamw * CLASS_OBJ (aka ACL_MASK)
1171da6c28aaSamw *
1172da6c28aaSamw * An ACL_MASK is not fabricated if the ACL is a default ACL.
1173da6c28aaSamw * This is to follow UFS's behavior.
1174da6c28aaSamw */
1175da6c28aaSamw if ((list->hasmask) || (! list->dfacl_flag)) {
1176da6c28aaSamw if (list->hasmask) {
1177da6c28aaSamw uint32_t flips = ACE_POSIX_SUPPORTED_BITS;
1178da6c28aaSamw if (isdir)
1179da6c28aaSamw flips |= ACE_DELETE_CHILD;
1180da6c28aaSamw error = ace_mask_to_mode(list->acl_mask ^ flips,
1181da6c28aaSamw &aent->a_perm, isdir);
1182da6c28aaSamw if (error != 0)
1183da6c28aaSamw goto out;
1184da6c28aaSamw } else {
1185da6c28aaSamw /* fabricate the ACL_MASK from the group permissions */
1186da6c28aaSamw error = ace_mask_to_mode(list->group_obj.allowed,
1187da6c28aaSamw &aent->a_perm, isdir);
1188da6c28aaSamw if (error != 0)
1189da6c28aaSamw goto out;
1190da6c28aaSamw }
1191da6c28aaSamw aent->a_id = 0;
1192da6c28aaSamw aent->a_type = CLASS_OBJ | list->dfacl_flag;
1193da6c28aaSamw ++aent;
1194da6c28aaSamw }
1195da6c28aaSamw /* OTHER_OBJ */
1196da6c28aaSamw if (!(list->other_obj.aent_type & OTHER_OBJ)) {
1197da6c28aaSamw error = EINVAL;
1198da6c28aaSamw goto out;
1199da6c28aaSamw }
1200da6c28aaSamw error = acevals_to_aent(&list->other_obj, aent, list, owner, group,
1201da6c28aaSamw isdir);
1202da6c28aaSamw if (error != 0)
1203da6c28aaSamw goto out;
1204da6c28aaSamw ++aent;
1205da6c28aaSamw
1206da6c28aaSamw *aclentp = result;
1207da6c28aaSamw *aclcnt = resultcount;
1208da6c28aaSamw
1209da6c28aaSamw out:
1210da6c28aaSamw if (error != 0) {
1211da6c28aaSamw if (result != NULL)
1212da6c28aaSamw cacl_free(result, resultcount * sizeof (aclent_t));
1213da6c28aaSamw }
1214da6c28aaSamw
1215da6c28aaSamw return (error);
1216da6c28aaSamw }
1217da6c28aaSamw
1218da6c28aaSamw
1219da6c28aaSamw /*
1220da6c28aaSamw * free all data associated with an ace_list
1221da6c28aaSamw */
1222da6c28aaSamw static void
ace_list_free(ace_list_t * al)1223da6c28aaSamw ace_list_free(ace_list_t *al)
1224da6c28aaSamw {
1225da6c28aaSamw acevals_t *node;
1226da6c28aaSamw void *cookie;
1227da6c28aaSamw
1228da6c28aaSamw if (al == NULL)
1229da6c28aaSamw return;
1230da6c28aaSamw
1231da6c28aaSamw cookie = NULL;
1232da6c28aaSamw while ((node = avl_destroy_nodes(&al->user, &cookie)) != NULL)
1233da6c28aaSamw cacl_free(node, sizeof (acevals_t));
1234da6c28aaSamw cookie = NULL;
1235da6c28aaSamw while ((node = avl_destroy_nodes(&al->group, &cookie)) != NULL)
1236da6c28aaSamw cacl_free(node, sizeof (acevals_t));
1237da6c28aaSamw
1238da6c28aaSamw avl_destroy(&al->user);
1239da6c28aaSamw avl_destroy(&al->group);
1240da6c28aaSamw
1241da6c28aaSamw /* free the container itself */
1242da6c28aaSamw cacl_free(al, sizeof (ace_list_t));
1243da6c28aaSamw }
1244da6c28aaSamw
1245da6c28aaSamw static int
acevals_compare(const void * va,const void * vb)1246da6c28aaSamw acevals_compare(const void *va, const void *vb)
1247da6c28aaSamw {
1248da6c28aaSamw const acevals_t *a = va, *b = vb;
1249da6c28aaSamw
1250da6c28aaSamw if (a->key == b->key)
1251da6c28aaSamw return (0);
1252da6c28aaSamw
1253da6c28aaSamw if (a->key > b->key)
1254da6c28aaSamw return (1);
1255da6c28aaSamw
1256da6c28aaSamw else
1257da6c28aaSamw return (-1);
1258da6c28aaSamw }
1259da6c28aaSamw
1260da6c28aaSamw /*
1261da6c28aaSamw * Convert a list of ace_t entries to equivalent regular and default
1262da6c28aaSamw * aclent_t lists. Return error (ENOTSUP) when conversion is not possible.
1263da6c28aaSamw */
1264da6c28aaSamw static int
ln_ace_to_aent(ace_t * ace,int n,uid_t owner,gid_t group,aclent_t ** aclentp,int * aclcnt,aclent_t ** dfaclentp,int * dfaclcnt,boolean_t isdir)1265da6c28aaSamw ln_ace_to_aent(ace_t *ace, int n, uid_t owner, gid_t group,
1266da6c28aaSamw aclent_t **aclentp, int *aclcnt, aclent_t **dfaclentp, int *dfaclcnt,
1267a3c49ce1SAlbert Lee boolean_t isdir)
1268da6c28aaSamw {
1269da6c28aaSamw int error = 0;
1270da6c28aaSamw ace_t *acep;
1271da6c28aaSamw uint32_t bits;
1272da6c28aaSamw int i;
1273da6c28aaSamw ace_list_t *normacl = NULL, *dfacl = NULL, *acl;
1274da6c28aaSamw acevals_t *vals;
1275da6c28aaSamw
1276da6c28aaSamw *aclentp = NULL;
1277da6c28aaSamw *aclcnt = 0;
1278da6c28aaSamw *dfaclentp = NULL;
1279da6c28aaSamw *dfaclcnt = 0;
1280da6c28aaSamw
1281da6c28aaSamw /* we need at least user_obj, group_obj, and other_obj */
1282da6c28aaSamw if (n < 6) {
1283da6c28aaSamw error = ENOTSUP;
1284da6c28aaSamw goto out;
1285da6c28aaSamw }
1286da6c28aaSamw if (ace == NULL) {
1287da6c28aaSamw error = EINVAL;
1288da6c28aaSamw goto out;
1289da6c28aaSamw }
1290da6c28aaSamw
1291da6c28aaSamw error = cacl_malloc((void **)&normacl, sizeof (ace_list_t));
1292da6c28aaSamw if (error != 0)
1293da6c28aaSamw goto out;
1294da6c28aaSamw
1295da6c28aaSamw avl_create(&normacl->user, acevals_compare, sizeof (acevals_t),
1296da6c28aaSamw offsetof(acevals_t, avl));
1297da6c28aaSamw avl_create(&normacl->group, acevals_compare, sizeof (acevals_t),
1298da6c28aaSamw offsetof(acevals_t, avl));
1299da6c28aaSamw
1300da6c28aaSamw ace_list_init(normacl, 0);
1301da6c28aaSamw
1302da6c28aaSamw error = cacl_malloc((void **)&dfacl, sizeof (ace_list_t));
1303da6c28aaSamw if (error != 0)
1304da6c28aaSamw goto out;
1305da6c28aaSamw
1306da6c28aaSamw avl_create(&dfacl->user, acevals_compare, sizeof (acevals_t),
1307da6c28aaSamw offsetof(acevals_t, avl));
1308da6c28aaSamw avl_create(&dfacl->group, acevals_compare, sizeof (acevals_t),
1309da6c28aaSamw offsetof(acevals_t, avl));
1310da6c28aaSamw ace_list_init(dfacl, ACL_DEFAULT);
1311da6c28aaSamw
1312da6c28aaSamw /* process every ace_t... */
1313da6c28aaSamw for (i = 0; i < n; i++) {
1314da6c28aaSamw acep = &ace[i];
1315da6c28aaSamw
1316da6c28aaSamw /* rule out certain cases quickly */
1317da6c28aaSamw error = ace_to_aent_legal(acep);
1318da6c28aaSamw if (error != 0)
1319da6c28aaSamw goto out;
1320da6c28aaSamw
1321da6c28aaSamw /*
1322da6c28aaSamw * Turn off these bits in order to not have to worry about
1323da6c28aaSamw * them when doing the checks for compliments.
1324da6c28aaSamw */
1325da6c28aaSamw acep->a_access_mask &= ~(ACE_WRITE_OWNER | ACE_DELETE |
1326da6c28aaSamw ACE_SYNCHRONIZE | ACE_WRITE_ATTRIBUTES |
1327da6c28aaSamw ACE_READ_NAMED_ATTRS | ACE_WRITE_NAMED_ATTRS);
1328da6c28aaSamw
1329da6c28aaSamw /* see if this should be a regular or default acl */
1330da6c28aaSamw bits = acep->a_flags &
1331da6c28aaSamw (ACE_INHERIT_ONLY_ACE |
1332da6c28aaSamw ACE_FILE_INHERIT_ACE |
1333da6c28aaSamw ACE_DIRECTORY_INHERIT_ACE);
1334da6c28aaSamw if (bits != 0) {
1335da6c28aaSamw /* all or nothing on these inherit bits */
1336da6c28aaSamw if (bits != (ACE_INHERIT_ONLY_ACE |
1337da6c28aaSamw ACE_FILE_INHERIT_ACE |
1338da6c28aaSamw ACE_DIRECTORY_INHERIT_ACE)) {
1339da6c28aaSamw error = ENOTSUP;
1340da6c28aaSamw goto out;
1341da6c28aaSamw }
1342da6c28aaSamw acl = dfacl;
1343da6c28aaSamw } else {
1344da6c28aaSamw acl = normacl;
1345da6c28aaSamw }
1346da6c28aaSamw
1347da6c28aaSamw if ((acep->a_flags & ACE_OWNER)) {
1348da6c28aaSamw if (acl->state > ace_user_obj) {
1349da6c28aaSamw error = ENOTSUP;
1350da6c28aaSamw goto out;
1351da6c28aaSamw }
1352da6c28aaSamw acl->state = ace_user_obj;
1353da6c28aaSamw acl->seen |= USER_OBJ;
1354da6c28aaSamw vals = &acl->user_obj;
1355da6c28aaSamw vals->aent_type = USER_OBJ | acl->dfacl_flag;
1356da6c28aaSamw } else if ((acep->a_flags & ACE_EVERYONE)) {
1357da6c28aaSamw acl->state = ace_other_obj;
1358da6c28aaSamw acl->seen |= OTHER_OBJ;
1359da6c28aaSamw vals = &acl->other_obj;
1360da6c28aaSamw vals->aent_type = OTHER_OBJ | acl->dfacl_flag;
1361da6c28aaSamw } else if (acep->a_flags & ACE_IDENTIFIER_GROUP) {
1362da6c28aaSamw if (acl->state > ace_group) {
1363da6c28aaSamw error = ENOTSUP;
1364da6c28aaSamw goto out;
1365da6c28aaSamw }
1366da6c28aaSamw if ((acep->a_flags & ACE_GROUP)) {
1367da6c28aaSamw acl->seen |= GROUP_OBJ;
1368da6c28aaSamw vals = &acl->group_obj;
1369da6c28aaSamw vals->aent_type = GROUP_OBJ | acl->dfacl_flag;
1370da6c28aaSamw } else {
1371da6c28aaSamw acl->seen |= GROUP;
1372da6c28aaSamw vals = acevals_find(acep, &acl->group,
1373da6c28aaSamw &acl->numgroups);
1374da6c28aaSamw if (vals == NULL) {
1375da6c28aaSamw error = ENOMEM;
1376da6c28aaSamw goto out;
1377da6c28aaSamw }
1378da6c28aaSamw vals->aent_type = GROUP | acl->dfacl_flag;
1379da6c28aaSamw }
1380da6c28aaSamw acl->state = ace_group;
1381da6c28aaSamw } else {
1382da6c28aaSamw if (acl->state > ace_user) {
1383da6c28aaSamw error = ENOTSUP;
1384da6c28aaSamw goto out;
1385da6c28aaSamw }
1386da6c28aaSamw acl->state = ace_user;
1387da6c28aaSamw acl->seen |= USER;
1388da6c28aaSamw vals = acevals_find(acep, &acl->user,
1389da6c28aaSamw &acl->numusers);
1390da6c28aaSamw if (vals == NULL) {
1391da6c28aaSamw error = ENOMEM;
1392da6c28aaSamw goto out;
1393da6c28aaSamw }
1394da6c28aaSamw vals->aent_type = USER | acl->dfacl_flag;
1395da6c28aaSamw }
1396da6c28aaSamw
1397da6c28aaSamw if (!(acl->state > ace_unused)) {
1398da6c28aaSamw error = EINVAL;
1399da6c28aaSamw goto out;
1400da6c28aaSamw }
1401da6c28aaSamw
1402da6c28aaSamw if (acep->a_type == ACE_ACCESS_ALLOWED_ACE_TYPE) {
1403da6c28aaSamw /* no more than one allowed per aclent_t */
1404da6c28aaSamw if (vals->allowed != ACE_MASK_UNDEFINED) {
1405da6c28aaSamw error = ENOTSUP;
1406da6c28aaSamw goto out;
1407da6c28aaSamw }
1408da6c28aaSamw vals->allowed = acep->a_access_mask;
1409da6c28aaSamw } else {
1410da6c28aaSamw /*
1411da6c28aaSamw * it's a DENY; if there was a previous DENY, it
1412da6c28aaSamw * must have been an ACL_MASK.
1413da6c28aaSamw */
1414da6c28aaSamw if (vals->denied != ACE_MASK_UNDEFINED) {
1415da6c28aaSamw /* ACL_MASK is for USER and GROUP only */
1416da6c28aaSamw if ((acl->state != ace_user) &&
1417da6c28aaSamw (acl->state != ace_group)) {
1418da6c28aaSamw error = ENOTSUP;
1419da6c28aaSamw goto out;
1420da6c28aaSamw }
1421da6c28aaSamw
1422da6c28aaSamw if (! acl->hasmask) {
1423da6c28aaSamw acl->hasmask = 1;
1424da6c28aaSamw acl->acl_mask = vals->denied;
1425da6c28aaSamw /* check for mismatched ACL_MASK emulations */
1426da6c28aaSamw } else if (acl->acl_mask != vals->denied) {
1427da6c28aaSamw error = ENOTSUP;
1428da6c28aaSamw goto out;
1429da6c28aaSamw }
1430da6c28aaSamw vals->mask = vals->denied;
1431da6c28aaSamw }
1432da6c28aaSamw vals->denied = acep->a_access_mask;
1433da6c28aaSamw }
1434da6c28aaSamw }
1435da6c28aaSamw
1436da6c28aaSamw /* done collating; produce the aclent_t lists */
1437da6c28aaSamw if (normacl->state != ace_unused) {
1438da6c28aaSamw error = ace_list_to_aent(normacl, aclentp, aclcnt,
1439da6c28aaSamw owner, group, isdir);
1440da6c28aaSamw if (error != 0) {
1441da6c28aaSamw goto out;
1442da6c28aaSamw }
1443da6c28aaSamw }
1444da6c28aaSamw if (dfacl->state != ace_unused) {
1445da6c28aaSamw error = ace_list_to_aent(dfacl, dfaclentp, dfaclcnt,
1446da6c28aaSamw owner, group, isdir);
1447da6c28aaSamw if (error != 0) {
1448da6c28aaSamw goto out;
1449da6c28aaSamw }
1450da6c28aaSamw }
1451da6c28aaSamw
1452da6c28aaSamw out:
1453da6c28aaSamw if (normacl != NULL)
1454da6c28aaSamw ace_list_free(normacl);
1455da6c28aaSamw if (dfacl != NULL)
1456da6c28aaSamw ace_list_free(dfacl);
1457da6c28aaSamw
1458da6c28aaSamw return (error);
1459da6c28aaSamw }
1460da6c28aaSamw
1461da6c28aaSamw static int
convert_ace_to_aent(ace_t * acebufp,int acecnt,boolean_t isdir,uid_t owner,gid_t group,aclent_t ** retaclentp,int * retaclcnt)1462a3c49ce1SAlbert Lee convert_ace_to_aent(ace_t *acebufp, int acecnt, boolean_t isdir,
1463da6c28aaSamw uid_t owner, gid_t group, aclent_t **retaclentp, int *retaclcnt)
1464da6c28aaSamw {
1465da6c28aaSamw int error = 0;
1466da6c28aaSamw aclent_t *aclentp, *dfaclentp;
1467da6c28aaSamw int aclcnt, dfaclcnt;
1468b819cea2SGordon Ross int aclsz, dfaclsz = 0;
1469da6c28aaSamw
1470da6c28aaSamw error = ln_ace_to_aent(acebufp, acecnt, owner, group,
1471da6c28aaSamw &aclentp, &aclcnt, &dfaclentp, &dfaclcnt, isdir);
1472da6c28aaSamw
1473da6c28aaSamw if (error)
1474da6c28aaSamw return (error);
1475da6c28aaSamw
1476da6c28aaSamw
1477da6c28aaSamw if (dfaclcnt != 0) {
1478da6c28aaSamw /*
1479da6c28aaSamw * Slap aclentp and dfaclentp into a single array.
1480da6c28aaSamw */
1481da6c28aaSamw aclsz = sizeof (aclent_t) * aclcnt;
1482da6c28aaSamw dfaclsz = sizeof (aclent_t) * dfaclcnt;
1483da6c28aaSamw aclentp = cacl_realloc(aclentp, aclsz, aclsz + dfaclsz);
1484da6c28aaSamw if (aclentp != NULL) {
1485da6c28aaSamw (void) memcpy(aclentp + aclcnt, dfaclentp, dfaclsz);
1486da6c28aaSamw } else {
1487da6c28aaSamw error = ENOMEM;
1488da6c28aaSamw }
1489da6c28aaSamw }
1490da6c28aaSamw
1491da6c28aaSamw if (aclentp) {
1492da6c28aaSamw *retaclentp = aclentp;
1493da6c28aaSamw *retaclcnt = aclcnt + dfaclcnt;
1494da6c28aaSamw }
1495da6c28aaSamw
1496da6c28aaSamw if (dfaclentp)
1497da6c28aaSamw cacl_free(dfaclentp, dfaclsz);
1498da6c28aaSamw
1499da6c28aaSamw return (error);
1500da6c28aaSamw }
1501da6c28aaSamw
1502da6c28aaSamw
1503da6c28aaSamw int
acl_translate(acl_t * aclp,int target_flavor,boolean_t isdir,uid_t owner,gid_t group)1504a3c49ce1SAlbert Lee acl_translate(acl_t *aclp, int target_flavor, boolean_t isdir, uid_t owner,
1505da6c28aaSamw gid_t group)
1506da6c28aaSamw {
1507da6c28aaSamw int aclcnt;
1508da6c28aaSamw void *acldata;
1509da6c28aaSamw int error;
1510da6c28aaSamw
1511da6c28aaSamw /*
1512da6c28aaSamw * See if we need to translate
1513da6c28aaSamw */
1514da6c28aaSamw if ((target_flavor == _ACL_ACE_ENABLED && aclp->acl_type == ACE_T) ||
1515da6c28aaSamw (target_flavor == _ACL_ACLENT_ENABLED &&
1516da6c28aaSamw aclp->acl_type == ACLENT_T))
1517da6c28aaSamw return (0);
1518da6c28aaSamw
1519da6c28aaSamw if (target_flavor == -1) {
1520da6c28aaSamw error = EINVAL;
1521da6c28aaSamw goto out;
1522da6c28aaSamw }
1523da6c28aaSamw
1524da6c28aaSamw if (target_flavor == _ACL_ACE_ENABLED &&
1525da6c28aaSamw aclp->acl_type == ACLENT_T) {
1526da6c28aaSamw error = convert_aent_to_ace(aclp->acl_aclp,
1527da6c28aaSamw aclp->acl_cnt, isdir, (ace_t **)&acldata, &aclcnt);
1528da6c28aaSamw if (error)
1529da6c28aaSamw goto out;
1530da6c28aaSamw
1531da6c28aaSamw } else if (target_flavor == _ACL_ACLENT_ENABLED &&
1532da6c28aaSamw aclp->acl_type == ACE_T) {
1533da6c28aaSamw error = convert_ace_to_aent(aclp->acl_aclp, aclp->acl_cnt,
1534da6c28aaSamw isdir, owner, group, (aclent_t **)&acldata, &aclcnt);
1535da6c28aaSamw if (error)
1536da6c28aaSamw goto out;
1537da6c28aaSamw } else {
1538da6c28aaSamw error = ENOTSUP;
1539da6c28aaSamw goto out;
1540da6c28aaSamw }
1541da6c28aaSamw
1542da6c28aaSamw /*
1543da6c28aaSamw * replace old acl with newly translated acl
1544da6c28aaSamw */
1545da6c28aaSamw cacl_free(aclp->acl_aclp, aclp->acl_cnt * aclp->acl_entry_size);
1546da6c28aaSamw aclp->acl_aclp = acldata;
1547da6c28aaSamw aclp->acl_cnt = aclcnt;
1548da6c28aaSamw if (target_flavor == _ACL_ACE_ENABLED) {
1549da6c28aaSamw aclp->acl_type = ACE_T;
1550da6c28aaSamw aclp->acl_entry_size = sizeof (ace_t);
1551da6c28aaSamw } else {
1552da6c28aaSamw aclp->acl_type = ACLENT_T;
1553da6c28aaSamw aclp->acl_entry_size = sizeof (aclent_t);
1554da6c28aaSamw }
1555da6c28aaSamw return (0);
1556da6c28aaSamw
1557da6c28aaSamw out:
1558da6c28aaSamw
1559b819cea2SGordon Ross #if defined(_KERNEL) || defined(_FAKE_KERNEL)
1560b819cea2SGordon Ross return (error);
1561b819cea2SGordon Ross #else
1562da6c28aaSamw errno = error;
1563da6c28aaSamw return (-1);
1564da6c28aaSamw #endif
1565da6c28aaSamw }
156627dd1e87SMark Shellenbaum
156727dd1e87SMark Shellenbaum #define SET_ACE(acl, index, who, mask, type, flags) { \
156827dd1e87SMark Shellenbaum acl[0][index].a_who = (uint32_t)who; \
156927dd1e87SMark Shellenbaum acl[0][index].a_type = type; \
157027dd1e87SMark Shellenbaum acl[0][index].a_flags = flags; \
157127dd1e87SMark Shellenbaum acl[0][index++].a_access_mask = mask; \
157227dd1e87SMark Shellenbaum }
157327dd1e87SMark Shellenbaum
157427dd1e87SMark Shellenbaum void
acl_trivial_access_masks(mode_t mode,boolean_t isdir,trivial_acl_t * masks)1575a3c49ce1SAlbert Lee acl_trivial_access_masks(mode_t mode, boolean_t isdir, trivial_acl_t *masks)
157627dd1e87SMark Shellenbaum {
1577a3c49ce1SAlbert Lee uint32_t read_mask = ACE_READ_DATA;
1578a3c49ce1SAlbert Lee uint32_t write_mask = ACE_WRITE_DATA|ACE_APPEND_DATA;
1579a3c49ce1SAlbert Lee uint32_t execute_mask = ACE_EXECUTE;
158027dd1e87SMark Shellenbaum
15811eb4e906SKevin Crowe if (isdir)
15821eb4e906SKevin Crowe write_mask |= ACE_DELETE_CHILD;
1583a3c49ce1SAlbert Lee
1584a3c49ce1SAlbert Lee masks->deny1 = 0;
158527dd1e87SMark Shellenbaum if (!(mode & S_IRUSR) && (mode & (S_IRGRP|S_IROTH)))
1586a3c49ce1SAlbert Lee masks->deny1 |= read_mask;
158727dd1e87SMark Shellenbaum if (!(mode & S_IWUSR) && (mode & (S_IWGRP|S_IWOTH)))
1588a3c49ce1SAlbert Lee masks->deny1 |= write_mask;
158927dd1e87SMark Shellenbaum if (!(mode & S_IXUSR) && (mode & (S_IXGRP|S_IXOTH)))
1590a3c49ce1SAlbert Lee masks->deny1 |= execute_mask;
159127dd1e87SMark Shellenbaum
1592a3c49ce1SAlbert Lee masks->deny2 = 0;
159327dd1e87SMark Shellenbaum if (!(mode & S_IRGRP) && (mode & S_IROTH))
1594a3c49ce1SAlbert Lee masks->deny2 |= read_mask;
159527dd1e87SMark Shellenbaum if (!(mode & S_IWGRP) && (mode & S_IWOTH))
1596a3c49ce1SAlbert Lee masks->deny2 |= write_mask;
159727dd1e87SMark Shellenbaum if (!(mode & S_IXGRP) && (mode & S_IXOTH))
1598a3c49ce1SAlbert Lee masks->deny2 |= execute_mask;
159927dd1e87SMark Shellenbaum
1600a3c49ce1SAlbert Lee masks->allow0 = 0;
160127dd1e87SMark Shellenbaum if ((mode & S_IRUSR) && (!(mode & S_IRGRP) && (mode & S_IROTH)))
1602a3c49ce1SAlbert Lee masks->allow0 |= read_mask;
160327dd1e87SMark Shellenbaum if ((mode & S_IWUSR) && (!(mode & S_IWGRP) && (mode & S_IWOTH)))
1604a3c49ce1SAlbert Lee masks->allow0 |= write_mask;
160527dd1e87SMark Shellenbaum if ((mode & S_IXUSR) && (!(mode & S_IXGRP) && (mode & S_IXOTH)))
1606a3c49ce1SAlbert Lee masks->allow0 |= execute_mask;
160727dd1e87SMark Shellenbaum
1608a3c49ce1SAlbert Lee masks->owner = ACE_WRITE_ATTRIBUTES|ACE_WRITE_OWNER|ACE_WRITE_ACL|
160927dd1e87SMark Shellenbaum ACE_WRITE_NAMED_ATTRS|ACE_READ_ACL|ACE_READ_ATTRIBUTES|
161027dd1e87SMark Shellenbaum ACE_READ_NAMED_ATTRS|ACE_SYNCHRONIZE;
161127dd1e87SMark Shellenbaum if (mode & S_IRUSR)
1612a3c49ce1SAlbert Lee masks->owner |= read_mask;
161327dd1e87SMark Shellenbaum if (mode & S_IWUSR)
1614a3c49ce1SAlbert Lee masks->owner |= write_mask;
161527dd1e87SMark Shellenbaum if (mode & S_IXUSR)
1616a3c49ce1SAlbert Lee masks->owner |= execute_mask;
161727dd1e87SMark Shellenbaum
1618a3c49ce1SAlbert Lee masks->group = ACE_READ_ACL|ACE_READ_ATTRIBUTES|ACE_READ_NAMED_ATTRS|
161927dd1e87SMark Shellenbaum ACE_SYNCHRONIZE;
162027dd1e87SMark Shellenbaum if (mode & S_IRGRP)
1621a3c49ce1SAlbert Lee masks->group |= read_mask;
162227dd1e87SMark Shellenbaum if (mode & S_IWGRP)
1623a3c49ce1SAlbert Lee masks->group |= write_mask;
162427dd1e87SMark Shellenbaum if (mode & S_IXGRP)
1625a3c49ce1SAlbert Lee masks->group |= execute_mask;
162627dd1e87SMark Shellenbaum
1627a3c49ce1SAlbert Lee masks->everyone = ACE_READ_ACL|ACE_READ_ATTRIBUTES|ACE_READ_NAMED_ATTRS|
162827dd1e87SMark Shellenbaum ACE_SYNCHRONIZE;
162927dd1e87SMark Shellenbaum if (mode & S_IROTH)
1630a3c49ce1SAlbert Lee masks->everyone |= read_mask;
163127dd1e87SMark Shellenbaum if (mode & S_IWOTH)
1632a3c49ce1SAlbert Lee masks->everyone |= write_mask;
163327dd1e87SMark Shellenbaum if (mode & S_IXOTH)
1634a3c49ce1SAlbert Lee masks->everyone |= execute_mask;
163527dd1e87SMark Shellenbaum }
163627dd1e87SMark Shellenbaum
163727dd1e87SMark Shellenbaum int
acl_trivial_create(mode_t mode,boolean_t isdir,ace_t ** acl,int * count)1638a3c49ce1SAlbert Lee acl_trivial_create(mode_t mode, boolean_t isdir, ace_t **acl, int *count)
163927dd1e87SMark Shellenbaum {
164080bd8a58SToomas Soome int index = 0;
164127dd1e87SMark Shellenbaum int error;
1642a3c49ce1SAlbert Lee trivial_acl_t masks;
164327dd1e87SMark Shellenbaum
164427dd1e87SMark Shellenbaum *count = 3;
1645a3c49ce1SAlbert Lee acl_trivial_access_masks(mode, isdir, &masks);
164627dd1e87SMark Shellenbaum
1647a3c49ce1SAlbert Lee if (masks.allow0)
164827dd1e87SMark Shellenbaum (*count)++;
1649a3c49ce1SAlbert Lee if (masks.deny1)
165027dd1e87SMark Shellenbaum (*count)++;
1651a3c49ce1SAlbert Lee if (masks.deny2)
165227dd1e87SMark Shellenbaum (*count)++;
165327dd1e87SMark Shellenbaum
165427dd1e87SMark Shellenbaum if ((error = cacl_malloc((void **)acl, *count * sizeof (ace_t))) != 0)
165527dd1e87SMark Shellenbaum return (error);
165627dd1e87SMark Shellenbaum
1657a3c49ce1SAlbert Lee if (masks.allow0) {
1658a3c49ce1SAlbert Lee SET_ACE(acl, index, -1, masks.allow0,
1659a3c49ce1SAlbert Lee ACE_ACCESS_ALLOWED_ACE_TYPE, ACE_OWNER);
166027dd1e87SMark Shellenbaum }
1661a3c49ce1SAlbert Lee if (masks.deny1) {
1662a3c49ce1SAlbert Lee SET_ACE(acl, index, -1, masks.deny1,
1663a3c49ce1SAlbert Lee ACE_ACCESS_DENIED_ACE_TYPE, ACE_OWNER);
166427dd1e87SMark Shellenbaum }
1665a3c49ce1SAlbert Lee if (masks.deny2) {
1666a3c49ce1SAlbert Lee SET_ACE(acl, index, -1, masks.deny2,
1667a3c49ce1SAlbert Lee ACE_ACCESS_DENIED_ACE_TYPE, ACE_GROUP|ACE_IDENTIFIER_GROUP);
166827dd1e87SMark Shellenbaum }
166927dd1e87SMark Shellenbaum
1670a3c49ce1SAlbert Lee SET_ACE(acl, index, -1, masks.owner, ACE_ACCESS_ALLOWED_ACE_TYPE,
1671a3c49ce1SAlbert Lee ACE_OWNER);
1672a3c49ce1SAlbert Lee SET_ACE(acl, index, -1, masks.group, ACE_ACCESS_ALLOWED_ACE_TYPE,
167327dd1e87SMark Shellenbaum ACE_IDENTIFIER_GROUP|ACE_GROUP);
1674a3c49ce1SAlbert Lee SET_ACE(acl, index, -1, masks.everyone, ACE_ACCESS_ALLOWED_ACE_TYPE,
167527dd1e87SMark Shellenbaum ACE_EVERYONE);
167627dd1e87SMark Shellenbaum
167727dd1e87SMark Shellenbaum return (0);
167827dd1e87SMark Shellenbaum }
167927dd1e87SMark Shellenbaum
1680*70561057SGordon Ross /*
1681*70561057SGordon Ross * Convenience macro for ACE rights implied for owner in a trivial ACL:
1682*70561057SGordon Ross * write_owner/write_acl/write_attributes/write_xattr
1683*70561057SGordon Ross */
1684*70561057SGordon Ross #define ACE_OWNER_MASK (\
1685*70561057SGordon Ross ACE_WRITE_OWNER|\
1686*70561057SGordon Ross ACE_WRITE_ACL|\
1687*70561057SGordon Ross ACE_WRITE_ATTRIBUTES|\
1688*70561057SGordon Ross ACE_WRITE_NAMED_ATTRS)
1689*70561057SGordon Ross
169027dd1e87SMark Shellenbaum /*
169127dd1e87SMark Shellenbaum * ace_trivial:
169227dd1e87SMark Shellenbaum * determine whether an ace_t acl is trivial
169327dd1e87SMark Shellenbaum *
169427dd1e87SMark Shellenbaum * Trivialness implies that the acl is composed of only
169527dd1e87SMark Shellenbaum * owner, group, everyone entries. ACL can't
169627dd1e87SMark Shellenbaum * have read_acl denied, and write_owner/write_acl/write_attributes
169727dd1e87SMark Shellenbaum * can only be owner@ entry.
1698*70561057SGordon Ross *
1699*70561057SGordon Ross * Returns zero if this is a "trivial" ACL, else 1.
170027dd1e87SMark Shellenbaum */
170127dd1e87SMark Shellenbaum int
ace_trivial_common(void * acep,int aclcnt,uint64_t (* walk)(void *,uint64_t,int aclcnt,uint16_t *,uint16_t *,uint32_t *))170227dd1e87SMark Shellenbaum ace_trivial_common(void *acep, int aclcnt,
170327dd1e87SMark Shellenbaum uint64_t (*walk)(void *, uint64_t, int aclcnt,
170427dd1e87SMark Shellenbaum uint16_t *, uint16_t *, uint32_t *))
170527dd1e87SMark Shellenbaum {
170627dd1e87SMark Shellenbaum uint16_t flags;
170727dd1e87SMark Shellenbaum uint32_t mask;
170827dd1e87SMark Shellenbaum uint16_t type;
170927dd1e87SMark Shellenbaum uint64_t cookie = 0;
1710*70561057SGordon Ross uint32_t owner_allow = 0;
1711*70561057SGordon Ross uint32_t owner_deny = 0;
171227dd1e87SMark Shellenbaum
171354026d5aSGordon Ross while ((cookie = walk(acep, cookie, aclcnt, &flags, &type, &mask))
171480bd8a58SToomas Soome != 0) {
171527dd1e87SMark Shellenbaum switch (flags & ACE_TYPE_FLAGS) {
171627dd1e87SMark Shellenbaum case ACE_OWNER:
171727dd1e87SMark Shellenbaum case ACE_GROUP|ACE_IDENTIFIER_GROUP:
171827dd1e87SMark Shellenbaum case ACE_EVERYONE:
171927dd1e87SMark Shellenbaum break;
172027dd1e87SMark Shellenbaum default:
172127dd1e87SMark Shellenbaum return (1);
172227dd1e87SMark Shellenbaum
172327dd1e87SMark Shellenbaum }
172427dd1e87SMark Shellenbaum
172527dd1e87SMark Shellenbaum if (flags & (ACE_FILE_INHERIT_ACE|
172627dd1e87SMark Shellenbaum ACE_DIRECTORY_INHERIT_ACE|ACE_NO_PROPAGATE_INHERIT_ACE|
172727dd1e87SMark Shellenbaum ACE_INHERIT_ONLY_ACE))
172827dd1e87SMark Shellenbaum return (1);
172927dd1e87SMark Shellenbaum
173027dd1e87SMark Shellenbaum /*
173127dd1e87SMark Shellenbaum * Special check for some special bits
173227dd1e87SMark Shellenbaum *
173327dd1e87SMark Shellenbaum * Don't allow anybody to deny reading basic
173427dd1e87SMark Shellenbaum * attributes or a files ACL.
173527dd1e87SMark Shellenbaum */
173627dd1e87SMark Shellenbaum if ((mask & (ACE_READ_ACL|ACE_READ_ATTRIBUTES)) &&
173727dd1e87SMark Shellenbaum (type == ACE_ACCESS_DENIED_ACE_TYPE))
173827dd1e87SMark Shellenbaum return (1);
173927dd1e87SMark Shellenbaum
174027dd1e87SMark Shellenbaum /*
17411eb4e906SKevin Crowe * Delete permission is never set by default
17421eb4e906SKevin Crowe */
17431eb4e906SKevin Crowe if (mask & ACE_DELETE)
17441eb4e906SKevin Crowe return (1);
17451eb4e906SKevin Crowe
17461eb4e906SKevin Crowe /*
17471eb4e906SKevin Crowe * Child delete permission should be accompanied by write
174827dd1e87SMark Shellenbaum */
17491eb4e906SKevin Crowe if ((mask & ACE_DELETE_CHILD) && !(mask & ACE_WRITE_DATA))
175027dd1e87SMark Shellenbaum return (1);
17511eb4e906SKevin Crowe
175227dd1e87SMark Shellenbaum /*
175327dd1e87SMark Shellenbaum * only allow owner@ to have
175427dd1e87SMark Shellenbaum * write_acl/write_owner/write_attributes/write_xattr/
175527dd1e87SMark Shellenbaum */
175627dd1e87SMark Shellenbaum if (type == ACE_ACCESS_ALLOWED_ACE_TYPE &&
1757*70561057SGordon Ross (flags & ACE_OWNER) == 0 &&
1758*70561057SGordon Ross (mask & ACE_OWNER_MASK) != 0)
175927dd1e87SMark Shellenbaum return (1);
176027dd1e87SMark Shellenbaum
1761*70561057SGordon Ross /* Accumulate owner masks */
1762*70561057SGordon Ross if ((flags & ACE_OWNER) != 0) {
1763*70561057SGordon Ross if (type == ACE_ACCESS_ALLOWED_ACE_TYPE)
1764*70561057SGordon Ross owner_allow |= mask;
1765*70561057SGordon Ross if (type == ACE_ACCESS_DENIED_ACE_TYPE)
1766*70561057SGordon Ross owner_deny |= mask;
1767*70561057SGordon Ross }
176827dd1e87SMark Shellenbaum }
1769*70561057SGordon Ross
1770*70561057SGordon Ross /*
1771*70561057SGordon Ross * If owner was not allowed the usual implied rights,
1772*70561057SGordon Ross * then this should not be considered a trivial ACL.
1773*70561057SGordon Ross * In cases like mode 0745 we may have owner@ on
1774*70561057SGordon Ross * multiple ACEs, so we have to check the combined
1775*70561057SGordon Ross * access masks.
1776*70561057SGordon Ross */
1777*70561057SGordon Ross if ((owner_deny & ACE_OWNER_MASK) != 0)
1778*70561057SGordon Ross return (1);
1779*70561057SGordon Ross if ((owner_allow & ACE_OWNER_MASK) != ACE_OWNER_MASK)
1780*70561057SGordon Ross return (1);
1781*70561057SGordon Ross
178227dd1e87SMark Shellenbaum return (0);
178327dd1e87SMark Shellenbaum }
178427dd1e87SMark Shellenbaum
178527dd1e87SMark Shellenbaum uint64_t
ace_walk(void * datap,uint64_t cookie,int aclcnt,uint16_t * flags,uint16_t * type,uint32_t * mask)178627dd1e87SMark Shellenbaum ace_walk(void *datap, uint64_t cookie, int aclcnt, uint16_t *flags,
178727dd1e87SMark Shellenbaum uint16_t *type, uint32_t *mask)
178827dd1e87SMark Shellenbaum {
178927dd1e87SMark Shellenbaum ace_t *acep = datap;
179027dd1e87SMark Shellenbaum
179127dd1e87SMark Shellenbaum if (cookie >= aclcnt)
179227dd1e87SMark Shellenbaum return (0);
179327dd1e87SMark Shellenbaum
179427dd1e87SMark Shellenbaum *flags = acep[cookie].a_flags;
179527dd1e87SMark Shellenbaum *type = acep[cookie].a_type;
179627dd1e87SMark Shellenbaum *mask = acep[cookie++].a_access_mask;
179727dd1e87SMark Shellenbaum
179827dd1e87SMark Shellenbaum return (cookie);
179927dd1e87SMark Shellenbaum }
180027dd1e87SMark Shellenbaum
180127dd1e87SMark Shellenbaum int
ace_trivial(ace_t * acep,int aclcnt)180227dd1e87SMark Shellenbaum ace_trivial(ace_t *acep, int aclcnt)
180327dd1e87SMark Shellenbaum {
180427dd1e87SMark Shellenbaum return (ace_trivial_common(acep, aclcnt, ace_walk));
180527dd1e87SMark Shellenbaum }
1806