fat: Remove FAT Directory Bread message
[linux-2.6.git] / fs / posix_acl.c
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/module.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         unsigned int id = 0;  /* keep gcc happy */
82         int needs_mask = 0;
83
84         FOREACH_ACL_ENTRY(pa, acl, pe) {
85                 if (pa->e_perm & ~(ACL_READ|ACL_WRITE|ACL_EXECUTE))
86                         return -EINVAL;
87                 switch (pa->e_tag) {
88                         case ACL_USER_OBJ:
89                                 if (state == ACL_USER_OBJ) {
90                                         id = 0;
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 (pa->e_id == ACL_UNDEFINED_ID ||
100                                     pa->e_id < id)
101                                         return -EINVAL;
102                                 id = pa->e_id + 1;
103                                 needs_mask = 1;
104                                 break;
105
106                         case ACL_GROUP_OBJ:
107                                 if (state == ACL_USER) {
108                                         id = 0;
109                                         state = ACL_GROUP;
110                                         break;
111                                 }
112                                 return -EINVAL;
113
114                         case ACL_GROUP:
115                                 if (state != ACL_GROUP)
116                                         return -EINVAL;
117                                 if (pa->e_id == ACL_UNDEFINED_ID ||
118                                     pa->e_id < id)
119                                         return -EINVAL;
120                                 id = pa->e_id + 1;
121                                 needs_mask = 1;
122                                 break;
123
124                         case ACL_MASK:
125                                 if (state != ACL_GROUP)
126                                         return -EINVAL;
127                                 state = ACL_OTHER;
128                                 break;
129
130                         case ACL_OTHER:
131                                 if (state == ACL_OTHER ||
132                                     (state == ACL_GROUP && !needs_mask)) {
133                                         state = 0;
134                                         break;
135                                 }
136                                 return -EINVAL;
137
138                         default:
139                                 return -EINVAL;
140                 }
141         }
142         if (state == 0)
143                 return 0;
144         return -EINVAL;
145 }
146
147 /*
148  * Returns 0 if the acl can be exactly represented in the traditional
149  * file mode permission bits, or else 1. Returns -E... on error.
150  */
151 int
152 posix_acl_equiv_mode(const struct posix_acl *acl, umode_t *mode_p)
153 {
154         const struct posix_acl_entry *pa, *pe;
155         umode_t mode = 0;
156         int not_equiv = 0;
157
158         FOREACH_ACL_ENTRY(pa, acl, pe) {
159                 switch (pa->e_tag) {
160                         case ACL_USER_OBJ:
161                                 mode |= (pa->e_perm & S_IRWXO) << 6;
162                                 break;
163                         case ACL_GROUP_OBJ:
164                                 mode |= (pa->e_perm & S_IRWXO) << 3;
165                                 break;
166                         case ACL_OTHER:
167                                 mode |= pa->e_perm & S_IRWXO;
168                                 break;
169                         case ACL_MASK:
170                                 mode = (mode & ~S_IRWXG) |
171                                        ((pa->e_perm & S_IRWXO) << 3);
172                                 not_equiv = 1;
173                                 break;
174                         case ACL_USER:
175                         case ACL_GROUP:
176                                 not_equiv = 1;
177                                 break;
178                         default:
179                                 return -EINVAL;
180                 }
181         }
182         if (mode_p)
183                 *mode_p = (*mode_p & ~S_IRWXUGO) | mode;
184         return not_equiv;
185 }
186
187 /*
188  * Create an ACL representing the file mode permission bits of an inode.
189  */
190 struct posix_acl *
191 posix_acl_from_mode(umode_t mode, gfp_t flags)
192 {
193         struct posix_acl *acl = posix_acl_alloc(3, flags);
194         if (!acl)
195                 return ERR_PTR(-ENOMEM);
196
197         acl->a_entries[0].e_tag  = ACL_USER_OBJ;
198         acl->a_entries[0].e_id   = ACL_UNDEFINED_ID;
199         acl->a_entries[0].e_perm = (mode & S_IRWXU) >> 6;
200
201         acl->a_entries[1].e_tag  = ACL_GROUP_OBJ;
202         acl->a_entries[1].e_id   = ACL_UNDEFINED_ID;
203         acl->a_entries[1].e_perm = (mode & S_IRWXG) >> 3;
204
205         acl->a_entries[2].e_tag  = ACL_OTHER;
206         acl->a_entries[2].e_id   = ACL_UNDEFINED_ID;
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         FOREACH_ACL_ENTRY(pa, acl, pe) {
222                 switch(pa->e_tag) {
223                         case ACL_USER_OBJ:
224                                 /* (May have been checked already) */
225                                 if (inode->i_uid == current_fsuid())
226                                         goto check_perm;
227                                 break;
228                         case ACL_USER:
229                                 if (pa->e_id == current_fsuid())
230                                         goto mask;
231                                 break;
232                         case ACL_GROUP_OBJ:
233                                 if (in_group_p(inode->i_gid)) {
234                                         found = 1;
235                                         if ((pa->e_perm & want) == want)
236                                                 goto mask;
237                                 }
238                                 break;
239                         case ACL_GROUP:
240                                 if (in_group_p(pa->e_id)) {
241                                         found = 1;
242                                         if ((pa->e_perm & want) == want)
243                                                 goto mask;
244                                 }
245                                 break;
246                         case ACL_MASK:
247                                 break;
248                         case ACL_OTHER:
249                                 if (found)
250                                         return -EACCES;
251                                 else
252                                         goto check_perm;
253                         default:
254                                 return -EIO;
255                 }
256         }
257         return -EIO;
258
259 mask:
260         for (mask_obj = pa+1; mask_obj != pe; mask_obj++) {
261                 if (mask_obj->e_tag == ACL_MASK) {
262                         if ((pa->e_perm & mask_obj->e_perm & want) == want)
263                                 return 0;
264                         return -EACCES;
265                 }
266         }
267
268 check_perm:
269         if ((pa->e_perm & want) == want)
270                 return 0;
271         return -EACCES;
272 }
273
274 /*
275  * Modify acl when creating a new inode. The caller must ensure the acl is
276  * only referenced once.
277  *
278  * mode_p initially must contain the mode parameter to the open() / creat()
279  * system calls. All permissions that are not granted by the acl are removed.
280  * The permissions in the acl are changed to reflect the mode_p parameter.
281  */
282 static int posix_acl_create_masq(struct posix_acl *acl, umode_t *mode_p)
283 {
284         struct posix_acl_entry *pa, *pe;
285         struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL;
286         umode_t mode = *mode_p;
287         int not_equiv = 0;
288
289         /* assert(atomic_read(acl->a_refcount) == 1); */
290
291         FOREACH_ACL_ENTRY(pa, acl, pe) {
292                 switch(pa->e_tag) {
293                         case ACL_USER_OBJ:
294                                 pa->e_perm &= (mode >> 6) | ~S_IRWXO;
295                                 mode &= (pa->e_perm << 6) | ~S_IRWXU;
296                                 break;
297
298                         case ACL_USER:
299                         case ACL_GROUP:
300                                 not_equiv = 1;
301                                 break;
302
303                         case ACL_GROUP_OBJ:
304                                 group_obj = pa;
305                                 break;
306
307                         case ACL_OTHER:
308                                 pa->e_perm &= mode | ~S_IRWXO;
309                                 mode &= pa->e_perm | ~S_IRWXO;
310                                 break;
311
312                         case ACL_MASK:
313                                 mask_obj = pa;
314                                 not_equiv = 1;
315                                 break;
316
317                         default:
318                                 return -EIO;
319                 }
320         }
321
322         if (mask_obj) {
323                 mask_obj->e_perm &= (mode >> 3) | ~S_IRWXO;
324                 mode &= (mask_obj->e_perm << 3) | ~S_IRWXG;
325         } else {
326                 if (!group_obj)
327                         return -EIO;
328                 group_obj->e_perm &= (mode >> 3) | ~S_IRWXO;
329                 mode &= (group_obj->e_perm << 3) | ~S_IRWXG;
330         }
331
332         *mode_p = (*mode_p & ~S_IRWXUGO) | mode;
333         return not_equiv;
334 }
335
336 /*
337  * Modify the ACL for the chmod syscall.
338  */
339 static int posix_acl_chmod_masq(struct posix_acl *acl, umode_t mode)
340 {
341         struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL;
342         struct posix_acl_entry *pa, *pe;
343
344         /* assert(atomic_read(acl->a_refcount) == 1); */
345
346         FOREACH_ACL_ENTRY(pa, acl, pe) {
347                 switch(pa->e_tag) {
348                         case ACL_USER_OBJ:
349                                 pa->e_perm = (mode & S_IRWXU) >> 6;
350                                 break;
351
352                         case ACL_USER:
353                         case ACL_GROUP:
354                                 break;
355
356                         case ACL_GROUP_OBJ:
357                                 group_obj = pa;
358                                 break;
359
360                         case ACL_MASK:
361                                 mask_obj = pa;
362                                 break;
363
364                         case ACL_OTHER:
365                                 pa->e_perm = (mode & S_IRWXO);
366                                 break;
367
368                         default:
369                                 return -EIO;
370                 }
371         }
372
373         if (mask_obj) {
374                 mask_obj->e_perm = (mode & S_IRWXG) >> 3;
375         } else {
376                 if (!group_obj)
377                         return -EIO;
378                 group_obj->e_perm = (mode & S_IRWXG) >> 3;
379         }
380
381         return 0;
382 }
383
384 int
385 posix_acl_create(struct posix_acl **acl, gfp_t gfp, umode_t *mode_p)
386 {
387         struct posix_acl *clone = posix_acl_clone(*acl, gfp);
388         int err = -ENOMEM;
389         if (clone) {
390                 err = posix_acl_create_masq(clone, mode_p);
391                 if (err < 0) {
392                         posix_acl_release(clone);
393                         clone = NULL;
394                 }
395         }
396         posix_acl_release(*acl);
397         *acl = clone;
398         return err;
399 }
400 EXPORT_SYMBOL(posix_acl_create);
401
402 int
403 posix_acl_chmod(struct posix_acl **acl, gfp_t gfp, umode_t mode)
404 {
405         struct posix_acl *clone = posix_acl_clone(*acl, gfp);
406         int err = -ENOMEM;
407         if (clone) {
408                 err = posix_acl_chmod_masq(clone, mode);
409                 if (err) {
410                         posix_acl_release(clone);
411                         clone = NULL;
412                 }
413         }
414         posix_acl_release(*acl);
415         *acl = clone;
416         return err;
417 }
418 EXPORT_SYMBOL(posix_acl_chmod);