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
posix_acl_init(struct posix_acl * acl,int count)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 *
posix_acl_alloc(int count,gfp_t flags)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 *
posix_acl_clone(const struct posix_acl * acl,gfp_t flags)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
posix_acl_valid(const struct posix_acl * acl)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
posix_acl_equiv_mode(const struct posix_acl * acl,umode_t * mode_p)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 *
posix_acl_from_mode(umode_t mode,gfp_t flags)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
posix_acl_permission(struct inode * inode,const struct posix_acl * acl,int want)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 */
posix_acl_create_masq(struct posix_acl * acl,umode_t * mode_p)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 * posix_acl_update_mode - update mode in set_acl
340 *
341 * Update the file mode when setting an ACL: compute the new file permission
342 * bits based on the ACL. In addition, if the ACL is equivalent to the new
343 * file mode, set *acl to NULL to indicate that no ACL should be set.
344 *
345 * As with chmod, clear the setgit bit if the caller is not in the owning group
346 * or capable of CAP_FSETID (see inode_change_ok).
347 *
348 * Called from set_acl inode operations.
349 */
posix_acl_update_mode(struct inode * inode,umode_t * mode_p,struct posix_acl ** acl)350 int posix_acl_update_mode(struct inode *inode, umode_t *mode_p,
351 struct posix_acl **acl)
352 {
353 umode_t mode = inode->i_mode;
354 int error;
355
356 error = posix_acl_equiv_mode(*acl, &mode);
357 if (error < 0)
358 return error;
359 if (error == 0)
360 *acl = NULL;
361 if (!in_group_p(inode->i_gid) &&
362 !capable_wrt_inode_uidgid(inode, CAP_FSETID))
363 mode &= ~S_ISGID;
364 *mode_p = mode;
365 return 0;
366 }
367 EXPORT_SYMBOL(posix_acl_update_mode);
368
369 /*
370 * Modify the ACL for the chmod syscall.
371 */
posix_acl_chmod_masq(struct posix_acl * acl,umode_t mode)372 static int posix_acl_chmod_masq(struct posix_acl *acl, umode_t mode)
373 {
374 struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL;
375 struct posix_acl_entry *pa, *pe;
376
377 /* assert(atomic_read(acl->a_refcount) == 1); */
378
379 FOREACH_ACL_ENTRY(pa, acl, pe) {
380 switch(pa->e_tag) {
381 case ACL_USER_OBJ:
382 pa->e_perm = (mode & S_IRWXU) >> 6;
383 break;
384
385 case ACL_USER:
386 case ACL_GROUP:
387 break;
388
389 case ACL_GROUP_OBJ:
390 group_obj = pa;
391 break;
392
393 case ACL_MASK:
394 mask_obj = pa;
395 break;
396
397 case ACL_OTHER:
398 pa->e_perm = (mode & S_IRWXO);
399 break;
400
401 default:
402 return -EIO;
403 }
404 }
405
406 if (mask_obj) {
407 mask_obj->e_perm = (mode & S_IRWXG) >> 3;
408 } else {
409 if (!group_obj)
410 return -EIO;
411 group_obj->e_perm = (mode & S_IRWXG) >> 3;
412 }
413
414 return 0;
415 }
416
417 int
posix_acl_create(struct posix_acl ** acl,gfp_t gfp,umode_t * mode_p)418 posix_acl_create(struct posix_acl **acl, gfp_t gfp, umode_t *mode_p)
419 {
420 struct posix_acl *clone = posix_acl_clone(*acl, gfp);
421 int err = -ENOMEM;
422 if (clone) {
423 err = posix_acl_create_masq(clone, mode_p);
424 if (err < 0) {
425 posix_acl_release(clone);
426 clone = NULL;
427 }
428 }
429 posix_acl_release(*acl);
430 *acl = clone;
431 return err;
432 }
433 EXPORT_SYMBOL(posix_acl_create);
434
435 int
posix_acl_chmod(struct posix_acl ** acl,gfp_t gfp,umode_t mode)436 posix_acl_chmod(struct posix_acl **acl, gfp_t gfp, umode_t mode)
437 {
438 struct posix_acl *clone = posix_acl_clone(*acl, gfp);
439 int err = -ENOMEM;
440 if (clone) {
441 err = posix_acl_chmod_masq(clone, mode);
442 if (err) {
443 posix_acl_release(clone);
444 clone = NULL;
445 }
446 }
447 posix_acl_release(*acl);
448 *acl = clone;
449 return err;
450 }
451 EXPORT_SYMBOL(posix_acl_chmod);
452