Contents of /alx-src/tags/kernel26-2.6.12-alx-r9/fs/posix_acl.c
Parent Directory | Revision Log
Revision 630 -
(show annotations)
(download)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 8784 byte(s)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 8784 byte(s)
Tag kernel26-2.6.12-alx-r9
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 <asm/atomic.h> |
18 | #include <linux/fs.h> |
19 | #include <linux/sched.h> |
20 | #include <linux/posix_acl.h> |
21 | #include <linux/module.h> |
22 | |
23 | #include <linux/errno.h> |
24 | |
25 | EXPORT_SYMBOL(posix_acl_alloc); |
26 | EXPORT_SYMBOL(posix_acl_clone); |
27 | EXPORT_SYMBOL(posix_acl_valid); |
28 | EXPORT_SYMBOL(posix_acl_equiv_mode); |
29 | EXPORT_SYMBOL(posix_acl_from_mode); |
30 | EXPORT_SYMBOL(posix_acl_create_masq); |
31 | EXPORT_SYMBOL(posix_acl_chmod_masq); |
32 | EXPORT_SYMBOL(posix_acl_permission); |
33 | |
34 | /* |
35 | * Allocate a new ACL with the specified number of entries. |
36 | */ |
37 | struct posix_acl * |
38 | posix_acl_alloc(int count, unsigned int __nocast flags) |
39 | { |
40 | const size_t size = sizeof(struct posix_acl) + |
41 | count * sizeof(struct posix_acl_entry); |
42 | struct posix_acl *acl = kmalloc(size, flags); |
43 | if (acl) { |
44 | atomic_set(&acl->a_refcount, 1); |
45 | acl->a_count = count; |
46 | } |
47 | return acl; |
48 | } |
49 | |
50 | /* |
51 | * Clone an ACL. |
52 | */ |
53 | struct posix_acl * |
54 | posix_acl_clone(const struct posix_acl *acl, unsigned int __nocast flags) |
55 | { |
56 | struct posix_acl *clone = NULL; |
57 | |
58 | if (acl) { |
59 | int size = sizeof(struct posix_acl) + acl->a_count * |
60 | sizeof(struct posix_acl_entry); |
61 | clone = kmalloc(size, flags); |
62 | if (clone) { |
63 | memcpy(clone, acl, size); |
64 | atomic_set(&clone->a_refcount, 1); |
65 | } |
66 | } |
67 | return clone; |
68 | } |
69 | |
70 | /* |
71 | * Check if an acl is valid. Returns 0 if it is, or -E... otherwise. |
72 | */ |
73 | int |
74 | posix_acl_valid(const struct posix_acl *acl) |
75 | { |
76 | const struct posix_acl_entry *pa, *pe; |
77 | int state = ACL_USER_OBJ; |
78 | unsigned int id = 0; /* keep gcc happy */ |
79 | int needs_mask = 0; |
80 | |
81 | FOREACH_ACL_ENTRY(pa, acl, pe) { |
82 | if (pa->e_perm & ~(ACL_READ|ACL_WRITE|ACL_EXECUTE)) |
83 | return -EINVAL; |
84 | switch (pa->e_tag) { |
85 | case ACL_USER_OBJ: |
86 | if (state == ACL_USER_OBJ) { |
87 | id = 0; |
88 | state = ACL_USER; |
89 | break; |
90 | } |
91 | return -EINVAL; |
92 | |
93 | case ACL_USER: |
94 | if (state != ACL_USER) |
95 | return -EINVAL; |
96 | if (pa->e_id == ACL_UNDEFINED_ID || |
97 | pa->e_id < id) |
98 | return -EINVAL; |
99 | id = pa->e_id + 1; |
100 | needs_mask = 1; |
101 | break; |
102 | |
103 | case ACL_GROUP_OBJ: |
104 | if (state == ACL_USER) { |
105 | id = 0; |
106 | state = ACL_GROUP; |
107 | break; |
108 | } |
109 | return -EINVAL; |
110 | |
111 | case ACL_GROUP: |
112 | if (state != ACL_GROUP) |
113 | return -EINVAL; |
114 | if (pa->e_id == ACL_UNDEFINED_ID || |
115 | pa->e_id < id) |
116 | return -EINVAL; |
117 | id = pa->e_id + 1; |
118 | needs_mask = 1; |
119 | break; |
120 | |
121 | case ACL_MASK: |
122 | if (state != ACL_GROUP) |
123 | return -EINVAL; |
124 | state = ACL_OTHER; |
125 | break; |
126 | |
127 | case ACL_OTHER: |
128 | if (state == ACL_OTHER || |
129 | (state == ACL_GROUP && !needs_mask)) { |
130 | state = 0; |
131 | break; |
132 | } |
133 | return -EINVAL; |
134 | |
135 | default: |
136 | return -EINVAL; |
137 | } |
138 | } |
139 | if (state == 0) |
140 | return 0; |
141 | return -EINVAL; |
142 | } |
143 | |
144 | /* |
145 | * Returns 0 if the acl can be exactly represented in the traditional |
146 | * file mode permission bits, or else 1. Returns -E... on error. |
147 | */ |
148 | int |
149 | posix_acl_equiv_mode(const struct posix_acl *acl, mode_t *mode_p) |
150 | { |
151 | const struct posix_acl_entry *pa, *pe; |
152 | mode_t mode = 0; |
153 | int not_equiv = 0; |
154 | |
155 | FOREACH_ACL_ENTRY(pa, acl, pe) { |
156 | switch (pa->e_tag) { |
157 | case ACL_USER_OBJ: |
158 | mode |= (pa->e_perm & S_IRWXO) << 6; |
159 | break; |
160 | case ACL_GROUP_OBJ: |
161 | mode |= (pa->e_perm & S_IRWXO) << 3; |
162 | break; |
163 | case ACL_OTHER: |
164 | mode |= pa->e_perm & S_IRWXO; |
165 | break; |
166 | case ACL_MASK: |
167 | mode = (mode & ~S_IRWXG) | |
168 | ((pa->e_perm & S_IRWXO) << 3); |
169 | not_equiv = 1; |
170 | break; |
171 | case ACL_USER: |
172 | case ACL_GROUP: |
173 | not_equiv = 1; |
174 | break; |
175 | default: |
176 | return -EINVAL; |
177 | } |
178 | } |
179 | if (mode_p) |
180 | *mode_p = (*mode_p & ~S_IRWXUGO) | mode; |
181 | return not_equiv; |
182 | } |
183 | |
184 | /* |
185 | * Create an ACL representing the file mode permission bits of an inode. |
186 | */ |
187 | struct posix_acl * |
188 | posix_acl_from_mode(mode_t mode, unsigned int __nocast flags) |
189 | { |
190 | struct posix_acl *acl = posix_acl_alloc(3, flags); |
191 | if (!acl) |
192 | return ERR_PTR(-ENOMEM); |
193 | |
194 | acl->a_entries[0].e_tag = ACL_USER_OBJ; |
195 | acl->a_entries[0].e_id = ACL_UNDEFINED_ID; |
196 | acl->a_entries[0].e_perm = (mode & S_IRWXU) >> 6; |
197 | |
198 | acl->a_entries[1].e_tag = ACL_GROUP_OBJ; |
199 | acl->a_entries[1].e_id = ACL_UNDEFINED_ID; |
200 | acl->a_entries[1].e_perm = (mode & S_IRWXG) >> 3; |
201 | |
202 | acl->a_entries[2].e_tag = ACL_OTHER; |
203 | acl->a_entries[2].e_id = ACL_UNDEFINED_ID; |
204 | acl->a_entries[2].e_perm = (mode & S_IRWXO); |
205 | return acl; |
206 | } |
207 | |
208 | /* |
209 | * Return 0 if current is granted want access to the inode |
210 | * by the acl. Returns -E... otherwise. |
211 | */ |
212 | int |
213 | posix_acl_permission(struct inode *inode, const struct posix_acl *acl, int want) |
214 | { |
215 | const struct posix_acl_entry *pa, *pe, *mask_obj; |
216 | int found = 0; |
217 | |
218 | FOREACH_ACL_ENTRY(pa, acl, pe) { |
219 | switch(pa->e_tag) { |
220 | case ACL_USER_OBJ: |
221 | /* (May have been checked already) */ |
222 | if (inode->i_uid == current->fsuid) |
223 | goto check_perm; |
224 | break; |
225 | case ACL_USER: |
226 | if (pa->e_id == current->fsuid) |
227 | goto mask; |
228 | break; |
229 | case ACL_GROUP_OBJ: |
230 | if (in_group_p(inode->i_gid)) { |
231 | found = 1; |
232 | if ((pa->e_perm & want) == want) |
233 | goto mask; |
234 | } |
235 | break; |
236 | case ACL_GROUP: |
237 | if (in_group_p(pa->e_id)) { |
238 | found = 1; |
239 | if ((pa->e_perm & want) == want) |
240 | goto mask; |
241 | } |
242 | break; |
243 | case ACL_MASK: |
244 | break; |
245 | case ACL_OTHER: |
246 | if (found) |
247 | return -EACCES; |
248 | else |
249 | goto check_perm; |
250 | default: |
251 | return -EIO; |
252 | } |
253 | } |
254 | return -EIO; |
255 | |
256 | mask: |
257 | for (mask_obj = pa+1; mask_obj != pe; mask_obj++) { |
258 | if (mask_obj->e_tag == ACL_MASK) { |
259 | if ((pa->e_perm & mask_obj->e_perm & want) == want) |
260 | return 0; |
261 | return -EACCES; |
262 | } |
263 | } |
264 | |
265 | check_perm: |
266 | if ((pa->e_perm & want) == want) |
267 | return 0; |
268 | return -EACCES; |
269 | } |
270 | |
271 | /* |
272 | * Modify acl when creating a new inode. The caller must ensure the acl is |
273 | * only referenced once. |
274 | * |
275 | * mode_p initially must contain the mode parameter to the open() / creat() |
276 | * system calls. All permissions that are not granted by the acl are removed. |
277 | * The permissions in the acl are changed to reflect the mode_p parameter. |
278 | */ |
279 | int |
280 | posix_acl_create_masq(struct posix_acl *acl, mode_t *mode_p) |
281 | { |
282 | struct posix_acl_entry *pa, *pe; |
283 | struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL; |
284 | mode_t mode = *mode_p; |
285 | int not_equiv = 0; |
286 | |
287 | /* assert(atomic_read(acl->a_refcount) == 1); */ |
288 | |
289 | FOREACH_ACL_ENTRY(pa, acl, pe) { |
290 | switch(pa->e_tag) { |
291 | case ACL_USER_OBJ: |
292 | pa->e_perm &= (mode >> 6) | ~S_IRWXO; |
293 | mode &= (pa->e_perm << 6) | ~S_IRWXU; |
294 | break; |
295 | |
296 | case ACL_USER: |
297 | case ACL_GROUP: |
298 | not_equiv = 1; |
299 | break; |
300 | |
301 | case ACL_GROUP_OBJ: |
302 | group_obj = pa; |
303 | break; |
304 | |
305 | case ACL_OTHER: |
306 | pa->e_perm &= mode | ~S_IRWXO; |
307 | mode &= pa->e_perm | ~S_IRWXO; |
308 | break; |
309 | |
310 | case ACL_MASK: |
311 | mask_obj = pa; |
312 | not_equiv = 1; |
313 | break; |
314 | |
315 | default: |
316 | return -EIO; |
317 | } |
318 | } |
319 | |
320 | if (mask_obj) { |
321 | mask_obj->e_perm &= (mode >> 3) | ~S_IRWXO; |
322 | mode &= (mask_obj->e_perm << 3) | ~S_IRWXG; |
323 | } else { |
324 | if (!group_obj) |
325 | return -EIO; |
326 | group_obj->e_perm &= (mode >> 3) | ~S_IRWXO; |
327 | mode &= (group_obj->e_perm << 3) | ~S_IRWXG; |
328 | } |
329 | |
330 | *mode_p = (*mode_p & ~S_IRWXUGO) | mode; |
331 | return not_equiv; |
332 | } |
333 | |
334 | /* |
335 | * Modify the ACL for the chmod syscall. |
336 | */ |
337 | int |
338 | posix_acl_chmod_masq(struct posix_acl *acl, mode_t mode) |
339 | { |
340 | struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL; |
341 | struct posix_acl_entry *pa, *pe; |
342 | |
343 | /* assert(atomic_read(acl->a_refcount) == 1); */ |
344 | |
345 | FOREACH_ACL_ENTRY(pa, acl, pe) { |
346 | switch(pa->e_tag) { |
347 | case ACL_USER_OBJ: |
348 | pa->e_perm = (mode & S_IRWXU) >> 6; |
349 | break; |
350 | |
351 | case ACL_USER: |
352 | case ACL_GROUP: |
353 | break; |
354 | |
355 | case ACL_GROUP_OBJ: |
356 | group_obj = pa; |
357 | break; |
358 | |
359 | case ACL_MASK: |
360 | mask_obj = pa; |
361 | break; |
362 | |
363 | case ACL_OTHER: |
364 | pa->e_perm = (mode & S_IRWXO); |
365 | break; |
366 | |
367 | default: |
368 | return -EIO; |
369 | } |
370 | } |
371 | |
372 | if (mask_obj) { |
373 | mask_obj->e_perm = (mode & S_IRWXG) >> 3; |
374 | } else { |
375 | if (!group_obj) |
376 | return -EIO; |
377 | group_obj->e_perm = (mode & S_IRWXG) >> 3; |
378 | } |
379 | |
380 | return 0; |
381 | } |