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

Archive Download this file



interactive