1 /* 2 * linux/fs/posix_acl.c 3 * 4 * Copyright (C) 2002 by Andreas Gruenbacher <a.gruenbacher@computer.org> 5 * 6 * Fixes from William Schumacher incorporated on 15 March 2001. 7 * (Reported by Charles Bertsch, <CBertsch@microtest.com>). 8 */ 9 10 /* 11 * This file contains generic functions for manipulating 12 * POSIX 1003.1e draft standard 17 ACLs. 13 */ 14 15 #include <linux/kernel.h> 16 #include <linux/slab.h> 17 #include <linux/atomic.h> 18 #include <linux/fs.h> 19 #include <linux/sched.h> 20 #include <linux/posix_acl.h> 21 #include <linux/export.h> 22 23 #include <linux/errno.h> 24 25 EXPORT_SYMBOL(posix_acl_init); 26 EXPORT_SYMBOL(posix_acl_alloc); 27 EXPORT_SYMBOL(posix_acl_valid); 28 EXPORT_SYMBOL(posix_acl_equiv_mode); 29 EXPORT_SYMBOL(posix_acl_from_mode); 30 31 /* 32 * Init a fresh posix_acl 33 */ 34 void 35 posix_acl_init(struct posix_acl *acl, int count) 36 { 37 atomic_set(&acl->a_refcount, 1); 38 acl->a_count = count; 39 } 40 41 /* 42 * Allocate a new ACL with the specified number of entries. 43 */ 44 struct posix_acl * 45 posix_acl_alloc(int count, gfp_t flags) 46 { 47 const size_t size = sizeof(struct posix_acl) + 48 count * sizeof(struct posix_acl_entry); 49 struct posix_acl *acl = kmalloc(size, flags); 50 if (acl) 51 posix_acl_init(acl, count); 52 return acl; 53 } 54 55 /* 56 * Clone an ACL. 57 */ 58 static struct posix_acl * 59 posix_acl_clone(const struct posix_acl *acl, gfp_t flags) 60 { 61 struct posix_acl *clone = NULL; 62 63 if (acl) { 64 int size = sizeof(struct posix_acl) + acl->a_count * 65 sizeof(struct posix_acl_entry); 66 clone = kmemdup(acl, size, flags); 67 if (clone) 68 atomic_set(&clone->a_refcount, 1); 69 } 70 return clone; 71 } 72 73 /* 74 * Check if an acl is valid. Returns 0 if it is, or -E... otherwise. 75 */ 76 int 77 posix_acl_valid(const struct posix_acl *acl) 78 { 79 const struct posix_acl_entry *pa, *pe; 80 int state = ACL_USER_OBJ; 81 kuid_t prev_uid = INVALID_UID; 82 kgid_t prev_gid = INVALID_GID; 83 int needs_mask = 0; 84 85 FOREACH_ACL_ENTRY(pa, acl, pe) { 86 if (pa->e_perm & ~(ACL_READ|ACL_WRITE|ACL_EXECUTE)) 87 return -EINVAL; 88 switch (pa->e_tag) { 89 case ACL_USER_OBJ: 90 if (state == ACL_USER_OBJ) { 91 state = ACL_USER; 92 break; 93 } 94 return -EINVAL; 95 96 case ACL_USER: 97 if (state != ACL_USER) 98 return -EINVAL; 99 if (!uid_valid(pa->e_uid)) 100 return -EINVAL; 101 if (uid_valid(prev_uid) && 102 uid_lte(pa->e_uid, prev_uid)) 103 return -EINVAL; 104 prev_uid = pa->e_uid; 105 needs_mask = 1; 106 break; 107 108 case ACL_GROUP_OBJ: 109 if (state == ACL_USER) { 110 state = ACL_GROUP; 111 break; 112 } 113 return -EINVAL; 114 115 case ACL_GROUP: 116 if (state != ACL_GROUP) 117 return -EINVAL; 118 if (!gid_valid(pa->e_gid)) 119 return -EINVAL; 120 if (gid_valid(prev_gid) && 121 gid_lte(pa->e_gid, prev_gid)) 122 return -EINVAL; 123 prev_gid = pa->e_gid; 124 needs_mask = 1; 125 break; 126 127 case ACL_MASK: 128 if (state != ACL_GROUP) 129 return -EINVAL; 130 state = ACL_OTHER; 131 break; 132 133 case ACL_OTHER: 134 if (state == ACL_OTHER || 135 (state == ACL_GROUP && !needs_mask)) { 136 state = 0; 137 break; 138 } 139 return -EINVAL; 140 141 default: 142 return -EINVAL; 143 } 144 } 145 if (state == 0) 146 return 0; 147 return -EINVAL; 148 } 149 150 /* 151 * Returns 0 if the acl can be exactly represented in the traditional 152 * file mode permission bits, or else 1. Returns -E... on error. 153 */ 154 int 155 posix_acl_equiv_mode(const struct posix_acl *acl, umode_t *mode_p) 156 { 157 const struct posix_acl_entry *pa, *pe; 158 umode_t mode = 0; 159 int not_equiv = 0; 160 161 FOREACH_ACL_ENTRY(pa, acl, pe) { 162 switch (pa->e_tag) { 163 case ACL_USER_OBJ: 164 mode |= (pa->e_perm & S_IRWXO) << 6; 165 break; 166 case ACL_GROUP_OBJ: 167 mode |= (pa->e_perm & S_IRWXO) << 3; 168 break; 169 case ACL_OTHER: 170 mode |= pa->e_perm & S_IRWXO; 171 break; 172 case ACL_MASK: 173 mode = (mode & ~S_IRWXG) | 174 ((pa->e_perm & S_IRWXO) << 3); 175 not_equiv = 1; 176 break; 177 case ACL_USER: 178 case ACL_GROUP: 179 not_equiv = 1; 180 break; 181 default: 182 return -EINVAL; 183 } 184 } 185 if (mode_p) 186 *mode_p = (*mode_p & ~S_IRWXUGO) | mode; 187 return not_equiv; 188 } 189 190 /* 191 * Create an ACL representing the file mode permission bits of an inode. 192 */ 193 struct posix_acl * 194 posix_acl_from_mode(umode_t mode, gfp_t flags) 195 { 196 struct posix_acl *acl = posix_acl_alloc(3, flags); 197 if (!acl) 198 return ERR_PTR(-ENOMEM); 199 200 acl->a_entries[0].e_tag = ACL_USER_OBJ; 201 acl->a_entries[0].e_perm = (mode & S_IRWXU) >> 6; 202 203 acl->a_entries[1].e_tag = ACL_GROUP_OBJ; 204 acl->a_entries[1].e_perm = (mode & S_IRWXG) >> 3; 205 206 acl->a_entries[2].e_tag = ACL_OTHER; 207 acl->a_entries[2].e_perm = (mode & S_IRWXO); 208 return acl; 209 } 210 211 /* 212 * Return 0 if current is granted want access to the inode 213 * by the acl. Returns -E... otherwise. 214 */ 215 int 216 posix_acl_permission(struct inode *inode, const struct posix_acl *acl, int want) 217 { 218 const struct posix_acl_entry *pa, *pe, *mask_obj; 219 int found = 0; 220 221 want &= MAY_READ | MAY_WRITE | MAY_EXEC | MAY_NOT_BLOCK; 222 223 FOREACH_ACL_ENTRY(pa, acl, pe) { 224 switch(pa->e_tag) { 225 case ACL_USER_OBJ: 226 /* (May have been checked already) */ 227 if (uid_eq(inode->i_uid, current_fsuid())) 228 goto check_perm; 229 break; 230 case ACL_USER: 231 if (uid_eq(pa->e_uid, current_fsuid())) 232 goto mask; 233 break; 234 case ACL_GROUP_OBJ: 235 if (in_group_p(inode->i_gid)) { 236 found = 1; 237 if ((pa->e_perm & want) == want) 238 goto mask; 239 } 240 break; 241 case ACL_GROUP: 242 if (in_group_p(pa->e_gid)) { 243 found = 1; 244 if ((pa->e_perm & want) == want) 245 goto mask; 246 } 247 break; 248 case ACL_MASK: 249 break; 250 case ACL_OTHER: 251 if (found) 252 return -EACCES; 253 else 254 goto check_perm; 255 default: 256 return -EIO; 257 } 258 } 259 return -EIO; 260 261 mask: 262 for (mask_obj = pa+1; mask_obj != pe; mask_obj++) { 263 if (mask_obj->e_tag == ACL_MASK) { 264 if ((pa->e_perm & mask_obj->e_perm & want) == want) 265 return 0; 266 return -EACCES; 267 } 268 } 269 270 check_perm: 271 if ((pa->e_perm & want) == want) 272 return 0; 273 return -EACCES; 274 } 275 276 /* 277 * Modify acl when creating a new inode. The caller must ensure the acl is 278 * only referenced once. 279 * 280 * mode_p initially must contain the mode parameter to the open() / creat() 281 * system calls. All permissions that are not granted by the acl are removed. 282 * The permissions in the acl are changed to reflect the mode_p parameter. 283 */ 284 static int posix_acl_create_masq(struct posix_acl *acl, umode_t *mode_p) 285 { 286 struct posix_acl_entry *pa, *pe; 287 struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL; 288 umode_t mode = *mode_p; 289 int not_equiv = 0; 290 291 /* assert(atomic_read(acl->a_refcount) == 1); */ 292 293 FOREACH_ACL_ENTRY(pa, acl, pe) { 294 switch(pa->e_tag) { 295 case ACL_USER_OBJ: 296 pa->e_perm &= (mode >> 6) | ~S_IRWXO; 297 mode &= (pa->e_perm << 6) | ~S_IRWXU; 298 break; 299 300 case ACL_USER: 301 case ACL_GROUP: 302 not_equiv = 1; 303 break; 304 305 case ACL_GROUP_OBJ: 306 group_obj = pa; 307 break; 308 309 case ACL_OTHER: 310 pa->e_perm &= mode | ~S_IRWXO; 311 mode &= pa->e_perm | ~S_IRWXO; 312 break; 313 314 case ACL_MASK: 315 mask_obj = pa; 316 not_equiv = 1; 317 break; 318 319 default: 320 return -EIO; 321 } 322 } 323 324 if (mask_obj) { 325 mask_obj->e_perm &= (mode >> 3) | ~S_IRWXO; 326 mode &= (mask_obj->e_perm << 3) | ~S_IRWXG; 327 } else { 328 if (!group_obj) 329 return -EIO; 330 group_obj->e_perm &= (mode >> 3) | ~S_IRWXO; 331 mode &= (group_obj->e_perm << 3) | ~S_IRWXG; 332 } 333 334 *mode_p = (*mode_p & ~S_IRWXUGO) | mode; 335 return not_equiv; 336 } 337 338 /* 339 * Modify the ACL for the chmod syscall. 340 */ 341 static int posix_acl_chmod_masq(struct posix_acl *acl, umode_t mode) 342 { 343 struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL; 344 struct posix_acl_entry *pa, *pe; 345 346 /* assert(atomic_read(acl->a_refcount) == 1); */ 347 348 FOREACH_ACL_ENTRY(pa, acl, pe) { 349 switch(pa->e_tag) { 350 case ACL_USER_OBJ: 351 pa->e_perm = (mode & S_IRWXU) >> 6; 352 break; 353 354 case ACL_USER: 355 case ACL_GROUP: 356 break; 357 358 case ACL_GROUP_OBJ: 359 group_obj = pa; 360 break; 361 362 case ACL_MASK: 363 mask_obj = pa; 364 break; 365 366 case ACL_OTHER: 367 pa->e_perm = (mode & S_IRWXO); 368 break; 369 370 default: 371 return -EIO; 372 } 373 } 374 375 if (mask_obj) { 376 mask_obj->e_perm = (mode & S_IRWXG) >> 3; 377 } else { 378 if (!group_obj) 379 return -EIO; 380 group_obj->e_perm = (mode & S_IRWXG) >> 3; 381 } 382 383 return 0; 384 } 385 386 int 387 posix_acl_create(struct posix_acl **acl, gfp_t gfp, umode_t *mode_p) 388 { 389 struct posix_acl *clone = posix_acl_clone(*acl, gfp); 390 int err = -ENOMEM; 391 if (clone) { 392 err = posix_acl_create_masq(clone, mode_p); 393 if (err < 0) { 394 posix_acl_release(clone); 395 clone = NULL; 396 } 397 } 398 posix_acl_release(*acl); 399 *acl = clone; 400 return err; 401 } 402 EXPORT_SYMBOL(posix_acl_create); 403 404 int 405 posix_acl_chmod(struct posix_acl **acl, gfp_t gfp, umode_t mode) 406 { 407 struct posix_acl *clone = posix_acl_clone(*acl, gfp); 408 int err = -ENOMEM; 409 if (clone) { 410 err = posix_acl_chmod_masq(clone, mode); 411 if (err) { 412 posix_acl_release(clone); 413 clone = NULL; 414 } 415 } 416 posix_acl_release(*acl); 417 *acl = clone; 418 return err; 419 } 420 EXPORT_SYMBOL(posix_acl_chmod); 421