Commit | Line | Data |
---|---|---|
1da177e4 LT |
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> | |
60063497 | 17 | #include <linux/atomic.h> |
1da177e4 LT |
18 | #include <linux/fs.h> |
19 | #include <linux/sched.h> | |
20 | #include <linux/posix_acl.h> | |
630d9c47 | 21 | #include <linux/export.h> |
1da177e4 LT |
22 | |
23 | #include <linux/errno.h> | |
24 | ||
f61f6da0 | 25 | EXPORT_SYMBOL(posix_acl_init); |
1da177e4 | 26 | EXPORT_SYMBOL(posix_acl_alloc); |
1da177e4 LT |
27 | EXPORT_SYMBOL(posix_acl_valid); |
28 | EXPORT_SYMBOL(posix_acl_equiv_mode); | |
29 | EXPORT_SYMBOL(posix_acl_from_mode); | |
1da177e4 | 30 | |
f61f6da0 CL |
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 | ||
1da177e4 LT |
41 | /* |
42 | * Allocate a new ACL with the specified number of entries. | |
43 | */ | |
44 | struct posix_acl * | |
dd0fc66f | 45 | posix_acl_alloc(int count, gfp_t flags) |
1da177e4 LT |
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); | |
f61f6da0 CL |
50 | if (acl) |
51 | posix_acl_init(acl, count); | |
1da177e4 LT |
52 | return acl; |
53 | } | |
54 | ||
55 | /* | |
56 | * Clone an ACL. | |
57 | */ | |
edde854e | 58 | static struct posix_acl * |
dd0fc66f | 59 | posix_acl_clone(const struct posix_acl *acl, gfp_t flags) |
1da177e4 LT |
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); | |
52978be6 AD |
66 | clone = kmemdup(acl, size, flags); |
67 | if (clone) | |
1da177e4 | 68 | atomic_set(&clone->a_refcount, 1); |
1da177e4 LT |
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; | |
2f6f0654 EB |
81 | kuid_t prev_uid = INVALID_UID; |
82 | kgid_t prev_gid = INVALID_GID; | |
1da177e4 LT |
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) { | |
1da177e4 LT |
91 | state = ACL_USER; |
92 | break; | |
93 | } | |
94 | return -EINVAL; | |
95 | ||
96 | case ACL_USER: | |
97 | if (state != ACL_USER) | |
98 | return -EINVAL; | |
2f6f0654 | 99 | if (!uid_valid(pa->e_uid)) |
1da177e4 | 100 | return -EINVAL; |
2f6f0654 EB |
101 | if (uid_valid(prev_uid) && |
102 | uid_lte(pa->e_uid, prev_uid)) | |
103 | return -EINVAL; | |
104 | prev_uid = pa->e_uid; | |
1da177e4 LT |
105 | needs_mask = 1; |
106 | break; | |
107 | ||
108 | case ACL_GROUP_OBJ: | |
109 | if (state == ACL_USER) { | |
1da177e4 LT |
110 | state = ACL_GROUP; |
111 | break; | |
112 | } | |
113 | return -EINVAL; | |
114 | ||
115 | case ACL_GROUP: | |
116 | if (state != ACL_GROUP) | |
117 | return -EINVAL; | |
2f6f0654 EB |
118 | if (!gid_valid(pa->e_gid)) |
119 | return -EINVAL; | |
120 | if (gid_valid(prev_gid) && | |
121 | gid_lte(pa->e_gid, prev_gid)) | |
1da177e4 | 122 | return -EINVAL; |
2f6f0654 | 123 | prev_gid = pa->e_gid; |
1da177e4 LT |
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 | |
d6952123 | 155 | posix_acl_equiv_mode(const struct posix_acl *acl, umode_t *mode_p) |
1da177e4 LT |
156 | { |
157 | const struct posix_acl_entry *pa, *pe; | |
d6952123 | 158 | umode_t mode = 0; |
1da177e4 LT |
159 | int not_equiv = 0; |
160 | ||
3d3da408 CH |
161 | /* |
162 | * A null ACL can always be presented as mode bits. | |
163 | */ | |
164 | if (!acl) | |
165 | return 0; | |
166 | ||
1da177e4 LT |
167 | FOREACH_ACL_ENTRY(pa, acl, pe) { |
168 | switch (pa->e_tag) { | |
169 | case ACL_USER_OBJ: | |
170 | mode |= (pa->e_perm & S_IRWXO) << 6; | |
171 | break; | |
172 | case ACL_GROUP_OBJ: | |
173 | mode |= (pa->e_perm & S_IRWXO) << 3; | |
174 | break; | |
175 | case ACL_OTHER: | |
176 | mode |= pa->e_perm & S_IRWXO; | |
177 | break; | |
178 | case ACL_MASK: | |
179 | mode = (mode & ~S_IRWXG) | | |
180 | ((pa->e_perm & S_IRWXO) << 3); | |
181 | not_equiv = 1; | |
182 | break; | |
183 | case ACL_USER: | |
184 | case ACL_GROUP: | |
185 | not_equiv = 1; | |
186 | break; | |
187 | default: | |
188 | return -EINVAL; | |
189 | } | |
190 | } | |
191 | if (mode_p) | |
192 | *mode_p = (*mode_p & ~S_IRWXUGO) | mode; | |
193 | return not_equiv; | |
194 | } | |
195 | ||
196 | /* | |
197 | * Create an ACL representing the file mode permission bits of an inode. | |
198 | */ | |
199 | struct posix_acl * | |
3a5fba19 | 200 | posix_acl_from_mode(umode_t mode, gfp_t flags) |
1da177e4 LT |
201 | { |
202 | struct posix_acl *acl = posix_acl_alloc(3, flags); | |
203 | if (!acl) | |
204 | return ERR_PTR(-ENOMEM); | |
205 | ||
206 | acl->a_entries[0].e_tag = ACL_USER_OBJ; | |
1da177e4 LT |
207 | acl->a_entries[0].e_perm = (mode & S_IRWXU) >> 6; |
208 | ||
209 | acl->a_entries[1].e_tag = ACL_GROUP_OBJ; | |
1da177e4 LT |
210 | acl->a_entries[1].e_perm = (mode & S_IRWXG) >> 3; |
211 | ||
212 | acl->a_entries[2].e_tag = ACL_OTHER; | |
1da177e4 LT |
213 | acl->a_entries[2].e_perm = (mode & S_IRWXO); |
214 | return acl; | |
215 | } | |
216 | ||
217 | /* | |
218 | * Return 0 if current is granted want access to the inode | |
219 | * by the acl. Returns -E... otherwise. | |
220 | */ | |
221 | int | |
222 | posix_acl_permission(struct inode *inode, const struct posix_acl *acl, int want) | |
223 | { | |
224 | const struct posix_acl_entry *pa, *pe, *mask_obj; | |
225 | int found = 0; | |
226 | ||
d124b60a AG |
227 | want &= MAY_READ | MAY_WRITE | MAY_EXEC | MAY_NOT_BLOCK; |
228 | ||
1da177e4 LT |
229 | FOREACH_ACL_ENTRY(pa, acl, pe) { |
230 | switch(pa->e_tag) { | |
231 | case ACL_USER_OBJ: | |
232 | /* (May have been checked already) */ | |
2f6f0654 | 233 | if (uid_eq(inode->i_uid, current_fsuid())) |
1da177e4 LT |
234 | goto check_perm; |
235 | break; | |
236 | case ACL_USER: | |
2f6f0654 | 237 | if (uid_eq(pa->e_uid, current_fsuid())) |
1da177e4 LT |
238 | goto mask; |
239 | break; | |
240 | case ACL_GROUP_OBJ: | |
241 | if (in_group_p(inode->i_gid)) { | |
242 | found = 1; | |
243 | if ((pa->e_perm & want) == want) | |
244 | goto mask; | |
245 | } | |
246 | break; | |
247 | case ACL_GROUP: | |
2f6f0654 | 248 | if (in_group_p(pa->e_gid)) { |
1da177e4 LT |
249 | found = 1; |
250 | if ((pa->e_perm & want) == want) | |
251 | goto mask; | |
252 | } | |
253 | break; | |
254 | case ACL_MASK: | |
255 | break; | |
256 | case ACL_OTHER: | |
257 | if (found) | |
258 | return -EACCES; | |
259 | else | |
260 | goto check_perm; | |
261 | default: | |
262 | return -EIO; | |
263 | } | |
264 | } | |
265 | return -EIO; | |
266 | ||
267 | mask: | |
268 | for (mask_obj = pa+1; mask_obj != pe; mask_obj++) { | |
269 | if (mask_obj->e_tag == ACL_MASK) { | |
270 | if ((pa->e_perm & mask_obj->e_perm & want) == want) | |
271 | return 0; | |
272 | return -EACCES; | |
273 | } | |
274 | } | |
275 | ||
276 | check_perm: | |
277 | if ((pa->e_perm & want) == want) | |
278 | return 0; | |
279 | return -EACCES; | |
280 | } | |
281 | ||
282 | /* | |
283 | * Modify acl when creating a new inode. The caller must ensure the acl is | |
284 | * only referenced once. | |
285 | * | |
286 | * mode_p initially must contain the mode parameter to the open() / creat() | |
287 | * system calls. All permissions that are not granted by the acl are removed. | |
288 | * The permissions in the acl are changed to reflect the mode_p parameter. | |
289 | */ | |
d3fb6120 | 290 | static int posix_acl_create_masq(struct posix_acl *acl, umode_t *mode_p) |
1da177e4 LT |
291 | { |
292 | struct posix_acl_entry *pa, *pe; | |
293 | struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL; | |
d3fb6120 | 294 | umode_t mode = *mode_p; |
1da177e4 LT |
295 | int not_equiv = 0; |
296 | ||
297 | /* assert(atomic_read(acl->a_refcount) == 1); */ | |
298 | ||
299 | FOREACH_ACL_ENTRY(pa, acl, pe) { | |
300 | switch(pa->e_tag) { | |
301 | case ACL_USER_OBJ: | |
302 | pa->e_perm &= (mode >> 6) | ~S_IRWXO; | |
303 | mode &= (pa->e_perm << 6) | ~S_IRWXU; | |
304 | break; | |
305 | ||
306 | case ACL_USER: | |
307 | case ACL_GROUP: | |
308 | not_equiv = 1; | |
309 | break; | |
310 | ||
311 | case ACL_GROUP_OBJ: | |
312 | group_obj = pa; | |
313 | break; | |
314 | ||
315 | case ACL_OTHER: | |
316 | pa->e_perm &= mode | ~S_IRWXO; | |
317 | mode &= pa->e_perm | ~S_IRWXO; | |
318 | break; | |
319 | ||
320 | case ACL_MASK: | |
321 | mask_obj = pa; | |
322 | not_equiv = 1; | |
323 | break; | |
324 | ||
325 | default: | |
326 | return -EIO; | |
327 | } | |
328 | } | |
329 | ||
330 | if (mask_obj) { | |
331 | mask_obj->e_perm &= (mode >> 3) | ~S_IRWXO; | |
332 | mode &= (mask_obj->e_perm << 3) | ~S_IRWXG; | |
333 | } else { | |
334 | if (!group_obj) | |
335 | return -EIO; | |
336 | group_obj->e_perm &= (mode >> 3) | ~S_IRWXO; | |
337 | mode &= (group_obj->e_perm << 3) | ~S_IRWXG; | |
338 | } | |
339 | ||
340 | *mode_p = (*mode_p & ~S_IRWXUGO) | mode; | |
341 | return not_equiv; | |
342 | } | |
343 | ||
4b9e9796 S |
344 | /** |
345 | * posix_acl_update_mode - update mode in set_acl | |
346 | * | |
347 | * Update the file mode when setting an ACL: compute the new file permission | |
348 | * bits based on the ACL. In addition, if the ACL is equivalent to the new | |
349 | * file mode, set *acl to NULL to indicate that no ACL should be set. | |
350 | * | |
351 | * As with chmod, clear the setgit bit if the caller is not in the owning group | |
352 | * or capable of CAP_FSETID (see inode_change_ok). | |
353 | * | |
354 | * Called from set_acl inode operations. | |
355 | */ | |
356 | int posix_acl_update_mode(struct inode *inode, umode_t *mode_p, | |
357 | struct posix_acl **acl) | |
358 | { | |
359 | umode_t mode = inode->i_mode; | |
360 | int error; | |
361 | ||
362 | error = posix_acl_equiv_mode(*acl, &mode); | |
363 | if (error < 0) | |
364 | return error; | |
365 | if (error == 0) | |
366 | *acl = NULL; | |
367 | if (!in_group_p(inode->i_gid) && | |
368 | !capable_wrt_inode_uidgid(inode, CAP_FSETID)) | |
369 | mode &= ~S_ISGID; | |
370 | *mode_p = mode; | |
371 | return 0; | |
372 | } | |
373 | EXPORT_SYMBOL(posix_acl_update_mode); | |
374 | ||
1da177e4 LT |
375 | /* |
376 | * Modify the ACL for the chmod syscall. | |
377 | */ | |
86bc704d | 378 | static int posix_acl_chmod_masq(struct posix_acl *acl, umode_t mode) |
1da177e4 LT |
379 | { |
380 | struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL; | |
381 | struct posix_acl_entry *pa, *pe; | |
382 | ||
383 | /* assert(atomic_read(acl->a_refcount) == 1); */ | |
384 | ||
385 | FOREACH_ACL_ENTRY(pa, acl, pe) { | |
386 | switch(pa->e_tag) { | |
387 | case ACL_USER_OBJ: | |
388 | pa->e_perm = (mode & S_IRWXU) >> 6; | |
389 | break; | |
390 | ||
391 | case ACL_USER: | |
392 | case ACL_GROUP: | |
393 | break; | |
394 | ||
395 | case ACL_GROUP_OBJ: | |
396 | group_obj = pa; | |
397 | break; | |
398 | ||
399 | case ACL_MASK: | |
400 | mask_obj = pa; | |
401 | break; | |
402 | ||
403 | case ACL_OTHER: | |
404 | pa->e_perm = (mode & S_IRWXO); | |
405 | break; | |
406 | ||
407 | default: | |
408 | return -EIO; | |
409 | } | |
410 | } | |
411 | ||
412 | if (mask_obj) { | |
413 | mask_obj->e_perm = (mode & S_IRWXG) >> 3; | |
414 | } else { | |
415 | if (!group_obj) | |
416 | return -EIO; | |
417 | group_obj->e_perm = (mode & S_IRWXG) >> 3; | |
418 | } | |
419 | ||
420 | return 0; | |
421 | } | |
bc26ab5f | 422 | |
826cae2f | 423 | int |
d3fb6120 | 424 | posix_acl_create(struct posix_acl **acl, gfp_t gfp, umode_t *mode_p) |
826cae2f AV |
425 | { |
426 | struct posix_acl *clone = posix_acl_clone(*acl, gfp); | |
427 | int err = -ENOMEM; | |
428 | if (clone) { | |
429 | err = posix_acl_create_masq(clone, mode_p); | |
430 | if (err < 0) { | |
431 | posix_acl_release(clone); | |
432 | clone = NULL; | |
433 | } | |
434 | } | |
435 | posix_acl_release(*acl); | |
436 | *acl = clone; | |
437 | return err; | |
438 | } | |
439 | EXPORT_SYMBOL(posix_acl_create); | |
440 | ||
bc26ab5f | 441 | int |
86bc704d | 442 | posix_acl_chmod(struct posix_acl **acl, gfp_t gfp, umode_t mode) |
bc26ab5f AV |
443 | { |
444 | struct posix_acl *clone = posix_acl_clone(*acl, gfp); | |
445 | int err = -ENOMEM; | |
446 | if (clone) { | |
447 | err = posix_acl_chmod_masq(clone, mode); | |
448 | if (err) { | |
449 | posix_acl_release(clone); | |
450 | clone = NULL; | |
451 | } | |
452 | } | |
453 | posix_acl_release(*acl); | |
454 | *acl = clone; | |
455 | return err; | |
456 | } | |
457 | EXPORT_SYMBOL(posix_acl_chmod); |