1 /* 2 * Common NFSv4 ACL handling code. 3 * 4 * Copyright (c) 2002, 2003 The Regents of the University of Michigan. 5 * All rights reserved. 6 * 7 * Marius Aamodt Eriksen <marius@umich.edu> 8 * Jeff Sedlak <jsedlak@umich.edu> 9 * J. Bruce Fields <bfields@umich.edu> 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 3. Neither the name of the University nor the names of its 21 * contributors may be used to endorse or promote products derived 22 * from this software without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 25 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 26 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 27 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 31 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 32 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 33 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 34 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 35 */ 36 37 #include <linux/slab.h> 38 #include <linux/nfs_fs.h> 39 #include "nfsfh.h" 40 #include "nfsd.h" 41 #include "acl.h" 42 #include "vfs.h" 43 44 #define NFS4_ACL_TYPE_DEFAULT 0x01 45 #define NFS4_ACL_DIR 0x02 46 #define NFS4_ACL_OWNER 0x04 47 48 /* mode bit translations: */ 49 #define NFS4_READ_MODE (NFS4_ACE_READ_DATA) 50 #define NFS4_WRITE_MODE (NFS4_ACE_WRITE_DATA | NFS4_ACE_APPEND_DATA) 51 #define NFS4_EXECUTE_MODE NFS4_ACE_EXECUTE 52 #define NFS4_ANYONE_MODE (NFS4_ACE_READ_ATTRIBUTES | NFS4_ACE_READ_ACL | NFS4_ACE_SYNCHRONIZE) 53 #define NFS4_OWNER_MODE (NFS4_ACE_WRITE_ATTRIBUTES | NFS4_ACE_WRITE_ACL) 54 55 /* We don't support these bits; insist they be neither allowed nor denied */ 56 #define NFS4_MASK_UNSUPP (NFS4_ACE_DELETE | NFS4_ACE_WRITE_OWNER \ 57 | NFS4_ACE_READ_NAMED_ATTRS | NFS4_ACE_WRITE_NAMED_ATTRS) 58 59 /* flags used to simulate posix default ACLs */ 60 #define NFS4_INHERITANCE_FLAGS (NFS4_ACE_FILE_INHERIT_ACE \ 61 | NFS4_ACE_DIRECTORY_INHERIT_ACE) 62 63 #define NFS4_SUPPORTED_FLAGS (NFS4_INHERITANCE_FLAGS \ 64 | NFS4_ACE_INHERIT_ONLY_ACE \ 65 | NFS4_ACE_IDENTIFIER_GROUP) 66 67 #define MASK_EQUAL(mask1, mask2) \ 68 ( ((mask1) & NFS4_ACE_MASK_ALL) == ((mask2) & NFS4_ACE_MASK_ALL) ) 69 70 static u32 71 mask_from_posix(unsigned short perm, unsigned int flags) 72 { 73 int mask = NFS4_ANYONE_MODE; 74 75 if (flags & NFS4_ACL_OWNER) 76 mask |= NFS4_OWNER_MODE; 77 if (perm & ACL_READ) 78 mask |= NFS4_READ_MODE; 79 if (perm & ACL_WRITE) 80 mask |= NFS4_WRITE_MODE; 81 if ((perm & ACL_WRITE) && (flags & NFS4_ACL_DIR)) 82 mask |= NFS4_ACE_DELETE_CHILD; 83 if (perm & ACL_EXECUTE) 84 mask |= NFS4_EXECUTE_MODE; 85 return mask; 86 } 87 88 static u32 89 deny_mask_from_posix(unsigned short perm, u32 flags) 90 { 91 u32 mask = 0; 92 93 if (perm & ACL_READ) 94 mask |= NFS4_READ_MODE; 95 if (perm & ACL_WRITE) 96 mask |= NFS4_WRITE_MODE; 97 if ((perm & ACL_WRITE) && (flags & NFS4_ACL_DIR)) 98 mask |= NFS4_ACE_DELETE_CHILD; 99 if (perm & ACL_EXECUTE) 100 mask |= NFS4_EXECUTE_MODE; 101 return mask; 102 } 103 104 /* XXX: modify functions to return NFS errors; they're only ever 105 * used by nfs code, after all.... */ 106 107 /* We only map from NFSv4 to POSIX ACLs when setting ACLs, when we err on the 108 * side of being more restrictive, so the mode bit mapping below is 109 * pessimistic. An optimistic version would be needed to handle DENY's, 110 * but we espect to coalesce all ALLOWs and DENYs before mapping to mode 111 * bits. */ 112 113 static void 114 low_mode_from_nfs4(u32 perm, unsigned short *mode, unsigned int flags) 115 { 116 u32 write_mode = NFS4_WRITE_MODE; 117 118 if (flags & NFS4_ACL_DIR) 119 write_mode |= NFS4_ACE_DELETE_CHILD; 120 *mode = 0; 121 if ((perm & NFS4_READ_MODE) == NFS4_READ_MODE) 122 *mode |= ACL_READ; 123 if ((perm & write_mode) == write_mode) 124 *mode |= ACL_WRITE; 125 if ((perm & NFS4_EXECUTE_MODE) == NFS4_EXECUTE_MODE) 126 *mode |= ACL_EXECUTE; 127 } 128 129 struct ace_container { 130 struct nfs4_ace *ace; 131 struct list_head ace_l; 132 }; 133 134 static short ace2type(struct nfs4_ace *); 135 static void _posix_to_nfsv4_one(struct posix_acl *, struct nfs4_acl *, 136 unsigned int); 137 138 int 139 nfsd4_get_nfs4_acl(struct svc_rqst *rqstp, struct dentry *dentry, 140 struct nfs4_acl **acl) 141 { 142 struct inode *inode = dentry->d_inode; 143 int error = 0; 144 struct posix_acl *pacl = NULL, *dpacl = NULL; 145 unsigned int flags = 0; 146 int size = 0; 147 148 pacl = get_acl(inode, ACL_TYPE_ACCESS); 149 if (!pacl) { 150 pacl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL); 151 if (IS_ERR(pacl)) 152 return PTR_ERR(pacl); 153 } 154 /* allocate for worst case: one (deny, allow) pair each: */ 155 size += 2 * pacl->a_count; 156 157 if (S_ISDIR(inode->i_mode)) { 158 flags = NFS4_ACL_DIR; 159 dpacl = get_acl(inode, ACL_TYPE_DEFAULT); 160 if (dpacl) 161 size += 2 * dpacl->a_count; 162 } 163 164 *acl = nfs4_acl_new(size); 165 if (*acl == NULL) { 166 error = -ENOMEM; 167 goto out; 168 } 169 170 _posix_to_nfsv4_one(pacl, *acl, flags & ~NFS4_ACL_TYPE_DEFAULT); 171 172 if (dpacl) 173 _posix_to_nfsv4_one(dpacl, *acl, flags | NFS4_ACL_TYPE_DEFAULT); 174 175 out: 176 posix_acl_release(pacl); 177 posix_acl_release(dpacl); 178 return error; 179 } 180 181 struct posix_acl_summary { 182 unsigned short owner; 183 unsigned short users; 184 unsigned short group; 185 unsigned short groups; 186 unsigned short other; 187 unsigned short mask; 188 }; 189 190 static void 191 summarize_posix_acl(struct posix_acl *acl, struct posix_acl_summary *pas) 192 { 193 struct posix_acl_entry *pa, *pe; 194 195 /* 196 * Only pas.users and pas.groups need initialization; previous 197 * posix_acl_valid() calls ensure that the other fields will be 198 * initialized in the following loop. But, just to placate gcc: 199 */ 200 memset(pas, 0, sizeof(*pas)); 201 pas->mask = 07; 202 203 pe = acl->a_entries + acl->a_count; 204 205 FOREACH_ACL_ENTRY(pa, acl, pe) { 206 switch (pa->e_tag) { 207 case ACL_USER_OBJ: 208 pas->owner = pa->e_perm; 209 break; 210 case ACL_GROUP_OBJ: 211 pas->group = pa->e_perm; 212 break; 213 case ACL_USER: 214 pas->users |= pa->e_perm; 215 break; 216 case ACL_GROUP: 217 pas->groups |= pa->e_perm; 218 break; 219 case ACL_OTHER: 220 pas->other = pa->e_perm; 221 break; 222 case ACL_MASK: 223 pas->mask = pa->e_perm; 224 break; 225 } 226 } 227 /* We'll only care about effective permissions: */ 228 pas->users &= pas->mask; 229 pas->group &= pas->mask; 230 pas->groups &= pas->mask; 231 } 232 233 /* We assume the acl has been verified with posix_acl_valid. */ 234 static void 235 _posix_to_nfsv4_one(struct posix_acl *pacl, struct nfs4_acl *acl, 236 unsigned int flags) 237 { 238 struct posix_acl_entry *pa, *group_owner_entry; 239 struct nfs4_ace *ace; 240 struct posix_acl_summary pas; 241 unsigned short deny; 242 int eflag = ((flags & NFS4_ACL_TYPE_DEFAULT) ? 243 NFS4_INHERITANCE_FLAGS | NFS4_ACE_INHERIT_ONLY_ACE : 0); 244 245 BUG_ON(pacl->a_count < 3); 246 summarize_posix_acl(pacl, &pas); 247 248 pa = pacl->a_entries; 249 ace = acl->aces + acl->naces; 250 251 /* We could deny everything not granted by the owner: */ 252 deny = ~pas.owner; 253 /* 254 * but it is equivalent (and simpler) to deny only what is not 255 * granted by later entries: 256 */ 257 deny &= pas.users | pas.group | pas.groups | pas.other; 258 if (deny) { 259 ace->type = NFS4_ACE_ACCESS_DENIED_ACE_TYPE; 260 ace->flag = eflag; 261 ace->access_mask = deny_mask_from_posix(deny, flags); 262 ace->whotype = NFS4_ACL_WHO_OWNER; 263 ace++; 264 acl->naces++; 265 } 266 267 ace->type = NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE; 268 ace->flag = eflag; 269 ace->access_mask = mask_from_posix(pa->e_perm, flags | NFS4_ACL_OWNER); 270 ace->whotype = NFS4_ACL_WHO_OWNER; 271 ace++; 272 acl->naces++; 273 pa++; 274 275 while (pa->e_tag == ACL_USER) { 276 deny = ~(pa->e_perm & pas.mask); 277 deny &= pas.groups | pas.group | pas.other; 278 if (deny) { 279 ace->type = NFS4_ACE_ACCESS_DENIED_ACE_TYPE; 280 ace->flag = eflag; 281 ace->access_mask = deny_mask_from_posix(deny, flags); 282 ace->whotype = NFS4_ACL_WHO_NAMED; 283 ace->who_uid = pa->e_uid; 284 ace++; 285 acl->naces++; 286 } 287 ace->type = NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE; 288 ace->flag = eflag; 289 ace->access_mask = mask_from_posix(pa->e_perm & pas.mask, 290 flags); 291 ace->whotype = NFS4_ACL_WHO_NAMED; 292 ace->who_uid = pa->e_uid; 293 ace++; 294 acl->naces++; 295 pa++; 296 } 297 298 /* In the case of groups, we apply allow ACEs first, then deny ACEs, 299 * since a user can be in more than one group. */ 300 301 /* allow ACEs */ 302 303 group_owner_entry = pa; 304 305 ace->type = NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE; 306 ace->flag = eflag; 307 ace->access_mask = mask_from_posix(pas.group, flags); 308 ace->whotype = NFS4_ACL_WHO_GROUP; 309 ace++; 310 acl->naces++; 311 pa++; 312 313 while (pa->e_tag == ACL_GROUP) { 314 ace->type = NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE; 315 ace->flag = eflag | NFS4_ACE_IDENTIFIER_GROUP; 316 ace->access_mask = mask_from_posix(pa->e_perm & pas.mask, 317 flags); 318 ace->whotype = NFS4_ACL_WHO_NAMED; 319 ace->who_gid = pa->e_gid; 320 ace++; 321 acl->naces++; 322 pa++; 323 } 324 325 /* deny ACEs */ 326 327 pa = group_owner_entry; 328 329 deny = ~pas.group & pas.other; 330 if (deny) { 331 ace->type = NFS4_ACE_ACCESS_DENIED_ACE_TYPE; 332 ace->flag = eflag; 333 ace->access_mask = deny_mask_from_posix(deny, flags); 334 ace->whotype = NFS4_ACL_WHO_GROUP; 335 ace++; 336 acl->naces++; 337 } 338 pa++; 339 340 while (pa->e_tag == ACL_GROUP) { 341 deny = ~(pa->e_perm & pas.mask); 342 deny &= pas.other; 343 if (deny) { 344 ace->type = NFS4_ACE_ACCESS_DENIED_ACE_TYPE; 345 ace->flag = eflag | NFS4_ACE_IDENTIFIER_GROUP; 346 ace->access_mask = deny_mask_from_posix(deny, flags); 347 ace->whotype = NFS4_ACL_WHO_NAMED; 348 ace->who_gid = pa->e_gid; 349 ace++; 350 acl->naces++; 351 } 352 pa++; 353 } 354 355 if (pa->e_tag == ACL_MASK) 356 pa++; 357 ace->type = NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE; 358 ace->flag = eflag; 359 ace->access_mask = mask_from_posix(pa->e_perm, flags); 360 ace->whotype = NFS4_ACL_WHO_EVERYONE; 361 acl->naces++; 362 } 363 364 static bool 365 pace_gt(struct posix_acl_entry *pace1, struct posix_acl_entry *pace2) 366 { 367 if (pace1->e_tag != pace2->e_tag) 368 return pace1->e_tag > pace2->e_tag; 369 if (pace1->e_tag == ACL_USER) 370 return uid_gt(pace1->e_uid, pace2->e_uid); 371 if (pace1->e_tag == ACL_GROUP) 372 return gid_gt(pace1->e_gid, pace2->e_gid); 373 return false; 374 } 375 376 static void 377 sort_pacl_range(struct posix_acl *pacl, int start, int end) { 378 int sorted = 0, i; 379 struct posix_acl_entry tmp; 380 381 /* We just do a bubble sort; easy to do in place, and we're not 382 * expecting acl's to be long enough to justify anything more. */ 383 while (!sorted) { 384 sorted = 1; 385 for (i = start; i < end; i++) { 386 if (pace_gt(&pacl->a_entries[i], 387 &pacl->a_entries[i+1])) { 388 sorted = 0; 389 tmp = pacl->a_entries[i]; 390 pacl->a_entries[i] = pacl->a_entries[i+1]; 391 pacl->a_entries[i+1] = tmp; 392 } 393 } 394 } 395 } 396 397 static void 398 sort_pacl(struct posix_acl *pacl) 399 { 400 /* posix_acl_valid requires that users and groups be in order 401 * by uid/gid. */ 402 int i, j; 403 404 if (pacl->a_count <= 4) 405 return; /* no users or groups */ 406 i = 1; 407 while (pacl->a_entries[i].e_tag == ACL_USER) 408 i++; 409 sort_pacl_range(pacl, 1, i-1); 410 411 BUG_ON(pacl->a_entries[i].e_tag != ACL_GROUP_OBJ); 412 j = ++i; 413 while (pacl->a_entries[j].e_tag == ACL_GROUP) 414 j++; 415 sort_pacl_range(pacl, i, j-1); 416 return; 417 } 418 419 /* 420 * While processing the NFSv4 ACE, this maintains bitmasks representing 421 * which permission bits have been allowed and which denied to a given 422 * entity: */ 423 struct posix_ace_state { 424 u32 allow; 425 u32 deny; 426 }; 427 428 struct posix_user_ace_state { 429 union { 430 kuid_t uid; 431 kgid_t gid; 432 }; 433 struct posix_ace_state perms; 434 }; 435 436 struct posix_ace_state_array { 437 int n; 438 struct posix_user_ace_state aces[]; 439 }; 440 441 /* 442 * While processing the NFSv4 ACE, this maintains the partial permissions 443 * calculated so far: */ 444 445 struct posix_acl_state { 446 int empty; 447 struct posix_ace_state owner; 448 struct posix_ace_state group; 449 struct posix_ace_state other; 450 struct posix_ace_state everyone; 451 struct posix_ace_state mask; /* Deny unused in this case */ 452 struct posix_ace_state_array *users; 453 struct posix_ace_state_array *groups; 454 }; 455 456 static int 457 init_state(struct posix_acl_state *state, int cnt) 458 { 459 int alloc; 460 461 memset(state, 0, sizeof(struct posix_acl_state)); 462 state->empty = 1; 463 /* 464 * In the worst case, each individual acl could be for a distinct 465 * named user or group, but we don't no which, so we allocate 466 * enough space for either: 467 */ 468 alloc = sizeof(struct posix_ace_state_array) 469 + cnt*sizeof(struct posix_user_ace_state); 470 state->users = kzalloc(alloc, GFP_KERNEL); 471 if (!state->users) 472 return -ENOMEM; 473 state->groups = kzalloc(alloc, GFP_KERNEL); 474 if (!state->groups) { 475 kfree(state->users); 476 return -ENOMEM; 477 } 478 return 0; 479 } 480 481 static void 482 free_state(struct posix_acl_state *state) { 483 kfree(state->users); 484 kfree(state->groups); 485 } 486 487 static inline void add_to_mask(struct posix_acl_state *state, struct posix_ace_state *astate) 488 { 489 state->mask.allow |= astate->allow; 490 } 491 492 /* 493 * Certain bits (SYNCHRONIZE, DELETE, WRITE_OWNER, READ/WRITE_NAMED_ATTRS, 494 * READ_ATTRIBUTES, READ_ACL) are currently unenforceable and don't translate 495 * to traditional read/write/execute permissions. 496 * 497 * It's problematic to reject acls that use certain mode bits, because it 498 * places the burden on users to learn the rules about which bits one 499 * particular server sets, without giving the user a lot of help--we return an 500 * error that could mean any number of different things. To make matters 501 * worse, the problematic bits might be introduced by some application that's 502 * automatically mapping from some other acl model. 503 * 504 * So wherever possible we accept anything, possibly erring on the side of 505 * denying more permissions than necessary. 506 * 507 * However we do reject *explicit* DENY's of a few bits representing 508 * permissions we could never deny: 509 */ 510 511 static inline int check_deny(u32 mask, int isowner) 512 { 513 if (mask & (NFS4_ACE_READ_ATTRIBUTES | NFS4_ACE_READ_ACL)) 514 return -EINVAL; 515 if (!isowner) 516 return 0; 517 if (mask & (NFS4_ACE_WRITE_ATTRIBUTES | NFS4_ACE_WRITE_ACL)) 518 return -EINVAL; 519 return 0; 520 } 521 522 static struct posix_acl * 523 posix_state_to_acl(struct posix_acl_state *state, unsigned int flags) 524 { 525 struct posix_acl_entry *pace; 526 struct posix_acl *pacl; 527 int nace; 528 int i, error = 0; 529 530 /* 531 * ACLs with no ACEs are treated differently in the inheritable 532 * and effective cases: when there are no inheritable ACEs, we 533 * set a zero-length default posix acl: 534 */ 535 if (state->empty && (flags & NFS4_ACL_TYPE_DEFAULT)) { 536 pacl = posix_acl_alloc(0, GFP_KERNEL); 537 return pacl ? pacl : ERR_PTR(-ENOMEM); 538 } 539 /* 540 * When there are no effective ACEs, the following will end 541 * up setting a 3-element effective posix ACL with all 542 * permissions zero. 543 */ 544 if (!state->users->n && !state->groups->n) 545 nace = 3; 546 else /* Note we also include a MASK ACE in this case: */ 547 nace = 4 + state->users->n + state->groups->n; 548 pacl = posix_acl_alloc(nace, GFP_KERNEL); 549 if (!pacl) 550 return ERR_PTR(-ENOMEM); 551 552 pace = pacl->a_entries; 553 pace->e_tag = ACL_USER_OBJ; 554 error = check_deny(state->owner.deny, 1); 555 if (error) 556 goto out_err; 557 low_mode_from_nfs4(state->owner.allow, &pace->e_perm, flags); 558 559 for (i=0; i < state->users->n; i++) { 560 pace++; 561 pace->e_tag = ACL_USER; 562 error = check_deny(state->users->aces[i].perms.deny, 0); 563 if (error) 564 goto out_err; 565 low_mode_from_nfs4(state->users->aces[i].perms.allow, 566 &pace->e_perm, flags); 567 pace->e_uid = state->users->aces[i].uid; 568 add_to_mask(state, &state->users->aces[i].perms); 569 } 570 571 pace++; 572 pace->e_tag = ACL_GROUP_OBJ; 573 error = check_deny(state->group.deny, 0); 574 if (error) 575 goto out_err; 576 low_mode_from_nfs4(state->group.allow, &pace->e_perm, flags); 577 add_to_mask(state, &state->group); 578 579 for (i=0; i < state->groups->n; i++) { 580 pace++; 581 pace->e_tag = ACL_GROUP; 582 error = check_deny(state->groups->aces[i].perms.deny, 0); 583 if (error) 584 goto out_err; 585 low_mode_from_nfs4(state->groups->aces[i].perms.allow, 586 &pace->e_perm, flags); 587 pace->e_gid = state->groups->aces[i].gid; 588 add_to_mask(state, &state->groups->aces[i].perms); 589 } 590 591 if (!state->users->n && !state->groups->n) { 592 pace++; 593 pace->e_tag = ACL_MASK; 594 low_mode_from_nfs4(state->mask.allow, &pace->e_perm, flags); 595 } 596 597 pace++; 598 pace->e_tag = ACL_OTHER; 599 error = check_deny(state->other.deny, 0); 600 if (error) 601 goto out_err; 602 low_mode_from_nfs4(state->other.allow, &pace->e_perm, flags); 603 604 return pacl; 605 out_err: 606 posix_acl_release(pacl); 607 return ERR_PTR(error); 608 } 609 610 static inline void allow_bits(struct posix_ace_state *astate, u32 mask) 611 { 612 /* Allow all bits in the mask not already denied: */ 613 astate->allow |= mask & ~astate->deny; 614 } 615 616 static inline void deny_bits(struct posix_ace_state *astate, u32 mask) 617 { 618 /* Deny all bits in the mask not already allowed: */ 619 astate->deny |= mask & ~astate->allow; 620 } 621 622 static int find_uid(struct posix_acl_state *state, kuid_t uid) 623 { 624 struct posix_ace_state_array *a = state->users; 625 int i; 626 627 for (i = 0; i < a->n; i++) 628 if (uid_eq(a->aces[i].uid, uid)) 629 return i; 630 /* Not found: */ 631 a->n++; 632 a->aces[i].uid = uid; 633 a->aces[i].perms.allow = state->everyone.allow; 634 a->aces[i].perms.deny = state->everyone.deny; 635 636 return i; 637 } 638 639 static int find_gid(struct posix_acl_state *state, kgid_t gid) 640 { 641 struct posix_ace_state_array *a = state->groups; 642 int i; 643 644 for (i = 0; i < a->n; i++) 645 if (gid_eq(a->aces[i].gid, gid)) 646 return i; 647 /* Not found: */ 648 a->n++; 649 a->aces[i].gid = gid; 650 a->aces[i].perms.allow = state->everyone.allow; 651 a->aces[i].perms.deny = state->everyone.deny; 652 653 return i; 654 } 655 656 static void deny_bits_array(struct posix_ace_state_array *a, u32 mask) 657 { 658 int i; 659 660 for (i=0; i < a->n; i++) 661 deny_bits(&a->aces[i].perms, mask); 662 } 663 664 static void allow_bits_array(struct posix_ace_state_array *a, u32 mask) 665 { 666 int i; 667 668 for (i=0; i < a->n; i++) 669 allow_bits(&a->aces[i].perms, mask); 670 } 671 672 static void process_one_v4_ace(struct posix_acl_state *state, 673 struct nfs4_ace *ace) 674 { 675 u32 mask = ace->access_mask; 676 int i; 677 678 state->empty = 0; 679 680 switch (ace2type(ace)) { 681 case ACL_USER_OBJ: 682 if (ace->type == NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE) { 683 allow_bits(&state->owner, mask); 684 } else { 685 deny_bits(&state->owner, mask); 686 } 687 break; 688 case ACL_USER: 689 i = find_uid(state, ace->who_uid); 690 if (ace->type == NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE) { 691 allow_bits(&state->users->aces[i].perms, mask); 692 } else { 693 deny_bits(&state->users->aces[i].perms, mask); 694 mask = state->users->aces[i].perms.deny; 695 deny_bits(&state->owner, mask); 696 } 697 break; 698 case ACL_GROUP_OBJ: 699 if (ace->type == NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE) { 700 allow_bits(&state->group, mask); 701 } else { 702 deny_bits(&state->group, mask); 703 mask = state->group.deny; 704 deny_bits(&state->owner, mask); 705 deny_bits(&state->everyone, mask); 706 deny_bits_array(state->users, mask); 707 deny_bits_array(state->groups, mask); 708 } 709 break; 710 case ACL_GROUP: 711 i = find_gid(state, ace->who_gid); 712 if (ace->type == NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE) { 713 allow_bits(&state->groups->aces[i].perms, mask); 714 } else { 715 deny_bits(&state->groups->aces[i].perms, mask); 716 mask = state->groups->aces[i].perms.deny; 717 deny_bits(&state->owner, mask); 718 deny_bits(&state->group, mask); 719 deny_bits(&state->everyone, mask); 720 deny_bits_array(state->users, mask); 721 deny_bits_array(state->groups, mask); 722 } 723 break; 724 case ACL_OTHER: 725 if (ace->type == NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE) { 726 allow_bits(&state->owner, mask); 727 allow_bits(&state->group, mask); 728 allow_bits(&state->other, mask); 729 allow_bits(&state->everyone, mask); 730 allow_bits_array(state->users, mask); 731 allow_bits_array(state->groups, mask); 732 } else { 733 deny_bits(&state->owner, mask); 734 deny_bits(&state->group, mask); 735 deny_bits(&state->other, mask); 736 deny_bits(&state->everyone, mask); 737 deny_bits_array(state->users, mask); 738 deny_bits_array(state->groups, mask); 739 } 740 } 741 } 742 743 static int nfs4_acl_nfsv4_to_posix(struct nfs4_acl *acl, 744 struct posix_acl **pacl, struct posix_acl **dpacl, 745 unsigned int flags) 746 { 747 struct posix_acl_state effective_acl_state, default_acl_state; 748 struct nfs4_ace *ace; 749 int ret; 750 751 ret = init_state(&effective_acl_state, acl->naces); 752 if (ret) 753 return ret; 754 ret = init_state(&default_acl_state, acl->naces); 755 if (ret) 756 goto out_estate; 757 ret = -EINVAL; 758 for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) { 759 if (ace->type != NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE && 760 ace->type != NFS4_ACE_ACCESS_DENIED_ACE_TYPE) 761 goto out_dstate; 762 if (ace->flag & ~NFS4_SUPPORTED_FLAGS) 763 goto out_dstate; 764 if ((ace->flag & NFS4_INHERITANCE_FLAGS) == 0) { 765 process_one_v4_ace(&effective_acl_state, ace); 766 continue; 767 } 768 if (!(flags & NFS4_ACL_DIR)) 769 goto out_dstate; 770 /* 771 * Note that when only one of FILE_INHERIT or DIRECTORY_INHERIT 772 * is set, we're effectively turning on the other. That's OK, 773 * according to rfc 3530. 774 */ 775 process_one_v4_ace(&default_acl_state, ace); 776 777 if (!(ace->flag & NFS4_ACE_INHERIT_ONLY_ACE)) 778 process_one_v4_ace(&effective_acl_state, ace); 779 } 780 *pacl = posix_state_to_acl(&effective_acl_state, flags); 781 if (IS_ERR(*pacl)) { 782 ret = PTR_ERR(*pacl); 783 *pacl = NULL; 784 goto out_dstate; 785 } 786 *dpacl = posix_state_to_acl(&default_acl_state, 787 flags | NFS4_ACL_TYPE_DEFAULT); 788 if (IS_ERR(*dpacl)) { 789 ret = PTR_ERR(*dpacl); 790 *dpacl = NULL; 791 posix_acl_release(*pacl); 792 *pacl = NULL; 793 goto out_dstate; 794 } 795 sort_pacl(*pacl); 796 sort_pacl(*dpacl); 797 ret = 0; 798 out_dstate: 799 free_state(&default_acl_state); 800 out_estate: 801 free_state(&effective_acl_state); 802 return ret; 803 } 804 805 __be32 806 nfsd4_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp, 807 struct nfs4_acl *acl) 808 { 809 __be32 error; 810 int host_error; 811 struct dentry *dentry; 812 struct inode *inode; 813 struct posix_acl *pacl = NULL, *dpacl = NULL; 814 unsigned int flags = 0; 815 816 /* Get inode */ 817 error = fh_verify(rqstp, fhp, 0, NFSD_MAY_SATTR); 818 if (error) 819 return error; 820 821 dentry = fhp->fh_dentry; 822 inode = dentry->d_inode; 823 824 if (!inode->i_op->set_acl || !IS_POSIXACL(inode)) 825 return nfserr_attrnotsupp; 826 827 if (S_ISDIR(inode->i_mode)) 828 flags = NFS4_ACL_DIR; 829 830 host_error = nfs4_acl_nfsv4_to_posix(acl, &pacl, &dpacl, flags); 831 if (host_error == -EINVAL) 832 return nfserr_attrnotsupp; 833 if (host_error < 0) 834 goto out_nfserr; 835 836 host_error = inode->i_op->set_acl(inode, pacl, ACL_TYPE_ACCESS); 837 if (host_error < 0) 838 goto out_release; 839 840 if (S_ISDIR(inode->i_mode)) { 841 host_error = inode->i_op->set_acl(inode, dpacl, 842 ACL_TYPE_DEFAULT); 843 } 844 845 out_release: 846 posix_acl_release(pacl); 847 posix_acl_release(dpacl); 848 out_nfserr: 849 if (host_error == -EOPNOTSUPP) 850 return nfserr_attrnotsupp; 851 else 852 return nfserrno(host_error); 853 } 854 855 856 static short 857 ace2type(struct nfs4_ace *ace) 858 { 859 switch (ace->whotype) { 860 case NFS4_ACL_WHO_NAMED: 861 return (ace->flag & NFS4_ACE_IDENTIFIER_GROUP ? 862 ACL_GROUP : ACL_USER); 863 case NFS4_ACL_WHO_OWNER: 864 return ACL_USER_OBJ; 865 case NFS4_ACL_WHO_GROUP: 866 return ACL_GROUP_OBJ; 867 case NFS4_ACL_WHO_EVERYONE: 868 return ACL_OTHER; 869 } 870 BUG(); 871 return -1; 872 } 873 874 struct nfs4_acl * 875 nfs4_acl_new(int n) 876 { 877 struct nfs4_acl *acl; 878 879 acl = kmalloc(sizeof(*acl) + n*sizeof(struct nfs4_ace), GFP_KERNEL); 880 if (acl == NULL) 881 return NULL; 882 acl->naces = 0; 883 return acl; 884 } 885 886 static struct { 887 char *string; 888 int stringlen; 889 int type; 890 } s2t_map[] = { 891 { 892 .string = "OWNER@", 893 .stringlen = sizeof("OWNER@") - 1, 894 .type = NFS4_ACL_WHO_OWNER, 895 }, 896 { 897 .string = "GROUP@", 898 .stringlen = sizeof("GROUP@") - 1, 899 .type = NFS4_ACL_WHO_GROUP, 900 }, 901 { 902 .string = "EVERYONE@", 903 .stringlen = sizeof("EVERYONE@") - 1, 904 .type = NFS4_ACL_WHO_EVERYONE, 905 }, 906 }; 907 908 int 909 nfs4_acl_get_whotype(char *p, u32 len) 910 { 911 int i; 912 913 for (i = 0; i < ARRAY_SIZE(s2t_map); i++) { 914 if (s2t_map[i].stringlen == len && 915 0 == memcmp(s2t_map[i].string, p, len)) 916 return s2t_map[i].type; 917 } 918 return NFS4_ACL_WHO_NAMED; 919 } 920 921 __be32 nfs4_acl_write_who(int who, __be32 **p, int *len) 922 { 923 int i; 924 int bytes; 925 926 for (i = 0; i < ARRAY_SIZE(s2t_map); i++) { 927 if (s2t_map[i].type != who) 928 continue; 929 bytes = 4 + (XDR_QUADLEN(s2t_map[i].stringlen) << 2); 930 if (bytes > *len) 931 return nfserr_resource; 932 *p = xdr_encode_opaque(*p, s2t_map[i].string, 933 s2t_map[i].stringlen); 934 *len -= bytes; 935 return 0; 936 } 937 WARN_ON_ONCE(1); 938 return -1; 939 } 940