aboutsummaryrefslogtreecommitdiffstats
path: root/fs/posix_acl.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/posix_acl.c')
-rw-r--r--fs/posix_acl.c381
1 files changed, 381 insertions, 0 deletions
diff --git a/fs/posix_acl.c b/fs/posix_acl.c
new file mode 100644
index 000000000000..296480e96dd5
--- /dev/null
+++ b/fs/posix_acl.c
@@ -0,0 +1,381 @@
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, 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 */
53struct posix_acl *
54posix_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 */
73int
74posix_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 */
148int
149posix_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 */
187struct posix_acl *
188posix_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 */
212int
213posix_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
256mask:
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
265check_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 */
279int
280posix_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 */
337int
338posix_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}
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-12 23:09:53 -0500