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