]>
Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
1da177e4 LT |
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 | ||
5a0e3ad6 | 37 | #include <linux/slab.h> |
1da177e4 | 38 | #include <linux/nfs_fs.h> |
afeacc8c | 39 | #include <linux/export.h> |
2ca72e17 | 40 | #include "acl.h" |
1da177e4 LT |
41 | |
42 | ||
43 | /* mode bit translations: */ | |
44 | #define NFS4_READ_MODE (NFS4_ACE_READ_DATA) | |
45 | #define NFS4_WRITE_MODE (NFS4_ACE_WRITE_DATA | NFS4_ACE_APPEND_DATA) | |
46 | #define NFS4_EXECUTE_MODE NFS4_ACE_EXECUTE | |
47 | #define NFS4_ANYONE_MODE (NFS4_ACE_READ_ATTRIBUTES | NFS4_ACE_READ_ACL | NFS4_ACE_SYNCHRONIZE) | |
48 | #define NFS4_OWNER_MODE (NFS4_ACE_WRITE_ATTRIBUTES | NFS4_ACE_WRITE_ACL) | |
49 | ||
50 | /* We don't support these bits; insist they be neither allowed nor denied */ | |
51 | #define NFS4_MASK_UNSUPP (NFS4_ACE_DELETE | NFS4_ACE_WRITE_OWNER \ | |
52 | | NFS4_ACE_READ_NAMED_ATTRS | NFS4_ACE_WRITE_NAMED_ATTRS) | |
53 | ||
54 | /* flags used to simulate posix default ACLs */ | |
55 | #define NFS4_INHERITANCE_FLAGS (NFS4_ACE_FILE_INHERIT_ACE \ | |
7bdfa68c | 56 | | NFS4_ACE_DIRECTORY_INHERIT_ACE) |
1da177e4 | 57 | |
7bdfa68c BF |
58 | #define NFS4_SUPPORTED_FLAGS (NFS4_INHERITANCE_FLAGS \ |
59 | | NFS4_ACE_INHERIT_ONLY_ACE \ | |
60 | | NFS4_ACE_IDENTIFIER_GROUP) | |
b548edc2 | 61 | |
1da177e4 LT |
62 | #define MASK_EQUAL(mask1, mask2) \ |
63 | ( ((mask1) & NFS4_ACE_MASK_ALL) == ((mask2) & NFS4_ACE_MASK_ALL) ) | |
64 | ||
65 | static u32 | |
66 | mask_from_posix(unsigned short perm, unsigned int flags) | |
67 | { | |
68 | int mask = NFS4_ANYONE_MODE; | |
69 | ||
70 | if (flags & NFS4_ACL_OWNER) | |
71 | mask |= NFS4_OWNER_MODE; | |
72 | if (perm & ACL_READ) | |
73 | mask |= NFS4_READ_MODE; | |
74 | if (perm & ACL_WRITE) | |
75 | mask |= NFS4_WRITE_MODE; | |
76 | if ((perm & ACL_WRITE) && (flags & NFS4_ACL_DIR)) | |
77 | mask |= NFS4_ACE_DELETE_CHILD; | |
78 | if (perm & ACL_EXECUTE) | |
79 | mask |= NFS4_EXECUTE_MODE; | |
80 | return mask; | |
81 | } | |
82 | ||
83 | static u32 | |
bec50c47 | 84 | deny_mask_from_posix(unsigned short perm, u32 flags) |
1da177e4 | 85 | { |
bec50c47 BF |
86 | u32 mask = 0; |
87 | ||
88 | if (perm & ACL_READ) | |
89 | mask |= NFS4_READ_MODE; | |
90 | if (perm & ACL_WRITE) | |
91 | mask |= NFS4_WRITE_MODE; | |
92 | if ((perm & ACL_WRITE) && (flags & NFS4_ACL_DIR)) | |
93 | mask |= NFS4_ACE_DELETE_CHILD; | |
94 | if (perm & ACL_EXECUTE) | |
95 | mask |= NFS4_EXECUTE_MODE; | |
96 | return mask; | |
1da177e4 LT |
97 | } |
98 | ||
99 | /* XXX: modify functions to return NFS errors; they're only ever | |
100 | * used by nfs code, after all.... */ | |
101 | ||
09229edb BF |
102 | /* We only map from NFSv4 to POSIX ACLs when setting ACLs, when we err on the |
103 | * side of being more restrictive, so the mode bit mapping below is | |
104 | * pessimistic. An optimistic version would be needed to handle DENY's, | |
105 | * but we espect to coalesce all ALLOWs and DENYs before mapping to mode | |
106 | * bits. */ | |
107 | ||
108 | static void | |
109 | low_mode_from_nfs4(u32 perm, unsigned short *mode, unsigned int flags) | |
1da177e4 | 110 | { |
09229edb | 111 | u32 write_mode = NFS4_WRITE_MODE; |
1da177e4 | 112 | |
09229edb BF |
113 | if (flags & NFS4_ACL_DIR) |
114 | write_mode |= NFS4_ACE_DELETE_CHILD; | |
1da177e4 LT |
115 | *mode = 0; |
116 | if ((perm & NFS4_READ_MODE) == NFS4_READ_MODE) | |
117 | *mode |= ACL_READ; | |
09229edb | 118 | if ((perm & write_mode) == write_mode) |
1da177e4 LT |
119 | *mode |= ACL_WRITE; |
120 | if ((perm & NFS4_EXECUTE_MODE) == NFS4_EXECUTE_MODE) | |
121 | *mode |= ACL_EXECUTE; | |
1da177e4 LT |
122 | } |
123 | ||
124 | struct ace_container { | |
125 | struct nfs4_ace *ace; | |
126 | struct list_head ace_l; | |
127 | }; | |
128 | ||
129 | static short ace2type(struct nfs4_ace *); | |
28e05dd8 BF |
130 | static void _posix_to_nfsv4_one(struct posix_acl *, struct nfs4_acl *, |
131 | unsigned int); | |
1da177e4 LT |
132 | |
133 | struct nfs4_acl * | |
134 | nfs4_acl_posix_to_nfsv4(struct posix_acl *pacl, struct posix_acl *dpacl, | |
135 | unsigned int flags) | |
136 | { | |
137 | struct nfs4_acl *acl; | |
28e05dd8 | 138 | int size = 0; |
1da177e4 | 139 | |
28e05dd8 BF |
140 | if (pacl) { |
141 | if (posix_acl_valid(pacl) < 0) | |
142 | return ERR_PTR(-EINVAL); | |
143 | size += 2*pacl->a_count; | |
1da177e4 | 144 | } |
28e05dd8 BF |
145 | if (dpacl) { |
146 | if (posix_acl_valid(dpacl) < 0) | |
147 | return ERR_PTR(-EINVAL); | |
148 | size += 2*dpacl->a_count; | |
1da177e4 LT |
149 | } |
150 | ||
28e05dd8 BF |
151 | /* Allocate for worst case: one (deny, allow) pair each: */ |
152 | acl = nfs4_acl_new(size); | |
153 | if (acl == NULL) | |
154 | return ERR_PTR(-ENOMEM); | |
1da177e4 | 155 | |
28e05dd8 BF |
156 | if (pacl) |
157 | _posix_to_nfsv4_one(pacl, acl, flags & ~NFS4_ACL_TYPE_DEFAULT); | |
1da177e4 | 158 | |
28e05dd8 BF |
159 | if (dpacl) |
160 | _posix_to_nfsv4_one(dpacl, acl, flags | NFS4_ACL_TYPE_DEFAULT); | |
1da177e4 LT |
161 | |
162 | return acl; | |
163 | } | |
164 | ||
bec50c47 BF |
165 | struct posix_acl_summary { |
166 | unsigned short owner; | |
167 | unsigned short users; | |
168 | unsigned short group; | |
169 | unsigned short groups; | |
170 | unsigned short other; | |
171 | unsigned short mask; | |
172 | }; | |
173 | ||
28e05dd8 | 174 | static void |
bec50c47 | 175 | summarize_posix_acl(struct posix_acl *acl, struct posix_acl_summary *pas) |
1da177e4 | 176 | { |
bec50c47 | 177 | struct posix_acl_entry *pa, *pe; |
f7fede4b BF |
178 | |
179 | /* | |
180 | * Only pas.users and pas.groups need initialization; previous | |
181 | * posix_acl_valid() calls ensure that the other fields will be | |
182 | * initialized in the following loop. But, just to placate gcc: | |
183 | */ | |
184 | memset(pas, 0, sizeof(*pas)); | |
bec50c47 BF |
185 | pas->mask = 07; |
186 | ||
187 | pe = acl->a_entries + acl->a_count; | |
188 | ||
189 | FOREACH_ACL_ENTRY(pa, acl, pe) { | |
190 | switch (pa->e_tag) { | |
191 | case ACL_USER_OBJ: | |
192 | pas->owner = pa->e_perm; | |
193 | break; | |
194 | case ACL_GROUP_OBJ: | |
195 | pas->group = pa->e_perm; | |
196 | break; | |
197 | case ACL_USER: | |
198 | pas->users |= pa->e_perm; | |
199 | break; | |
200 | case ACL_GROUP: | |
201 | pas->groups |= pa->e_perm; | |
202 | break; | |
203 | case ACL_OTHER: | |
204 | pas->other = pa->e_perm; | |
205 | break; | |
206 | case ACL_MASK: | |
207 | pas->mask = pa->e_perm; | |
208 | break; | |
209 | } | |
210 | } | |
211 | /* We'll only care about effective permissions: */ | |
212 | pas->users &= pas->mask; | |
213 | pas->group &= pas->mask; | |
214 | pas->groups &= pas->mask; | |
1da177e4 LT |
215 | } |
216 | ||
217 | /* We assume the acl has been verified with posix_acl_valid. */ | |
28e05dd8 | 218 | static void |
1da177e4 LT |
219 | _posix_to_nfsv4_one(struct posix_acl *pacl, struct nfs4_acl *acl, |
220 | unsigned int flags) | |
221 | { | |
bec50c47 BF |
222 | struct posix_acl_entry *pa, *group_owner_entry; |
223 | struct nfs4_ace *ace; | |
224 | struct posix_acl_summary pas; | |
225 | unsigned short deny; | |
1da177e4 | 226 | int eflag = ((flags & NFS4_ACL_TYPE_DEFAULT) ? |
54c04409 | 227 | NFS4_INHERITANCE_FLAGS | NFS4_ACE_INHERIT_ONLY_ACE : 0); |
1da177e4 LT |
228 | |
229 | BUG_ON(pacl->a_count < 3); | |
bec50c47 | 230 | summarize_posix_acl(pacl, &pas); |
1da177e4 LT |
231 | |
232 | pa = pacl->a_entries; | |
bec50c47 BF |
233 | ace = acl->aces + acl->naces; |
234 | ||
235 | /* We could deny everything not granted by the owner: */ | |
236 | deny = ~pas.owner; | |
237 | /* | |
238 | * but it is equivalent (and simpler) to deny only what is not | |
239 | * granted by later entries: | |
240 | */ | |
241 | deny &= pas.users | pas.group | pas.groups | pas.other; | |
242 | if (deny) { | |
243 | ace->type = NFS4_ACE_ACCESS_DENIED_ACE_TYPE; | |
244 | ace->flag = eflag; | |
245 | ace->access_mask = deny_mask_from_posix(deny, flags); | |
246 | ace->whotype = NFS4_ACL_WHO_OWNER; | |
247 | ace++; | |
248 | acl->naces++; | |
249 | } | |
250 | ||
251 | ace->type = NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE; | |
252 | ace->flag = eflag; | |
253 | ace->access_mask = mask_from_posix(pa->e_perm, flags | NFS4_ACL_OWNER); | |
254 | ace->whotype = NFS4_ACL_WHO_OWNER; | |
255 | ace++; | |
256 | acl->naces++; | |
1da177e4 LT |
257 | pa++; |
258 | ||
259 | while (pa->e_tag == ACL_USER) { | |
bec50c47 BF |
260 | deny = ~(pa->e_perm & pas.mask); |
261 | deny &= pas.groups | pas.group | pas.other; | |
262 | if (deny) { | |
263 | ace->type = NFS4_ACE_ACCESS_DENIED_ACE_TYPE; | |
264 | ace->flag = eflag; | |
265 | ace->access_mask = deny_mask_from_posix(deny, flags); | |
266 | ace->whotype = NFS4_ACL_WHO_NAMED; | |
267 | ace->who = pa->e_id; | |
268 | ace++; | |
269 | acl->naces++; | |
270 | } | |
271 | ace->type = NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE; | |
272 | ace->flag = eflag; | |
273 | ace->access_mask = mask_from_posix(pa->e_perm & pas.mask, | |
274 | flags); | |
275 | ace->whotype = NFS4_ACL_WHO_NAMED; | |
276 | ace->who = pa->e_id; | |
277 | ace++; | |
278 | acl->naces++; | |
1da177e4 LT |
279 | pa++; |
280 | } | |
281 | ||
282 | /* In the case of groups, we apply allow ACEs first, then deny ACEs, | |
283 | * since a user can be in more than one group. */ | |
284 | ||
285 | /* allow ACEs */ | |
286 | ||
1da177e4 | 287 | group_owner_entry = pa; |
bec50c47 BF |
288 | |
289 | ace->type = NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE; | |
290 | ace->flag = eflag; | |
291 | ace->access_mask = mask_from_posix(pas.group, flags); | |
292 | ace->whotype = NFS4_ACL_WHO_GROUP; | |
293 | ace++; | |
294 | acl->naces++; | |
1da177e4 LT |
295 | pa++; |
296 | ||
297 | while (pa->e_tag == ACL_GROUP) { | |
bec50c47 BF |
298 | ace->type = NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE; |
299 | ace->flag = eflag | NFS4_ACE_IDENTIFIER_GROUP; | |
300 | ace->access_mask = mask_from_posix(pa->e_perm & pas.mask, | |
301 | flags); | |
302 | ace->whotype = NFS4_ACL_WHO_NAMED; | |
303 | ace->who = pa->e_id; | |
304 | ace++; | |
305 | acl->naces++; | |
1da177e4 LT |
306 | pa++; |
307 | } | |
308 | ||
309 | /* deny ACEs */ | |
310 | ||
311 | pa = group_owner_entry; | |
bec50c47 BF |
312 | |
313 | deny = ~pas.group & pas.other; | |
314 | if (deny) { | |
315 | ace->type = NFS4_ACE_ACCESS_DENIED_ACE_TYPE; | |
d8d0b85b | 316 | ace->flag = eflag; |
bec50c47 BF |
317 | ace->access_mask = deny_mask_from_posix(deny, flags); |
318 | ace->whotype = NFS4_ACL_WHO_GROUP; | |
319 | ace++; | |
320 | acl->naces++; | |
321 | } | |
1da177e4 | 322 | pa++; |
bec50c47 | 323 | |
1da177e4 | 324 | while (pa->e_tag == ACL_GROUP) { |
bec50c47 BF |
325 | deny = ~(pa->e_perm & pas.mask); |
326 | deny &= pas.other; | |
327 | if (deny) { | |
328 | ace->type = NFS4_ACE_ACCESS_DENIED_ACE_TYPE; | |
329 | ace->flag = eflag | NFS4_ACE_IDENTIFIER_GROUP; | |
55bb55dc | 330 | ace->access_mask = deny_mask_from_posix(deny, flags); |
bec50c47 BF |
331 | ace->whotype = NFS4_ACL_WHO_NAMED; |
332 | ace->who = pa->e_id; | |
333 | ace++; | |
334 | acl->naces++; | |
335 | } | |
1da177e4 LT |
336 | pa++; |
337 | } | |
338 | ||
339 | if (pa->e_tag == ACL_MASK) | |
340 | pa++; | |
bec50c47 BF |
341 | ace->type = NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE; |
342 | ace->flag = eflag; | |
343 | ace->access_mask = mask_from_posix(pa->e_perm, flags); | |
344 | ace->whotype = NFS4_ACL_WHO_EVERYONE; | |
345 | acl->naces++; | |
1da177e4 LT |
346 | } |
347 | ||
348 | static void | |
349 | sort_pacl_range(struct posix_acl *pacl, int start, int end) { | |
350 | int sorted = 0, i; | |
351 | struct posix_acl_entry tmp; | |
352 | ||
353 | /* We just do a bubble sort; easy to do in place, and we're not | |
354 | * expecting acl's to be long enough to justify anything more. */ | |
355 | while (!sorted) { | |
356 | sorted = 1; | |
357 | for (i = start; i < end; i++) { | |
358 | if (pacl->a_entries[i].e_id | |
359 | > pacl->a_entries[i+1].e_id) { | |
360 | sorted = 0; | |
361 | tmp = pacl->a_entries[i]; | |
362 | pacl->a_entries[i] = pacl->a_entries[i+1]; | |
363 | pacl->a_entries[i+1] = tmp; | |
364 | } | |
365 | } | |
366 | } | |
367 | } | |
368 | ||
369 | static void | |
370 | sort_pacl(struct posix_acl *pacl) | |
371 | { | |
372 | /* posix_acl_valid requires that users and groups be in order | |
373 | * by uid/gid. */ | |
374 | int i, j; | |
375 | ||
376 | if (pacl->a_count <= 4) | |
377 | return; /* no users or groups */ | |
378 | i = 1; | |
379 | while (pacl->a_entries[i].e_tag == ACL_USER) | |
380 | i++; | |
381 | sort_pacl_range(pacl, 1, i-1); | |
382 | ||
383 | BUG_ON(pacl->a_entries[i].e_tag != ACL_GROUP_OBJ); | |
aba24d71 | 384 | j = ++i; |
1da177e4 LT |
385 | while (pacl->a_entries[j].e_tag == ACL_GROUP) |
386 | j++; | |
387 | sort_pacl_range(pacl, i, j-1); | |
388 | return; | |
389 | } | |
390 | ||
09229edb BF |
391 | /* |
392 | * While processing the NFSv4 ACE, this maintains bitmasks representing | |
393 | * which permission bits have been allowed and which denied to a given | |
394 | * entity: */ | |
395 | struct posix_ace_state { | |
396 | u32 allow; | |
397 | u32 deny; | |
398 | }; | |
399 | ||
400 | struct posix_user_ace_state { | |
401 | uid_t uid; | |
402 | struct posix_ace_state perms; | |
403 | }; | |
404 | ||
405 | struct posix_ace_state_array { | |
406 | int n; | |
407 | struct posix_user_ace_state aces[]; | |
408 | }; | |
409 | ||
410 | /* | |
411 | * While processing the NFSv4 ACE, this maintains the partial permissions | |
412 | * calculated so far: */ | |
413 | ||
414 | struct posix_acl_state { | |
3160a711 | 415 | int empty; |
09229edb BF |
416 | struct posix_ace_state owner; |
417 | struct posix_ace_state group; | |
418 | struct posix_ace_state other; | |
419 | struct posix_ace_state everyone; | |
420 | struct posix_ace_state mask; /* Deny unused in this case */ | |
421 | struct posix_ace_state_array *users; | |
422 | struct posix_ace_state_array *groups; | |
423 | }; | |
424 | ||
1da177e4 | 425 | static int |
09229edb | 426 | init_state(struct posix_acl_state *state, int cnt) |
1da177e4 | 427 | { |
09229edb BF |
428 | int alloc; |
429 | ||
430 | memset(state, 0, sizeof(struct posix_acl_state)); | |
3160a711 | 431 | state->empty = 1; |
09229edb BF |
432 | /* |
433 | * In the worst case, each individual acl could be for a distinct | |
434 | * named user or group, but we don't no which, so we allocate | |
435 | * enough space for either: | |
436 | */ | |
437 | alloc = sizeof(struct posix_ace_state_array) | |
91b80969 | 438 | + cnt*sizeof(struct posix_user_ace_state); |
09229edb BF |
439 | state->users = kzalloc(alloc, GFP_KERNEL); |
440 | if (!state->users) | |
441 | return -ENOMEM; | |
442 | state->groups = kzalloc(alloc, GFP_KERNEL); | |
443 | if (!state->groups) { | |
444 | kfree(state->users); | |
445 | return -ENOMEM; | |
446 | } | |
447 | return 0; | |
1da177e4 LT |
448 | } |
449 | ||
09229edb BF |
450 | static void |
451 | free_state(struct posix_acl_state *state) { | |
452 | kfree(state->users); | |
453 | kfree(state->groups); | |
1da177e4 LT |
454 | } |
455 | ||
09229edb | 456 | static inline void add_to_mask(struct posix_acl_state *state, struct posix_ace_state *astate) |
1da177e4 | 457 | { |
09229edb | 458 | state->mask.allow |= astate->allow; |
1da177e4 LT |
459 | } |
460 | ||
09229edb BF |
461 | /* |
462 | * Certain bits (SYNCHRONIZE, DELETE, WRITE_OWNER, READ/WRITE_NAMED_ATTRS, | |
463 | * READ_ATTRIBUTES, READ_ACL) are currently unenforceable and don't translate | |
464 | * to traditional read/write/execute permissions. | |
465 | * | |
466 | * It's problematic to reject acls that use certain mode bits, because it | |
467 | * places the burden on users to learn the rules about which bits one | |
468 | * particular server sets, without giving the user a lot of help--we return an | |
469 | * error that could mean any number of different things. To make matters | |
470 | * worse, the problematic bits might be introduced by some application that's | |
471 | * automatically mapping from some other acl model. | |
472 | * | |
473 | * So wherever possible we accept anything, possibly erring on the side of | |
474 | * denying more permissions than necessary. | |
475 | * | |
476 | * However we do reject *explicit* DENY's of a few bits representing | |
477 | * permissions we could never deny: | |
478 | */ | |
1da177e4 | 479 | |
09229edb BF |
480 | static inline int check_deny(u32 mask, int isowner) |
481 | { | |
482 | if (mask & (NFS4_ACE_READ_ATTRIBUTES | NFS4_ACE_READ_ACL)) | |
483 | return -EINVAL; | |
484 | if (!isowner) | |
485 | return 0; | |
486 | if (mask & (NFS4_ACE_WRITE_ATTRIBUTES | NFS4_ACE_WRITE_ACL)) | |
487 | return -EINVAL; | |
488 | return 0; | |
1da177e4 LT |
489 | } |
490 | ||
09229edb BF |
491 | static struct posix_acl * |
492 | posix_state_to_acl(struct posix_acl_state *state, unsigned int flags) | |
1da177e4 | 493 | { |
09229edb BF |
494 | struct posix_acl_entry *pace; |
495 | struct posix_acl *pacl; | |
496 | int nace; | |
497 | int i, error = 0; | |
1da177e4 | 498 | |
3160a711 BF |
499 | /* |
500 | * ACLs with no ACEs are treated differently in the inheritable | |
501 | * and effective cases: when there are no inheritable ACEs, we | |
502 | * set a zero-length default posix acl: | |
503 | */ | |
504 | if (state->empty && (flags & NFS4_ACL_TYPE_DEFAULT)) { | |
505 | pacl = posix_acl_alloc(0, GFP_KERNEL); | |
506 | return pacl ? pacl : ERR_PTR(-ENOMEM); | |
507 | } | |
508 | /* | |
509 | * When there are no effective ACEs, the following will end | |
510 | * up setting a 3-element effective posix ACL with all | |
511 | * permissions zero. | |
512 | */ | |
09229edb BF |
513 | nace = 4 + state->users->n + state->groups->n; |
514 | pacl = posix_acl_alloc(nace, GFP_KERNEL); | |
515 | if (!pacl) | |
516 | return ERR_PTR(-ENOMEM); | |
1da177e4 | 517 | |
09229edb BF |
518 | pace = pacl->a_entries; |
519 | pace->e_tag = ACL_USER_OBJ; | |
520 | error = check_deny(state->owner.deny, 1); | |
521 | if (error) | |
522 | goto out_err; | |
523 | low_mode_from_nfs4(state->owner.allow, &pace->e_perm, flags); | |
524 | pace->e_id = ACL_UNDEFINED_ID; | |
525 | ||
526 | for (i=0; i < state->users->n; i++) { | |
527 | pace++; | |
528 | pace->e_tag = ACL_USER; | |
529 | error = check_deny(state->users->aces[i].perms.deny, 0); | |
530 | if (error) | |
531 | goto out_err; | |
532 | low_mode_from_nfs4(state->users->aces[i].perms.allow, | |
533 | &pace->e_perm, flags); | |
534 | pace->e_id = state->users->aces[i].uid; | |
535 | add_to_mask(state, &state->users->aces[i].perms); | |
1da177e4 LT |
536 | } |
537 | ||
09229edb BF |
538 | pace++; |
539 | pace->e_tag = ACL_GROUP_OBJ; | |
540 | error = check_deny(state->group.deny, 0); | |
541 | if (error) | |
542 | goto out_err; | |
543 | low_mode_from_nfs4(state->group.allow, &pace->e_perm, flags); | |
544 | pace->e_id = ACL_UNDEFINED_ID; | |
545 | add_to_mask(state, &state->group); | |
546 | ||
547 | for (i=0; i < state->groups->n; i++) { | |
548 | pace++; | |
549 | pace->e_tag = ACL_GROUP; | |
550 | error = check_deny(state->groups->aces[i].perms.deny, 0); | |
551 | if (error) | |
552 | goto out_err; | |
553 | low_mode_from_nfs4(state->groups->aces[i].perms.allow, | |
554 | &pace->e_perm, flags); | |
555 | pace->e_id = state->groups->aces[i].uid; | |
556 | add_to_mask(state, &state->groups->aces[i].perms); | |
557 | } | |
1da177e4 | 558 | |
09229edb BF |
559 | pace++; |
560 | pace->e_tag = ACL_MASK; | |
561 | low_mode_from_nfs4(state->mask.allow, &pace->e_perm, flags); | |
562 | pace->e_id = ACL_UNDEFINED_ID; | |
1da177e4 | 563 | |
09229edb BF |
564 | pace++; |
565 | pace->e_tag = ACL_OTHER; | |
566 | error = check_deny(state->other.deny, 0); | |
567 | if (error) | |
568 | goto out_err; | |
569 | low_mode_from_nfs4(state->other.allow, &pace->e_perm, flags); | |
570 | pace->e_id = ACL_UNDEFINED_ID; | |
1da177e4 | 571 | |
09229edb BF |
572 | return pacl; |
573 | out_err: | |
574 | posix_acl_release(pacl); | |
575 | return ERR_PTR(error); | |
576 | } | |
1da177e4 | 577 | |
09229edb BF |
578 | static inline void allow_bits(struct posix_ace_state *astate, u32 mask) |
579 | { | |
580 | /* Allow all bits in the mask not already denied: */ | |
581 | astate->allow |= mask & ~astate->deny; | |
582 | } | |
1da177e4 | 583 | |
09229edb BF |
584 | static inline void deny_bits(struct posix_ace_state *astate, u32 mask) |
585 | { | |
586 | /* Deny all bits in the mask not already allowed: */ | |
587 | astate->deny |= mask & ~astate->allow; | |
588 | } | |
1da177e4 | 589 | |
09229edb BF |
590 | static int find_uid(struct posix_acl_state *state, struct posix_ace_state_array *a, uid_t uid) |
591 | { | |
592 | int i; | |
1da177e4 | 593 | |
09229edb BF |
594 | for (i = 0; i < a->n; i++) |
595 | if (a->aces[i].uid == uid) | |
596 | return i; | |
597 | /* Not found: */ | |
598 | a->n++; | |
599 | a->aces[i].uid = uid; | |
600 | a->aces[i].perms.allow = state->everyone.allow; | |
601 | a->aces[i].perms.deny = state->everyone.deny; | |
1da177e4 | 602 | |
09229edb | 603 | return i; |
1da177e4 LT |
604 | } |
605 | ||
09229edb | 606 | static void deny_bits_array(struct posix_ace_state_array *a, u32 mask) |
1da177e4 | 607 | { |
09229edb | 608 | int i; |
1da177e4 | 609 | |
09229edb BF |
610 | for (i=0; i < a->n; i++) |
611 | deny_bits(&a->aces[i].perms, mask); | |
1da177e4 LT |
612 | } |
613 | ||
09229edb | 614 | static void allow_bits_array(struct posix_ace_state_array *a, u32 mask) |
1da177e4 | 615 | { |
09229edb | 616 | int i; |
1da177e4 | 617 | |
09229edb BF |
618 | for (i=0; i < a->n; i++) |
619 | allow_bits(&a->aces[i].perms, mask); | |
1da177e4 LT |
620 | } |
621 | ||
09229edb BF |
622 | static void process_one_v4_ace(struct posix_acl_state *state, |
623 | struct nfs4_ace *ace) | |
1da177e4 | 624 | { |
09229edb BF |
625 | u32 mask = ace->access_mask; |
626 | int i; | |
627 | ||
3160a711 BF |
628 | state->empty = 0; |
629 | ||
09229edb BF |
630 | switch (ace2type(ace)) { |
631 | case ACL_USER_OBJ: | |
632 | if (ace->type == NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE) { | |
633 | allow_bits(&state->owner, mask); | |
634 | } else { | |
635 | deny_bits(&state->owner, mask); | |
636 | } | |
637 | break; | |
638 | case ACL_USER: | |
639 | i = find_uid(state, state->users, ace->who); | |
640 | if (ace->type == NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE) { | |
641 | allow_bits(&state->users->aces[i].perms, mask); | |
642 | } else { | |
643 | deny_bits(&state->users->aces[i].perms, mask); | |
644 | mask = state->users->aces[i].perms.deny; | |
645 | deny_bits(&state->owner, mask); | |
646 | } | |
647 | break; | |
648 | case ACL_GROUP_OBJ: | |
649 | if (ace->type == NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE) { | |
650 | allow_bits(&state->group, mask); | |
651 | } else { | |
652 | deny_bits(&state->group, mask); | |
653 | mask = state->group.deny; | |
654 | deny_bits(&state->owner, mask); | |
655 | deny_bits(&state->everyone, mask); | |
656 | deny_bits_array(state->users, mask); | |
657 | deny_bits_array(state->groups, mask); | |
658 | } | |
659 | break; | |
660 | case ACL_GROUP: | |
661 | i = find_uid(state, state->groups, ace->who); | |
662 | if (ace->type == NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE) { | |
663 | allow_bits(&state->groups->aces[i].perms, mask); | |
664 | } else { | |
665 | deny_bits(&state->groups->aces[i].perms, mask); | |
666 | mask = state->groups->aces[i].perms.deny; | |
667 | deny_bits(&state->owner, mask); | |
668 | deny_bits(&state->group, mask); | |
669 | deny_bits(&state->everyone, mask); | |
670 | deny_bits_array(state->users, mask); | |
671 | deny_bits_array(state->groups, mask); | |
672 | } | |
673 | break; | |
674 | case ACL_OTHER: | |
675 | if (ace->type == NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE) { | |
676 | allow_bits(&state->owner, mask); | |
677 | allow_bits(&state->group, mask); | |
678 | allow_bits(&state->other, mask); | |
679 | allow_bits(&state->everyone, mask); | |
680 | allow_bits_array(state->users, mask); | |
681 | allow_bits_array(state->groups, mask); | |
682 | } else { | |
683 | deny_bits(&state->owner, mask); | |
684 | deny_bits(&state->group, mask); | |
685 | deny_bits(&state->other, mask); | |
686 | deny_bits(&state->everyone, mask); | |
687 | deny_bits_array(state->users, mask); | |
688 | deny_bits_array(state->groups, mask); | |
689 | } | |
1da177e4 LT |
690 | } |
691 | } | |
692 | ||
575a6290 BF |
693 | int nfs4_acl_nfsv4_to_posix(struct nfs4_acl *acl, struct posix_acl **pacl, |
694 | struct posix_acl **dpacl, unsigned int flags) | |
1da177e4 | 695 | { |
575a6290 | 696 | struct posix_acl_state effective_acl_state, default_acl_state; |
09229edb BF |
697 | struct nfs4_ace *ace; |
698 | int ret; | |
1da177e4 | 699 | |
575a6290 | 700 | ret = init_state(&effective_acl_state, acl->naces); |
09229edb | 701 | if (ret) |
575a6290 BF |
702 | return ret; |
703 | ret = init_state(&default_acl_state, acl->naces); | |
704 | if (ret) | |
705 | goto out_estate; | |
706 | ret = -EINVAL; | |
28e05dd8 | 707 | for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) { |
09229edb BF |
708 | if (ace->type != NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE && |
709 | ace->type != NFS4_ACE_ACCESS_DENIED_ACE_TYPE) | |
575a6290 | 710 | goto out_dstate; |
b548edc2 | 711 | if (ace->flag & ~NFS4_SUPPORTED_FLAGS) |
575a6290 | 712 | goto out_dstate; |
7bdfa68c | 713 | if ((ace->flag & NFS4_INHERITANCE_FLAGS) == 0) { |
575a6290 | 714 | process_one_v4_ace(&effective_acl_state, ace); |
b548edc2 | 715 | continue; |
7bdfa68c | 716 | } |
575a6290 BF |
717 | if (!(flags & NFS4_ACL_DIR)) |
718 | goto out_dstate; | |
7bdfa68c BF |
719 | /* |
720 | * Note that when only one of FILE_INHERIT or DIRECTORY_INHERIT | |
721 | * is set, we're effectively turning on the other. That's OK, | |
722 | * according to rfc 3530. | |
723 | */ | |
575a6290 BF |
724 | process_one_v4_ace(&default_acl_state, ace); |
725 | ||
726 | if (!(ace->flag & NFS4_ACE_INHERIT_ONLY_ACE)) | |
727 | process_one_v4_ace(&effective_acl_state, ace); | |
1da177e4 | 728 | } |
575a6290 BF |
729 | *pacl = posix_state_to_acl(&effective_acl_state, flags); |
730 | if (IS_ERR(*pacl)) { | |
731 | ret = PTR_ERR(*pacl); | |
4b2ca38a | 732 | *pacl = NULL; |
575a6290 BF |
733 | goto out_dstate; |
734 | } | |
3160a711 BF |
735 | *dpacl = posix_state_to_acl(&default_acl_state, |
736 | flags | NFS4_ACL_TYPE_DEFAULT); | |
575a6290 BF |
737 | if (IS_ERR(*dpacl)) { |
738 | ret = PTR_ERR(*dpacl); | |
4b2ca38a | 739 | *dpacl = NULL; |
575a6290 | 740 | posix_acl_release(*pacl); |
4b2ca38a | 741 | *pacl = NULL; |
575a6290 BF |
742 | goto out_dstate; |
743 | } | |
744 | sort_pacl(*pacl); | |
745 | sort_pacl(*dpacl); | |
746 | ret = 0; | |
747 | out_dstate: | |
748 | free_state(&default_acl_state); | |
749 | out_estate: | |
750 | free_state(&effective_acl_state); | |
751 | return ret; | |
1da177e4 LT |
752 | } |
753 | ||
754 | static short | |
755 | ace2type(struct nfs4_ace *ace) | |
756 | { | |
757 | switch (ace->whotype) { | |
758 | case NFS4_ACL_WHO_NAMED: | |
759 | return (ace->flag & NFS4_ACE_IDENTIFIER_GROUP ? | |
760 | ACL_GROUP : ACL_USER); | |
761 | case NFS4_ACL_WHO_OWNER: | |
762 | return ACL_USER_OBJ; | |
763 | case NFS4_ACL_WHO_GROUP: | |
764 | return ACL_GROUP_OBJ; | |
765 | case NFS4_ACL_WHO_EVERYONE: | |
766 | return ACL_OTHER; | |
767 | } | |
768 | BUG(); | |
769 | return -1; | |
770 | } | |
771 | ||
772 | EXPORT_SYMBOL(nfs4_acl_posix_to_nfsv4); | |
773 | EXPORT_SYMBOL(nfs4_acl_nfsv4_to_posix); | |
774 | ||
775 | struct nfs4_acl * | |
28e05dd8 | 776 | nfs4_acl_new(int n) |
1da177e4 LT |
777 | { |
778 | struct nfs4_acl *acl; | |
779 | ||
28e05dd8 BF |
780 | acl = kmalloc(sizeof(*acl) + n*sizeof(struct nfs4_ace), GFP_KERNEL); |
781 | if (acl == NULL) | |
1da177e4 | 782 | return NULL; |
1da177e4 | 783 | acl->naces = 0; |
1da177e4 LT |
784 | return acl; |
785 | } | |
786 | ||
1da177e4 LT |
787 | static struct { |
788 | char *string; | |
789 | int stringlen; | |
790 | int type; | |
791 | } s2t_map[] = { | |
792 | { | |
793 | .string = "OWNER@", | |
794 | .stringlen = sizeof("OWNER@") - 1, | |
795 | .type = NFS4_ACL_WHO_OWNER, | |
796 | }, | |
797 | { | |
798 | .string = "GROUP@", | |
799 | .stringlen = sizeof("GROUP@") - 1, | |
800 | .type = NFS4_ACL_WHO_GROUP, | |
801 | }, | |
802 | { | |
803 | .string = "EVERYONE@", | |
804 | .stringlen = sizeof("EVERYONE@") - 1, | |
805 | .type = NFS4_ACL_WHO_EVERYONE, | |
806 | }, | |
807 | }; | |
808 | ||
809 | int | |
810 | nfs4_acl_get_whotype(char *p, u32 len) | |
811 | { | |
812 | int i; | |
813 | ||
e8c96f8c | 814 | for (i = 0; i < ARRAY_SIZE(s2t_map); i++) { |
1da177e4 LT |
815 | if (s2t_map[i].stringlen == len && |
816 | 0 == memcmp(s2t_map[i].string, p, len)) | |
817 | return s2t_map[i].type; | |
818 | } | |
819 | return NFS4_ACL_WHO_NAMED; | |
820 | } | |
821 | ||
822 | int | |
823 | nfs4_acl_write_who(int who, char *p) | |
824 | { | |
825 | int i; | |
826 | ||
e8c96f8c | 827 | for (i = 0; i < ARRAY_SIZE(s2t_map); i++) { |
1da177e4 LT |
828 | if (s2t_map[i].type == who) { |
829 | memcpy(p, s2t_map[i].string, s2t_map[i].stringlen); | |
830 | return s2t_map[i].stringlen; | |
831 | } | |
832 | } | |
833 | BUG(); | |
834 | return -1; | |
835 | } | |
836 | ||
1da177e4 | 837 | EXPORT_SYMBOL(nfs4_acl_new); |
1da177e4 LT |
838 | EXPORT_SYMBOL(nfs4_acl_get_whotype); |
839 | EXPORT_SYMBOL(nfs4_acl_write_who); |