1 /* 2 * Copyright (C) 2002,2003 by Andreas Gruenbacher <a.gruenbacher@computer.org> 3 * 4 * Fixes from William Schumacher incorporated on 15 March 2001. 5 * (Reported by Charles Bertsch, <CBertsch@microtest.com>). 6 */ 7 8 /* 9 * This file contains generic functions for manipulating 10 * POSIX 1003.1e draft standard 17 ACLs. 11 */ 12 13 #include <linux/kernel.h> 14 #include <linux/slab.h> 15 #include <linux/atomic.h> 16 #include <linux/fs.h> 17 #include <linux/sched.h> 18 #include <linux/posix_acl.h> 19 #include <linux/posix_acl_xattr.h> 20 #include <linux/xattr.h> 21 #include <linux/export.h> 22 #include <linux/user_namespace.h> 23 24 EXPORT_SYMBOL(posix_acl_init); 25 EXPORT_SYMBOL(posix_acl_alloc); 26 EXPORT_SYMBOL(posix_acl_valid); 27 EXPORT_SYMBOL(posix_acl_equiv_mode); 28 EXPORT_SYMBOL(posix_acl_from_mode); 29 30 struct posix_acl *get_acl(struct inode *inode, int type) 31 { 32 struct posix_acl *acl; 33 34 acl = get_cached_acl(inode, type); 35 if (acl != ACL_NOT_CACHED) 36 return acl; 37 38 if (!IS_POSIXACL(inode)) 39 return NULL; 40 41 /* 42 * A filesystem can force a ACL callback by just never filling the 43 * ACL cache. But normally you'd fill the cache either at inode 44 * instantiation time, or on the first ->get_acl call. 45 * 46 * If the filesystem doesn't have a get_acl() function at all, we'll 47 * just create the negative cache entry. 48 */ 49 if (!inode->i_op->get_acl) { 50 set_cached_acl(inode, type, NULL); 51 return NULL; 52 } 53 return inode->i_op->get_acl(inode, type); 54 } 55 EXPORT_SYMBOL(get_acl); 56 57 /* 58 * Init a fresh posix_acl 59 */ 60 void 61 posix_acl_init(struct posix_acl *acl, int count) 62 { 63 atomic_set(&acl->a_refcount, 1); 64 acl->a_count = count; 65 } 66 67 /* 68 * Allocate a new ACL with the specified number of entries. 69 */ 70 struct posix_acl * 71 posix_acl_alloc(int count, gfp_t flags) 72 { 73 const size_t size = sizeof(struct posix_acl) + 74 count * sizeof(struct posix_acl_entry); 75 struct posix_acl *acl = kmalloc(size, flags); 76 if (acl) 77 posix_acl_init(acl, count); 78 return acl; 79 } 80 81 /* 82 * Clone an ACL. 83 */ 84 static struct posix_acl * 85 posix_acl_clone(const struct posix_acl *acl, gfp_t flags) 86 { 87 struct posix_acl *clone = NULL; 88 89 if (acl) { 90 int size = sizeof(struct posix_acl) + acl->a_count * 91 sizeof(struct posix_acl_entry); 92 clone = kmemdup(acl, size, flags); 93 if (clone) 94 atomic_set(&clone->a_refcount, 1); 95 } 96 return clone; 97 } 98 99 /* 100 * Check if an acl is valid. Returns 0 if it is, or -E... otherwise. 101 */ 102 int 103 posix_acl_valid(const struct posix_acl *acl) 104 { 105 const struct posix_acl_entry *pa, *pe; 106 int state = ACL_USER_OBJ; 107 kuid_t prev_uid = INVALID_UID; 108 kgid_t prev_gid = INVALID_GID; 109 int needs_mask = 0; 110 111 FOREACH_ACL_ENTRY(pa, acl, pe) { 112 if (pa->e_perm & ~(ACL_READ|ACL_WRITE|ACL_EXECUTE)) 113 return -EINVAL; 114 switch (pa->e_tag) { 115 case ACL_USER_OBJ: 116 if (state == ACL_USER_OBJ) { 117 state = ACL_USER; 118 break; 119 } 120 return -EINVAL; 121 122 case ACL_USER: 123 if (state != ACL_USER) 124 return -EINVAL; 125 if (!uid_valid(pa->e_uid)) 126 return -EINVAL; 127 if (uid_valid(prev_uid) && 128 uid_lte(pa->e_uid, prev_uid)) 129 return -EINVAL; 130 prev_uid = pa->e_uid; 131 needs_mask = 1; 132 break; 133 134 case ACL_GROUP_OBJ: 135 if (state == ACL_USER) { 136 state = ACL_GROUP; 137 break; 138 } 139 return -EINVAL; 140 141 case ACL_GROUP: 142 if (state != ACL_GROUP) 143 return -EINVAL; 144 if (!gid_valid(pa->e_gid)) 145 return -EINVAL; 146 if (gid_valid(prev_gid) && 147 gid_lte(pa->e_gid, prev_gid)) 148 return -EINVAL; 149 prev_gid = pa->e_gid; 150 needs_mask = 1; 151 break; 152 153 case ACL_MASK: 154 if (state != ACL_GROUP) 155 return -EINVAL; 156 state = ACL_OTHER; 157 break; 158 159 case ACL_OTHER: 160 if (state == ACL_OTHER || 161 (state == ACL_GROUP && !needs_mask)) { 162 state = 0; 163 break; 164 } 165 return -EINVAL; 166 167 default: 168 return -EINVAL; 169 } 170 } 171 if (state == 0) 172 return 0; 173 return -EINVAL; 174 } 175 176 /* 177 * Returns 0 if the acl can be exactly represented in the traditional 178 * file mode permission bits, or else 1. Returns -E... on error. 179 */ 180 int 181 posix_acl_equiv_mode(const struct posix_acl *acl, umode_t *mode_p) 182 { 183 const struct posix_acl_entry *pa, *pe; 184 umode_t mode = 0; 185 int not_equiv = 0; 186 187 FOREACH_ACL_ENTRY(pa, acl, pe) { 188 switch (pa->e_tag) { 189 case ACL_USER_OBJ: 190 mode |= (pa->e_perm & S_IRWXO) << 6; 191 break; 192 case ACL_GROUP_OBJ: 193 mode |= (pa->e_perm & S_IRWXO) << 3; 194 break; 195 case ACL_OTHER: 196 mode |= pa->e_perm & S_IRWXO; 197 break; 198 case ACL_MASK: 199 mode = (mode & ~S_IRWXG) | 200 ((pa->e_perm & S_IRWXO) << 3); 201 not_equiv = 1; 202 break; 203 case ACL_USER: 204 case ACL_GROUP: 205 not_equiv = 1; 206 break; 207 default: 208 return -EINVAL; 209 } 210 } 211 if (mode_p) 212 *mode_p = (*mode_p & ~S_IRWXUGO) | mode; 213 return not_equiv; 214 } 215 216 /* 217 * Create an ACL representing the file mode permission bits of an inode. 218 */ 219 struct posix_acl * 220 posix_acl_from_mode(umode_t mode, gfp_t flags) 221 { 222 struct posix_acl *acl = posix_acl_alloc(3, flags); 223 if (!acl) 224 return ERR_PTR(-ENOMEM); 225 226 acl->a_entries[0].e_tag = ACL_USER_OBJ; 227 acl->a_entries[0].e_perm = (mode & S_IRWXU) >> 6; 228 229 acl->a_entries[1].e_tag = ACL_GROUP_OBJ; 230 acl->a_entries[1].e_perm = (mode & S_IRWXG) >> 3; 231 232 acl->a_entries[2].e_tag = ACL_OTHER; 233 acl->a_entries[2].e_perm = (mode & S_IRWXO); 234 return acl; 235 } 236 237 /* 238 * Return 0 if current is granted want access to the inode 239 * by the acl. Returns -E... otherwise. 240 */ 241 int 242 posix_acl_permission(struct inode *inode, const struct posix_acl *acl, int want) 243 { 244 const struct posix_acl_entry *pa, *pe, *mask_obj; 245 int found = 0; 246 247 want &= MAY_READ | MAY_WRITE | MAY_EXEC | MAY_NOT_BLOCK; 248 249 FOREACH_ACL_ENTRY(pa, acl, pe) { 250 switch(pa->e_tag) { 251 case ACL_USER_OBJ: 252 /* (May have been checked already) */ 253 if (uid_eq(inode->i_uid, current_fsuid())) 254 goto check_perm; 255 break; 256 case ACL_USER: 257 if (uid_eq(pa->e_uid, current_fsuid())) 258 goto mask; 259 break; 260 case ACL_GROUP_OBJ: 261 if (in_group_p(inode->i_gid)) { 262 found = 1; 263 if ((pa->e_perm & want) == want) 264 goto mask; 265 } 266 break; 267 case ACL_GROUP: 268 if (in_group_p(pa->e_gid)) { 269 found = 1; 270 if ((pa->e_perm & want) == want) 271 goto mask; 272 } 273 break; 274 case ACL_MASK: 275 break; 276 case ACL_OTHER: 277 if (found) 278 return -EACCES; 279 else 280 goto check_perm; 281 default: 282 return -EIO; 283 } 284 } 285 return -EIO; 286 287 mask: 288 for (mask_obj = pa+1; mask_obj != pe; mask_obj++) { 289 if (mask_obj->e_tag == ACL_MASK) { 290 if ((pa->e_perm & mask_obj->e_perm & want) == want) 291 return 0; 292 return -EACCES; 293 } 294 } 295 296 check_perm: 297 if ((pa->e_perm & want) == want) 298 return 0; 299 return -EACCES; 300 } 301 302 /* 303 * Modify acl when creating a new inode. The caller must ensure the acl is 304 * only referenced once. 305 * 306 * mode_p initially must contain the mode parameter to the open() / creat() 307 * system calls. All permissions that are not granted by the acl are removed. 308 * The permissions in the acl are changed to reflect the mode_p parameter. 309 */ 310 static int posix_acl_create_masq(struct posix_acl *acl, umode_t *mode_p) 311 { 312 struct posix_acl_entry *pa, *pe; 313 struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL; 314 umode_t mode = *mode_p; 315 int not_equiv = 0; 316 317 /* assert(atomic_read(acl->a_refcount) == 1); */ 318 319 FOREACH_ACL_ENTRY(pa, acl, pe) { 320 switch(pa->e_tag) { 321 case ACL_USER_OBJ: 322 pa->e_perm &= (mode >> 6) | ~S_IRWXO; 323 mode &= (pa->e_perm << 6) | ~S_IRWXU; 324 break; 325 326 case ACL_USER: 327 case ACL_GROUP: 328 not_equiv = 1; 329 break; 330 331 case ACL_GROUP_OBJ: 332 group_obj = pa; 333 break; 334 335 case ACL_OTHER: 336 pa->e_perm &= mode | ~S_IRWXO; 337 mode &= pa->e_perm | ~S_IRWXO; 338 break; 339 340 case ACL_MASK: 341 mask_obj = pa; 342 not_equiv = 1; 343 break; 344 345 default: 346 return -EIO; 347 } 348 } 349 350 if (mask_obj) { 351 mask_obj->e_perm &= (mode >> 3) | ~S_IRWXO; 352 mode &= (mask_obj->e_perm << 3) | ~S_IRWXG; 353 } else { 354 if (!group_obj) 355 return -EIO; 356 group_obj->e_perm &= (mode >> 3) | ~S_IRWXO; 357 mode &= (group_obj->e_perm << 3) | ~S_IRWXG; 358 } 359 360 *mode_p = (*mode_p & ~S_IRWXUGO) | mode; 361 return not_equiv; 362 } 363 364 /* 365 * Modify the ACL for the chmod syscall. 366 */ 367 static int posix_acl_chmod_masq(struct posix_acl *acl, umode_t mode) 368 { 369 struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL; 370 struct posix_acl_entry *pa, *pe; 371 372 /* assert(atomic_read(acl->a_refcount) == 1); */ 373 374 FOREACH_ACL_ENTRY(pa, acl, pe) { 375 switch(pa->e_tag) { 376 case ACL_USER_OBJ: 377 pa->e_perm = (mode & S_IRWXU) >> 6; 378 break; 379 380 case ACL_USER: 381 case ACL_GROUP: 382 break; 383 384 case ACL_GROUP_OBJ: 385 group_obj = pa; 386 break; 387 388 case ACL_MASK: 389 mask_obj = pa; 390 break; 391 392 case ACL_OTHER: 393 pa->e_perm = (mode & S_IRWXO); 394 break; 395 396 default: 397 return -EIO; 398 } 399 } 400 401 if (mask_obj) { 402 mask_obj->e_perm = (mode & S_IRWXG) >> 3; 403 } else { 404 if (!group_obj) 405 return -EIO; 406 group_obj->e_perm = (mode & S_IRWXG) >> 3; 407 } 408 409 return 0; 410 } 411 412 int 413 posix_acl_create(struct posix_acl **acl, gfp_t gfp, umode_t *mode_p) 414 { 415 struct posix_acl *clone = posix_acl_clone(*acl, gfp); 416 int err = -ENOMEM; 417 if (clone) { 418 err = posix_acl_create_masq(clone, mode_p); 419 if (err < 0) { 420 posix_acl_release(clone); 421 clone = NULL; 422 } 423 } 424 posix_acl_release(*acl); 425 *acl = clone; 426 return err; 427 } 428 EXPORT_SYMBOL(posix_acl_create); 429 430 int 431 posix_acl_chmod(struct posix_acl **acl, gfp_t gfp, umode_t mode) 432 { 433 struct posix_acl *clone = posix_acl_clone(*acl, gfp); 434 int err = -ENOMEM; 435 if (clone) { 436 err = posix_acl_chmod_masq(clone, mode); 437 if (err) { 438 posix_acl_release(clone); 439 clone = NULL; 440 } 441 } 442 posix_acl_release(*acl); 443 *acl = clone; 444 return err; 445 } 446 EXPORT_SYMBOL(posix_acl_chmod); 447 448 /* 449 * Fix up the uids and gids in posix acl extended attributes in place. 450 */ 451 static void posix_acl_fix_xattr_userns( 452 struct user_namespace *to, struct user_namespace *from, 453 void *value, size_t size) 454 { 455 posix_acl_xattr_header *header = (posix_acl_xattr_header *)value; 456 posix_acl_xattr_entry *entry = (posix_acl_xattr_entry *)(header+1), *end; 457 int count; 458 kuid_t uid; 459 kgid_t gid; 460 461 if (!value) 462 return; 463 if (size < sizeof(posix_acl_xattr_header)) 464 return; 465 if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION)) 466 return; 467 468 count = posix_acl_xattr_count(size); 469 if (count < 0) 470 return; 471 if (count == 0) 472 return; 473 474 for (end = entry + count; entry != end; entry++) { 475 switch(le16_to_cpu(entry->e_tag)) { 476 case ACL_USER: 477 uid = make_kuid(from, le32_to_cpu(entry->e_id)); 478 entry->e_id = cpu_to_le32(from_kuid(to, uid)); 479 break; 480 case ACL_GROUP: 481 gid = make_kgid(from, le32_to_cpu(entry->e_id)); 482 entry->e_id = cpu_to_le32(from_kgid(to, gid)); 483 break; 484 default: 485 break; 486 } 487 } 488 } 489 490 void posix_acl_fix_xattr_from_user(void *value, size_t size) 491 { 492 struct user_namespace *user_ns = current_user_ns(); 493 if (user_ns == &init_user_ns) 494 return; 495 posix_acl_fix_xattr_userns(&init_user_ns, user_ns, value, size); 496 } 497 498 void posix_acl_fix_xattr_to_user(void *value, size_t size) 499 { 500 struct user_namespace *user_ns = current_user_ns(); 501 if (user_ns == &init_user_ns) 502 return; 503 posix_acl_fix_xattr_userns(user_ns, &init_user_ns, value, size); 504 } 505 506 /* 507 * Convert from extended attribute to in-memory representation. 508 */ 509 struct posix_acl * 510 posix_acl_from_xattr(struct user_namespace *user_ns, 511 const void *value, size_t size) 512 { 513 posix_acl_xattr_header *header = (posix_acl_xattr_header *)value; 514 posix_acl_xattr_entry *entry = (posix_acl_xattr_entry *)(header+1), *end; 515 int count; 516 struct posix_acl *acl; 517 struct posix_acl_entry *acl_e; 518 519 if (!value) 520 return NULL; 521 if (size < sizeof(posix_acl_xattr_header)) 522 return ERR_PTR(-EINVAL); 523 if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION)) 524 return ERR_PTR(-EOPNOTSUPP); 525 526 count = posix_acl_xattr_count(size); 527 if (count < 0) 528 return ERR_PTR(-EINVAL); 529 if (count == 0) 530 return NULL; 531 532 acl = posix_acl_alloc(count, GFP_NOFS); 533 if (!acl) 534 return ERR_PTR(-ENOMEM); 535 acl_e = acl->a_entries; 536 537 for (end = entry + count; entry != end; acl_e++, entry++) { 538 acl_e->e_tag = le16_to_cpu(entry->e_tag); 539 acl_e->e_perm = le16_to_cpu(entry->e_perm); 540 541 switch(acl_e->e_tag) { 542 case ACL_USER_OBJ: 543 case ACL_GROUP_OBJ: 544 case ACL_MASK: 545 case ACL_OTHER: 546 break; 547 548 case ACL_USER: 549 acl_e->e_uid = 550 make_kuid(user_ns, 551 le32_to_cpu(entry->e_id)); 552 if (!uid_valid(acl_e->e_uid)) 553 goto fail; 554 break; 555 case ACL_GROUP: 556 acl_e->e_gid = 557 make_kgid(user_ns, 558 le32_to_cpu(entry->e_id)); 559 if (!gid_valid(acl_e->e_gid)) 560 goto fail; 561 break; 562 563 default: 564 goto fail; 565 } 566 } 567 return acl; 568 569 fail: 570 posix_acl_release(acl); 571 return ERR_PTR(-EINVAL); 572 } 573 EXPORT_SYMBOL (posix_acl_from_xattr); 574 575 /* 576 * Convert from in-memory to extended attribute representation. 577 */ 578 int 579 posix_acl_to_xattr(struct user_namespace *user_ns, const struct posix_acl *acl, 580 void *buffer, size_t size) 581 { 582 posix_acl_xattr_header *ext_acl = (posix_acl_xattr_header *)buffer; 583 posix_acl_xattr_entry *ext_entry = ext_acl->a_entries; 584 int real_size, n; 585 586 real_size = posix_acl_xattr_size(acl->a_count); 587 if (!buffer) 588 return real_size; 589 if (real_size > size) 590 return -ERANGE; 591 592 ext_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION); 593 594 for (n=0; n < acl->a_count; n++, ext_entry++) { 595 const struct posix_acl_entry *acl_e = &acl->a_entries[n]; 596 ext_entry->e_tag = cpu_to_le16(acl_e->e_tag); 597 ext_entry->e_perm = cpu_to_le16(acl_e->e_perm); 598 switch(acl_e->e_tag) { 599 case ACL_USER: 600 ext_entry->e_id = 601 cpu_to_le32(from_kuid(user_ns, acl_e->e_uid)); 602 break; 603 case ACL_GROUP: 604 ext_entry->e_id = 605 cpu_to_le32(from_kgid(user_ns, acl_e->e_gid)); 606 break; 607 default: 608 ext_entry->e_id = cpu_to_le32(ACL_UNDEFINED_ID); 609 break; 610 } 611 } 612 return real_size; 613 } 614 EXPORT_SYMBOL (posix_acl_to_xattr); 615 616 static int 617 posix_acl_xattr_get(struct dentry *dentry, const char *name, 618 void *value, size_t size, int type) 619 { 620 struct posix_acl *acl; 621 int error; 622 623 if (!IS_POSIXACL(dentry->d_inode)) 624 return -EOPNOTSUPP; 625 if (S_ISLNK(dentry->d_inode->i_mode)) 626 return -EOPNOTSUPP; 627 628 acl = get_acl(dentry->d_inode, type); 629 if (IS_ERR(acl)) 630 return PTR_ERR(acl); 631 if (acl == NULL) 632 return -ENODATA; 633 634 error = posix_acl_to_xattr(&init_user_ns, acl, value, size); 635 posix_acl_release(acl); 636 637 return error; 638 } 639 640 static int 641 posix_acl_xattr_set(struct dentry *dentry, const char *name, 642 const void *value, size_t size, int flags, int type) 643 { 644 struct inode *inode = dentry->d_inode; 645 struct posix_acl *acl = NULL; 646 int ret; 647 648 if (!IS_POSIXACL(inode)) 649 return -EOPNOTSUPP; 650 if (!inode->i_op->set_acl) 651 return -EOPNOTSUPP; 652 653 if (type == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) 654 return value ? -EACCES : 0; 655 if (!inode_owner_or_capable(inode)) 656 return -EPERM; 657 658 if (value) { 659 acl = posix_acl_from_xattr(&init_user_ns, value, size); 660 if (IS_ERR(acl)) 661 return PTR_ERR(acl); 662 663 if (acl) { 664 ret = posix_acl_valid(acl); 665 if (ret) 666 goto out; 667 } 668 } 669 670 ret = inode->i_op->set_acl(inode, acl, type); 671 out: 672 posix_acl_release(acl); 673 return ret; 674 } 675 676 static size_t 677 posix_acl_xattr_list(struct dentry *dentry, char *list, size_t list_size, 678 const char *name, size_t name_len, int type) 679 { 680 const char *xname; 681 size_t size; 682 683 if (!IS_POSIXACL(dentry->d_inode)) 684 return -EOPNOTSUPP; 685 if (S_ISLNK(dentry->d_inode->i_mode)) 686 return -EOPNOTSUPP; 687 688 if (type == ACL_TYPE_ACCESS) 689 xname = POSIX_ACL_XATTR_ACCESS; 690 else 691 xname = POSIX_ACL_XATTR_DEFAULT; 692 693 size = strlen(xname) + 1; 694 if (list && size <= list_size) 695 memcpy(list, xname, size); 696 return size; 697 } 698 699 const struct xattr_handler posix_acl_access_xattr_handler = { 700 .prefix = POSIX_ACL_XATTR_ACCESS, 701 .flags = ACL_TYPE_ACCESS, 702 .list = posix_acl_xattr_list, 703 .get = posix_acl_xattr_get, 704 .set = posix_acl_xattr_set, 705 }; 706 EXPORT_SYMBOL_GPL(posix_acl_access_xattr_handler); 707 708 const struct xattr_handler posix_acl_default_xattr_handler = { 709 .prefix = POSIX_ACL_XATTR_DEFAULT, 710 .flags = ACL_TYPE_DEFAULT, 711 .list = posix_acl_xattr_list, 712 .get = posix_acl_xattr_get, 713 .set = posix_acl_xattr_set, 714 }; 715 EXPORT_SYMBOL_GPL(posix_acl_default_xattr_handler); 716