Root/
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 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9