TOMOYO: Rename directives.
[linux-2.6.git] / security / tomoyo / file.c
1 /*
2  * security/tomoyo/file.c
3  *
4  * Pathname restriction functions.
5  *
6  * Copyright (C) 2005-2010  NTT DATA CORPORATION
7  */
8
9 #include "common.h"
10 #include <linux/slab.h>
11
12 /* Keyword array for operations with one pathname. */
13 const char *tomoyo_path_keyword[TOMOYO_MAX_PATH_OPERATION] = {
14         [TOMOYO_TYPE_EXECUTE]    = "execute",
15         [TOMOYO_TYPE_READ]       = "read",
16         [TOMOYO_TYPE_WRITE]      = "write",
17         [TOMOYO_TYPE_APPEND]     = "append",
18         [TOMOYO_TYPE_UNLINK]     = "unlink",
19         [TOMOYO_TYPE_GETATTR]    = "getattr",
20         [TOMOYO_TYPE_RMDIR]      = "rmdir",
21         [TOMOYO_TYPE_TRUNCATE]   = "truncate",
22         [TOMOYO_TYPE_SYMLINK]    = "symlink",
23         [TOMOYO_TYPE_CHROOT]     = "chroot",
24         [TOMOYO_TYPE_UMOUNT]     = "unmount",
25 };
26
27 /* Keyword array for operations with one pathname and three numbers. */
28 const char *tomoyo_mkdev_keyword[TOMOYO_MAX_MKDEV_OPERATION] = {
29         [TOMOYO_TYPE_MKBLOCK]    = "mkblock",
30         [TOMOYO_TYPE_MKCHAR]     = "mkchar",
31 };
32
33 /* Keyword array for operations with two pathnames. */
34 const char *tomoyo_path2_keyword[TOMOYO_MAX_PATH2_OPERATION] = {
35         [TOMOYO_TYPE_LINK]       = "link",
36         [TOMOYO_TYPE_RENAME]     = "rename",
37         [TOMOYO_TYPE_PIVOT_ROOT] = "pivot_root",
38 };
39
40 /* Keyword array for operations with one pathname and one number. */
41 const char *tomoyo_path_number_keyword[TOMOYO_MAX_PATH_NUMBER_OPERATION] = {
42         [TOMOYO_TYPE_CREATE]     = "create",
43         [TOMOYO_TYPE_MKDIR]      = "mkdir",
44         [TOMOYO_TYPE_MKFIFO]     = "mkfifo",
45         [TOMOYO_TYPE_MKSOCK]     = "mksock",
46         [TOMOYO_TYPE_IOCTL]      = "ioctl",
47         [TOMOYO_TYPE_CHMOD]      = "chmod",
48         [TOMOYO_TYPE_CHOWN]      = "chown",
49         [TOMOYO_TYPE_CHGRP]      = "chgrp",
50 };
51
52 /*
53  * Mapping table from "enum tomoyo_path_acl_index" to "enum tomoyo_mac_index".
54  */
55 static const u8 tomoyo_p2mac[TOMOYO_MAX_PATH_OPERATION] = {
56         [TOMOYO_TYPE_EXECUTE]    = TOMOYO_MAC_FILE_EXECUTE,
57         [TOMOYO_TYPE_READ]       = TOMOYO_MAC_FILE_OPEN,
58         [TOMOYO_TYPE_WRITE]      = TOMOYO_MAC_FILE_OPEN,
59         [TOMOYO_TYPE_APPEND]     = TOMOYO_MAC_FILE_OPEN,
60         [TOMOYO_TYPE_UNLINK]     = TOMOYO_MAC_FILE_UNLINK,
61         [TOMOYO_TYPE_GETATTR]    = TOMOYO_MAC_FILE_GETATTR,
62         [TOMOYO_TYPE_RMDIR]      = TOMOYO_MAC_FILE_RMDIR,
63         [TOMOYO_TYPE_TRUNCATE]   = TOMOYO_MAC_FILE_TRUNCATE,
64         [TOMOYO_TYPE_SYMLINK]    = TOMOYO_MAC_FILE_SYMLINK,
65         [TOMOYO_TYPE_CHROOT]     = TOMOYO_MAC_FILE_CHROOT,
66         [TOMOYO_TYPE_UMOUNT]     = TOMOYO_MAC_FILE_UMOUNT,
67 };
68
69 /*
70  * Mapping table from "enum tomoyo_mkdev_acl_index" to "enum tomoyo_mac_index".
71  */
72 const u8 tomoyo_pnnn2mac[TOMOYO_MAX_MKDEV_OPERATION] = {
73         [TOMOYO_TYPE_MKBLOCK] = TOMOYO_MAC_FILE_MKBLOCK,
74         [TOMOYO_TYPE_MKCHAR]  = TOMOYO_MAC_FILE_MKCHAR,
75 };
76
77 /*
78  * Mapping table from "enum tomoyo_path2_acl_index" to "enum tomoyo_mac_index".
79  */
80 const u8 tomoyo_pp2mac[TOMOYO_MAX_PATH2_OPERATION] = {
81         [TOMOYO_TYPE_LINK]       = TOMOYO_MAC_FILE_LINK,
82         [TOMOYO_TYPE_RENAME]     = TOMOYO_MAC_FILE_RENAME,
83         [TOMOYO_TYPE_PIVOT_ROOT] = TOMOYO_MAC_FILE_PIVOT_ROOT,
84 };
85
86 /*
87  * Mapping table from "enum tomoyo_path_number_acl_index" to
88  * "enum tomoyo_mac_index".
89  */
90 const u8 tomoyo_pn2mac[TOMOYO_MAX_PATH_NUMBER_OPERATION] = {
91         [TOMOYO_TYPE_CREATE] = TOMOYO_MAC_FILE_CREATE,
92         [TOMOYO_TYPE_MKDIR]  = TOMOYO_MAC_FILE_MKDIR,
93         [TOMOYO_TYPE_MKFIFO] = TOMOYO_MAC_FILE_MKFIFO,
94         [TOMOYO_TYPE_MKSOCK] = TOMOYO_MAC_FILE_MKSOCK,
95         [TOMOYO_TYPE_IOCTL]  = TOMOYO_MAC_FILE_IOCTL,
96         [TOMOYO_TYPE_CHMOD]  = TOMOYO_MAC_FILE_CHMOD,
97         [TOMOYO_TYPE_CHOWN]  = TOMOYO_MAC_FILE_CHOWN,
98         [TOMOYO_TYPE_CHGRP]  = TOMOYO_MAC_FILE_CHGRP,
99 };
100
101 /**
102  * tomoyo_put_name_union - Drop reference on "struct tomoyo_name_union".
103  *
104  * @ptr: Pointer to "struct tomoyo_name_union".
105  *
106  * Returns nothing.
107  */
108 void tomoyo_put_name_union(struct tomoyo_name_union *ptr)
109 {
110         tomoyo_put_group(ptr->group);
111         tomoyo_put_name(ptr->filename);
112 }
113
114 /**
115  * tomoyo_compare_name_union - Check whether a name matches "struct tomoyo_name_union" or not.
116  *
117  * @name: Pointer to "struct tomoyo_path_info".
118  * @ptr:  Pointer to "struct tomoyo_name_union".
119  *
120  * Returns "struct tomoyo_path_info" if @name matches @ptr, NULL otherwise.
121  */
122 const struct tomoyo_path_info *
123 tomoyo_compare_name_union(const struct tomoyo_path_info *name,
124                           const struct tomoyo_name_union *ptr)
125 {
126         if (ptr->group)
127                 return tomoyo_path_matches_group(name, ptr->group);
128         if (tomoyo_path_matches_pattern(name, ptr->filename))
129                 return ptr->filename;
130         return NULL;
131 }
132
133 /**
134  * tomoyo_put_number_union - Drop reference on "struct tomoyo_number_union".
135  *
136  * @ptr: Pointer to "struct tomoyo_number_union".
137  *
138  * Returns nothing.
139  */
140 void tomoyo_put_number_union(struct tomoyo_number_union *ptr)
141 {
142         tomoyo_put_group(ptr->group);
143 }
144
145 /**
146  * tomoyo_compare_number_union - Check whether a value matches "struct tomoyo_number_union" or not.
147  *
148  * @value: Number to check.
149  * @ptr:   Pointer to "struct tomoyo_number_union".
150  *
151  * Returns true if @value matches @ptr, false otherwise.
152  */
153 bool tomoyo_compare_number_union(const unsigned long value,
154                                  const struct tomoyo_number_union *ptr)
155 {
156         if (ptr->group)
157                 return tomoyo_number_matches_group(value, value, ptr->group);
158         return value >= ptr->values[0] && value <= ptr->values[1];
159 }
160
161 /**
162  * tomoyo_add_slash - Add trailing '/' if needed.
163  *
164  * @buf: Pointer to "struct tomoyo_path_info".
165  *
166  * Returns nothing.
167  *
168  * @buf must be generated by tomoyo_encode() because this function does not
169  * allocate memory for adding '/'.
170  */
171 static void tomoyo_add_slash(struct tomoyo_path_info *buf)
172 {
173         if (buf->is_dir)
174                 return;
175         /*
176          * This is OK because tomoyo_encode() reserves space for appending "/".
177          */
178         strcat((char *) buf->name, "/");
179         tomoyo_fill_path_info(buf);
180 }
181
182 /**
183  * tomoyo_get_realpath - Get realpath.
184  *
185  * @buf:  Pointer to "struct tomoyo_path_info".
186  * @path: Pointer to "struct path".
187  *
188  * Returns true on success, false otherwise.
189  */
190 static bool tomoyo_get_realpath(struct tomoyo_path_info *buf, struct path *path)
191 {
192         buf->name = tomoyo_realpath_from_path(path);
193         if (buf->name) {
194                 tomoyo_fill_path_info(buf);
195                 return true;
196         }
197         return false;
198 }
199
200 /**
201  * tomoyo_audit_path_log - Audit path request log.
202  *
203  * @r: Pointer to "struct tomoyo_request_info".
204  *
205  * Returns 0 on success, negative value otherwise.
206  */
207 static int tomoyo_audit_path_log(struct tomoyo_request_info *r)
208 {
209         const char *operation = tomoyo_path_keyword[r->param.path.operation];
210         const struct tomoyo_path_info *filename = r->param.path.filename;
211         if (r->granted)
212                 return 0;
213         tomoyo_warn_log(r, "%s %s", operation, filename->name);
214         return tomoyo_supervisor(r, "file %s %s\n", operation, filename->name);
215 }
216
217 /**
218  * tomoyo_audit_path2_log - Audit path/path request log.
219  *
220  * @r: Pointer to "struct tomoyo_request_info".
221  *
222  * Returns 0 on success, negative value otherwise.
223  */
224 static int tomoyo_audit_path2_log(struct tomoyo_request_info *r)
225 {
226         const char *operation = tomoyo_path2_keyword[r->param.path2.operation];
227         const struct tomoyo_path_info *filename1 = r->param.path2.filename1;
228         const struct tomoyo_path_info *filename2 = r->param.path2.filename2;
229         if (r->granted)
230                 return 0;
231         tomoyo_warn_log(r, "%s %s %s", operation, filename1->name,
232                         filename2->name);
233         return tomoyo_supervisor(r, "file %s %s %s\n", operation,
234                                  filename1->name, filename2->name);
235 }
236
237 /**
238  * tomoyo_audit_mkdev_log - Audit path/number/number/number request log.
239  *
240  * @r: Pointer to "struct tomoyo_request_info".
241  *
242  * Returns 0 on success, negative value otherwise.
243  */
244 static int tomoyo_audit_mkdev_log(struct tomoyo_request_info *r)
245 {
246         const char *operation = tomoyo_mkdev_keyword[r->param.mkdev.operation];
247         const struct tomoyo_path_info *filename = r->param.mkdev.filename;
248         const unsigned int major = r->param.mkdev.major;
249         const unsigned int minor = r->param.mkdev.minor;
250         const unsigned int mode = r->param.mkdev.mode;
251         if (r->granted)
252                 return 0;
253         tomoyo_warn_log(r, "%s %s 0%o %u %u", operation, filename->name, mode,
254                         major, minor);
255         return tomoyo_supervisor(r, "file %s %s 0%o %u %u\n", operation,
256                                  filename->name, mode, major, minor);
257 }
258
259 /**
260  * tomoyo_audit_path_number_log - Audit path/number request log.
261  *
262  * @r: Pointer to "struct tomoyo_request_info".
263  *
264  * Returns 0 on success, negative value otherwise.
265  */
266 static int tomoyo_audit_path_number_log(struct tomoyo_request_info *r)
267 {
268         const u8 type = r->param.path_number.operation;
269         u8 radix;
270         const struct tomoyo_path_info *filename = r->param.path_number.filename;
271         const char *operation = tomoyo_path_number_keyword[type];
272         char buffer[64];
273         if (r->granted)
274                 return 0;
275         switch (type) {
276         case TOMOYO_TYPE_CREATE:
277         case TOMOYO_TYPE_MKDIR:
278         case TOMOYO_TYPE_MKFIFO:
279         case TOMOYO_TYPE_MKSOCK:
280         case TOMOYO_TYPE_CHMOD:
281                 radix = TOMOYO_VALUE_TYPE_OCTAL;
282                 break;
283         case TOMOYO_TYPE_IOCTL:
284                 radix = TOMOYO_VALUE_TYPE_HEXADECIMAL;
285                 break;
286         default:
287                 radix = TOMOYO_VALUE_TYPE_DECIMAL;
288                 break;
289         }
290         tomoyo_print_ulong(buffer, sizeof(buffer), r->param.path_number.number,
291                            radix);
292         tomoyo_warn_log(r, "%s %s %s", operation, filename->name, buffer);
293         return tomoyo_supervisor(r, "file %s %s %s\n", operation,
294                                  filename->name, buffer);
295 }
296
297 /**
298  * tomoyo_check_path_acl - Check permission for path operation.
299  *
300  * @r:   Pointer to "struct tomoyo_request_info".
301  * @ptr: Pointer to "struct tomoyo_acl_info".
302  *
303  * Returns true if granted, false otherwise.
304  *
305  * To be able to use wildcard for domain transition, this function sets
306  * matching entry on success. Since the caller holds tomoyo_read_lock(),
307  * it is safe to set matching entry.
308  */
309 static bool tomoyo_check_path_acl(struct tomoyo_request_info *r,
310                                   const struct tomoyo_acl_info *ptr)
311 {
312         const struct tomoyo_path_acl *acl = container_of(ptr, typeof(*acl),
313                                                          head);
314         if (acl->perm & (1 << r->param.path.operation)) {
315                 r->param.path.matched_path =
316                         tomoyo_compare_name_union(r->param.path.filename,
317                                                   &acl->name);
318                 return r->param.path.matched_path != NULL;
319         }
320         return false;
321 }
322
323 /**
324  * tomoyo_check_path_number_acl - Check permission for path number operation.
325  *
326  * @r:   Pointer to "struct tomoyo_request_info".
327  * @ptr: Pointer to "struct tomoyo_acl_info".
328  *
329  * Returns true if granted, false otherwise.
330  */
331 static bool tomoyo_check_path_number_acl(struct tomoyo_request_info *r,
332                                          const struct tomoyo_acl_info *ptr)
333 {
334         const struct tomoyo_path_number_acl *acl =
335                 container_of(ptr, typeof(*acl), head);
336         return (acl->perm & (1 << r->param.path_number.operation)) &&
337                 tomoyo_compare_number_union(r->param.path_number.number,
338                                             &acl->number) &&
339                 tomoyo_compare_name_union(r->param.path_number.filename,
340                                           &acl->name);
341 }
342
343 /**
344  * tomoyo_check_path2_acl - Check permission for path path operation.
345  *
346  * @r:   Pointer to "struct tomoyo_request_info".
347  * @ptr: Pointer to "struct tomoyo_acl_info".
348  *
349  * Returns true if granted, false otherwise.
350  */
351 static bool tomoyo_check_path2_acl(struct tomoyo_request_info *r,
352                                    const struct tomoyo_acl_info *ptr)
353 {
354         const struct tomoyo_path2_acl *acl =
355                 container_of(ptr, typeof(*acl), head);
356         return (acl->perm & (1 << r->param.path2.operation)) &&
357                 tomoyo_compare_name_union(r->param.path2.filename1, &acl->name1)
358                 && tomoyo_compare_name_union(r->param.path2.filename2,
359                                              &acl->name2);
360 }
361
362 /**
363  * tomoyo_check_mkdev_acl - Check permission for path number number number operation.
364  *
365  * @r:   Pointer to "struct tomoyo_request_info".
366  * @ptr: Pointer to "struct tomoyo_acl_info".
367  *
368  * Returns true if granted, false otherwise.
369  */
370 static bool tomoyo_check_mkdev_acl(struct tomoyo_request_info *r,
371                                    const struct tomoyo_acl_info *ptr)
372 {
373         const struct tomoyo_mkdev_acl *acl =
374                 container_of(ptr, typeof(*acl), head);
375         return (acl->perm & (1 << r->param.mkdev.operation)) &&
376                 tomoyo_compare_number_union(r->param.mkdev.mode,
377                                             &acl->mode) &&
378                 tomoyo_compare_number_union(r->param.mkdev.major,
379                                             &acl->major) &&
380                 tomoyo_compare_number_union(r->param.mkdev.minor,
381                                             &acl->minor) &&
382                 tomoyo_compare_name_union(r->param.mkdev.filename,
383                                           &acl->name);
384 }
385
386 /**
387  * tomoyo_same_path_acl - Check for duplicated "struct tomoyo_path_acl" entry.
388  *
389  * @a: Pointer to "struct tomoyo_acl_info".
390  * @b: Pointer to "struct tomoyo_acl_info".
391  *
392  * Returns true if @a == @b except permission bits, false otherwise.
393  */
394 static bool tomoyo_same_path_acl(const struct tomoyo_acl_info *a,
395                                  const struct tomoyo_acl_info *b)
396 {
397         const struct tomoyo_path_acl *p1 = container_of(a, typeof(*p1), head);
398         const struct tomoyo_path_acl *p2 = container_of(b, typeof(*p2), head);
399         return tomoyo_same_name_union(&p1->name, &p2->name);
400 }
401
402 /**
403  * tomoyo_merge_path_acl - Merge duplicated "struct tomoyo_path_acl" entry.
404  *
405  * @a:         Pointer to "struct tomoyo_acl_info".
406  * @b:         Pointer to "struct tomoyo_acl_info".
407  * @is_delete: True for @a &= ~@b, false for @a |= @b.
408  *
409  * Returns true if @a is empty, false otherwise.
410  */
411 static bool tomoyo_merge_path_acl(struct tomoyo_acl_info *a,
412                                   struct tomoyo_acl_info *b,
413                                   const bool is_delete)
414 {
415         u16 * const a_perm = &container_of(a, struct tomoyo_path_acl, head)
416                 ->perm;
417         u16 perm = *a_perm;
418         const u16 b_perm = container_of(b, struct tomoyo_path_acl, head)->perm;
419         if (is_delete)
420                 perm &= ~b_perm;
421         else
422                 perm |= b_perm;
423         *a_perm = perm;
424         return !perm;
425 }
426
427 /**
428  * tomoyo_update_path_acl - Update "struct tomoyo_path_acl" list.
429  *
430  * @perm:  Permission.
431  * @param: Pointer to "struct tomoyo_acl_param".
432  *
433  * Returns 0 on success, negative value otherwise.
434  *
435  * Caller holds tomoyo_read_lock().
436  */
437 static int tomoyo_update_path_acl(const u16 perm,
438                                   struct tomoyo_acl_param *param)
439 {
440         struct tomoyo_path_acl e = {
441                 .head.type = TOMOYO_TYPE_PATH_ACL,
442                 .perm = perm
443         };
444         int error;
445         if (!tomoyo_parse_name_union(param, &e.name))
446                 error = -EINVAL;
447         else
448                 error = tomoyo_update_domain(&e.head, sizeof(e), param,
449                                              tomoyo_same_path_acl,
450                                              tomoyo_merge_path_acl);
451         tomoyo_put_name_union(&e.name);
452         return error;
453 }
454
455 /**
456  * tomoyo_same_mkdev_acl - Check for duplicated "struct tomoyo_mkdev_acl" entry.
457  *
458  * @a: Pointer to "struct tomoyo_acl_info".
459  * @b: Pointer to "struct tomoyo_acl_info".
460  *
461  * Returns true if @a == @b except permission bits, false otherwise.
462  */
463 static bool tomoyo_same_mkdev_acl(const struct tomoyo_acl_info *a,
464                                          const struct tomoyo_acl_info *b)
465 {
466         const struct tomoyo_mkdev_acl *p1 = container_of(a, typeof(*p1), head);
467         const struct tomoyo_mkdev_acl *p2 = container_of(b, typeof(*p2), head);
468         return tomoyo_same_name_union(&p1->name, &p2->name) &&
469                 tomoyo_same_number_union(&p1->mode, &p2->mode) &&
470                 tomoyo_same_number_union(&p1->major, &p2->major) &&
471                 tomoyo_same_number_union(&p1->minor, &p2->minor);
472 }
473
474 /**
475  * tomoyo_merge_mkdev_acl - Merge duplicated "struct tomoyo_mkdev_acl" entry.
476  *
477  * @a:         Pointer to "struct tomoyo_acl_info".
478  * @b:         Pointer to "struct tomoyo_acl_info".
479  * @is_delete: True for @a &= ~@b, false for @a |= @b.
480  *
481  * Returns true if @a is empty, false otherwise.
482  */
483 static bool tomoyo_merge_mkdev_acl(struct tomoyo_acl_info *a,
484                                    struct tomoyo_acl_info *b,
485                                    const bool is_delete)
486 {
487         u8 *const a_perm = &container_of(a, struct tomoyo_mkdev_acl,
488                                          head)->perm;
489         u8 perm = *a_perm;
490         const u8 b_perm = container_of(b, struct tomoyo_mkdev_acl, head)
491                 ->perm;
492         if (is_delete)
493                 perm &= ~b_perm;
494         else
495                 perm |= b_perm;
496         *a_perm = perm;
497         return !perm;
498 }
499
500 /**
501  * tomoyo_update_mkdev_acl - Update "struct tomoyo_mkdev_acl" list.
502  *
503  * @perm:  Permission.
504  * @param: Pointer to "struct tomoyo_acl_param".
505  *
506  * Returns 0 on success, negative value otherwise.
507  *
508  * Caller holds tomoyo_read_lock().
509  */
510 static int tomoyo_update_mkdev_acl(const u8 perm,
511                                    struct tomoyo_acl_param *param)
512 {
513         struct tomoyo_mkdev_acl e = {
514                 .head.type = TOMOYO_TYPE_MKDEV_ACL,
515                 .perm = perm
516         };
517         int error;
518         if (!tomoyo_parse_name_union(param, &e.name) ||
519             !tomoyo_parse_number_union(param, &e.mode) ||
520             !tomoyo_parse_number_union(param, &e.major) ||
521             !tomoyo_parse_number_union(param, &e.minor))
522                 error = -EINVAL;
523         else
524                 error = tomoyo_update_domain(&e.head, sizeof(e), param,
525                                              tomoyo_same_mkdev_acl,
526                                              tomoyo_merge_mkdev_acl);
527         tomoyo_put_name_union(&e.name);
528         tomoyo_put_number_union(&e.mode);
529         tomoyo_put_number_union(&e.major);
530         tomoyo_put_number_union(&e.minor);
531         return error;
532 }
533
534 /**
535  * tomoyo_same_path2_acl - Check for duplicated "struct tomoyo_path2_acl" entry.
536  *
537  * @a: Pointer to "struct tomoyo_acl_info".
538  * @b: Pointer to "struct tomoyo_acl_info".
539  *
540  * Returns true if @a == @b except permission bits, false otherwise.
541  */
542 static bool tomoyo_same_path2_acl(const struct tomoyo_acl_info *a,
543                                   const struct tomoyo_acl_info *b)
544 {
545         const struct tomoyo_path2_acl *p1 = container_of(a, typeof(*p1), head);
546         const struct tomoyo_path2_acl *p2 = container_of(b, typeof(*p2), head);
547         return tomoyo_same_name_union(&p1->name1, &p2->name1) &&
548                 tomoyo_same_name_union(&p1->name2, &p2->name2);
549 }
550
551 /**
552  * tomoyo_merge_path2_acl - Merge duplicated "struct tomoyo_path2_acl" entry.
553  *
554  * @a:         Pointer to "struct tomoyo_acl_info".
555  * @b:         Pointer to "struct tomoyo_acl_info".
556  * @is_delete: True for @a &= ~@b, false for @a |= @b.
557  *
558  * Returns true if @a is empty, false otherwise.
559  */
560 static bool tomoyo_merge_path2_acl(struct tomoyo_acl_info *a,
561                                    struct tomoyo_acl_info *b,
562                                    const bool is_delete)
563 {
564         u8 * const a_perm = &container_of(a, struct tomoyo_path2_acl, head)
565                 ->perm;
566         u8 perm = *a_perm;
567         const u8 b_perm = container_of(b, struct tomoyo_path2_acl, head)->perm;
568         if (is_delete)
569                 perm &= ~b_perm;
570         else
571                 perm |= b_perm;
572         *a_perm = perm;
573         return !perm;
574 }
575
576 /**
577  * tomoyo_update_path2_acl - Update "struct tomoyo_path2_acl" list.
578  *
579  * @perm:  Permission.
580  * @param: Pointer to "struct tomoyo_acl_param".
581  *
582  * Returns 0 on success, negative value otherwise.
583  *
584  * Caller holds tomoyo_read_lock().
585  */
586 static int tomoyo_update_path2_acl(const u8 perm,
587                                    struct tomoyo_acl_param *param)
588 {
589         struct tomoyo_path2_acl e = {
590                 .head.type = TOMOYO_TYPE_PATH2_ACL,
591                 .perm = perm
592         };
593         int error;
594         if (!tomoyo_parse_name_union(param, &e.name1) ||
595             !tomoyo_parse_name_union(param, &e.name2))
596                 error = -EINVAL;
597         else
598                 error = tomoyo_update_domain(&e.head, sizeof(e), param,
599                                              tomoyo_same_path2_acl,
600                                              tomoyo_merge_path2_acl);
601         tomoyo_put_name_union(&e.name1);
602         tomoyo_put_name_union(&e.name2);
603         return error;
604 }
605
606 /**
607  * tomoyo_path_permission - Check permission for single path operation.
608  *
609  * @r:         Pointer to "struct tomoyo_request_info".
610  * @operation: Type of operation.
611  * @filename:  Filename to check.
612  *
613  * Returns 0 on success, negative value otherwise.
614  *
615  * Caller holds tomoyo_read_lock().
616  */
617 int tomoyo_path_permission(struct tomoyo_request_info *r, u8 operation,
618                            const struct tomoyo_path_info *filename)
619 {
620         int error;
621
622         r->type = tomoyo_p2mac[operation];
623         r->mode = tomoyo_get_mode(r->profile, r->type);
624         if (r->mode == TOMOYO_CONFIG_DISABLED)
625                 return 0;
626         r->param_type = TOMOYO_TYPE_PATH_ACL;
627         r->param.path.filename = filename;
628         r->param.path.operation = operation;
629         do {
630                 tomoyo_check_acl(r, tomoyo_check_path_acl);
631                 error = tomoyo_audit_path_log(r);
632                 /*
633                  * Do not retry for execute request, for alias may have
634                  * changed.
635                  */
636         } while (error == TOMOYO_RETRY_REQUEST &&
637                  operation != TOMOYO_TYPE_EXECUTE);
638         return error;
639 }
640
641 /**
642  * tomoyo_same_path_number_acl - Check for duplicated "struct tomoyo_path_number_acl" entry.
643  *
644  * @a: Pointer to "struct tomoyo_acl_info".
645  * @b: Pointer to "struct tomoyo_acl_info".
646  *
647  * Returns true if @a == @b except permission bits, false otherwise.
648  */
649 static bool tomoyo_same_path_number_acl(const struct tomoyo_acl_info *a,
650                                         const struct tomoyo_acl_info *b)
651 {
652         const struct tomoyo_path_number_acl *p1 = container_of(a, typeof(*p1),
653                                                                head);
654         const struct tomoyo_path_number_acl *p2 = container_of(b, typeof(*p2),
655                                                                head);
656         return tomoyo_same_name_union(&p1->name, &p2->name) &&
657                 tomoyo_same_number_union(&p1->number, &p2->number);
658 }
659
660 /**
661  * tomoyo_merge_path_number_acl - Merge duplicated "struct tomoyo_path_number_acl" entry.
662  *
663  * @a:         Pointer to "struct tomoyo_acl_info".
664  * @b:         Pointer to "struct tomoyo_acl_info".
665  * @is_delete: True for @a &= ~@b, false for @a |= @b.
666  *
667  * Returns true if @a is empty, false otherwise.
668  */
669 static bool tomoyo_merge_path_number_acl(struct tomoyo_acl_info *a,
670                                          struct tomoyo_acl_info *b,
671                                          const bool is_delete)
672 {
673         u8 * const a_perm = &container_of(a, struct tomoyo_path_number_acl,
674                                           head)->perm;
675         u8 perm = *a_perm;
676         const u8 b_perm = container_of(b, struct tomoyo_path_number_acl, head)
677                 ->perm;
678         if (is_delete)
679                 perm &= ~b_perm;
680         else
681                 perm |= b_perm;
682         *a_perm = perm;
683         return !perm;
684 }
685
686 /**
687  * tomoyo_update_path_number_acl - Update ioctl/chmod/chown/chgrp ACL.
688  *
689  * @perm:  Permission.
690  * @param: Pointer to "struct tomoyo_acl_param".
691  *
692  * Returns 0 on success, negative value otherwise.
693  */
694 static int tomoyo_update_path_number_acl(const u8 perm,
695                                          struct tomoyo_acl_param *param)
696 {
697         struct tomoyo_path_number_acl e = {
698                 .head.type = TOMOYO_TYPE_PATH_NUMBER_ACL,
699                 .perm = perm
700         };
701         int error;
702         if (!tomoyo_parse_name_union(param, &e.name) ||
703             !tomoyo_parse_number_union(param, &e.number))
704                 error = -EINVAL;
705         else
706                 error = tomoyo_update_domain(&e.head, sizeof(e), param,
707                                              tomoyo_same_path_number_acl,
708                                              tomoyo_merge_path_number_acl);
709         tomoyo_put_name_union(&e.name);
710         tomoyo_put_number_union(&e.number);
711         return error;
712 }
713
714 /**
715  * tomoyo_path_number_perm - Check permission for "create", "mkdir", "mkfifo", "mksock", "ioctl", "chmod", "chown", "chgrp".
716  *
717  * @type:   Type of operation.
718  * @path:   Pointer to "struct path".
719  * @number: Number.
720  *
721  * Returns 0 on success, negative value otherwise.
722  */
723 int tomoyo_path_number_perm(const u8 type, struct path *path,
724                             unsigned long number)
725 {
726         struct tomoyo_request_info r;
727         int error = -ENOMEM;
728         struct tomoyo_path_info buf;
729         int idx;
730
731         if (tomoyo_init_request_info(&r, NULL, tomoyo_pn2mac[type])
732             == TOMOYO_CONFIG_DISABLED || !path->mnt || !path->dentry)
733                 return 0;
734         idx = tomoyo_read_lock();
735         if (!tomoyo_get_realpath(&buf, path))
736                 goto out;
737         if (type == TOMOYO_TYPE_MKDIR)
738                 tomoyo_add_slash(&buf);
739         r.param_type = TOMOYO_TYPE_PATH_NUMBER_ACL;
740         r.param.path_number.operation = type;
741         r.param.path_number.filename = &buf;
742         r.param.path_number.number = number;
743         do {
744                 tomoyo_check_acl(&r, tomoyo_check_path_number_acl);
745                 error = tomoyo_audit_path_number_log(&r);
746         } while (error == TOMOYO_RETRY_REQUEST);
747         kfree(buf.name);
748  out:
749         tomoyo_read_unlock(idx);
750         if (r.mode != TOMOYO_CONFIG_ENFORCING)
751                 error = 0;
752         return error;
753 }
754
755 /**
756  * tomoyo_check_open_permission - Check permission for "read" and "write".
757  *
758  * @domain: Pointer to "struct tomoyo_domain_info".
759  * @path:   Pointer to "struct path".
760  * @flag:   Flags for open().
761  *
762  * Returns 0 on success, negative value otherwise.
763  */
764 int tomoyo_check_open_permission(struct tomoyo_domain_info *domain,
765                                  struct path *path, const int flag)
766 {
767         const u8 acc_mode = ACC_MODE(flag);
768         int error = 0;
769         struct tomoyo_path_info buf;
770         struct tomoyo_request_info r;
771         int idx;
772
773         if (!path->mnt)
774                 return 0;
775         buf.name = NULL;
776         r.mode = TOMOYO_CONFIG_DISABLED;
777         idx = tomoyo_read_lock();
778         if (acc_mode &&
779             tomoyo_init_request_info(&r, domain, TOMOYO_MAC_FILE_OPEN)
780             != TOMOYO_CONFIG_DISABLED) {
781                 if (!tomoyo_get_realpath(&buf, path)) {
782                         error = -ENOMEM;
783                         goto out;
784                 }
785                 if (acc_mode & MAY_READ)
786                         error = tomoyo_path_permission(&r, TOMOYO_TYPE_READ,
787                                                        &buf);
788                 if (!error && (acc_mode & MAY_WRITE))
789                         error = tomoyo_path_permission(&r, (flag & O_APPEND) ?
790                                                        TOMOYO_TYPE_APPEND :
791                                                        TOMOYO_TYPE_WRITE,
792                                                        &buf);
793         }
794  out:
795         kfree(buf.name);
796         tomoyo_read_unlock(idx);
797         if (r.mode != TOMOYO_CONFIG_ENFORCING)
798                 error = 0;
799         return error;
800 }
801
802 /**
803  * tomoyo_path_perm - Check permission for "unlink", "rmdir", "truncate", "symlink", "append", "chroot" and "unmount".
804  *
805  * @operation: Type of operation.
806  * @path:      Pointer to "struct path".
807  *
808  * Returns 0 on success, negative value otherwise.
809  */
810 int tomoyo_path_perm(const u8 operation, struct path *path)
811 {
812         struct tomoyo_request_info r;
813         int error;
814         struct tomoyo_path_info buf;
815         bool is_enforce;
816         int idx;
817
818         if (!path->mnt)
819                 return 0;
820         if (tomoyo_init_request_info(&r, NULL, tomoyo_p2mac[operation])
821             == TOMOYO_CONFIG_DISABLED)
822                 return 0;
823         is_enforce = (r.mode == TOMOYO_CONFIG_ENFORCING);
824         error = -ENOMEM;
825         buf.name = NULL;
826         idx = tomoyo_read_lock();
827         if (!tomoyo_get_realpath(&buf, path))
828                 goto out;
829         switch (operation) {
830         case TOMOYO_TYPE_RMDIR:
831         case TOMOYO_TYPE_CHROOT:
832                 tomoyo_add_slash(&buf);
833                 break;
834         }
835         error = tomoyo_path_permission(&r, operation, &buf);
836  out:
837         kfree(buf.name);
838         tomoyo_read_unlock(idx);
839         if (!is_enforce)
840                 error = 0;
841         return error;
842 }
843
844 /**
845  * tomoyo_mkdev_perm - Check permission for "mkblock" and "mkchar".
846  *
847  * @operation: Type of operation. (TOMOYO_TYPE_MKCHAR or TOMOYO_TYPE_MKBLOCK)
848  * @path:      Pointer to "struct path".
849  * @mode:      Create mode.
850  * @dev:       Device number.
851  *
852  * Returns 0 on success, negative value otherwise.
853  */
854 int tomoyo_mkdev_perm(const u8 operation, struct path *path,
855                       const unsigned int mode, unsigned int dev)
856 {
857         struct tomoyo_request_info r;
858         int error = -ENOMEM;
859         struct tomoyo_path_info buf;
860         int idx;
861
862         if (!path->mnt ||
863             tomoyo_init_request_info(&r, NULL, tomoyo_pnnn2mac[operation])
864             == TOMOYO_CONFIG_DISABLED)
865                 return 0;
866         idx = tomoyo_read_lock();
867         error = -ENOMEM;
868         if (tomoyo_get_realpath(&buf, path)) {
869                 dev = new_decode_dev(dev);
870                 r.param_type = TOMOYO_TYPE_MKDEV_ACL;
871                 r.param.mkdev.filename = &buf;
872                 r.param.mkdev.operation = operation;
873                 r.param.mkdev.mode = mode;
874                 r.param.mkdev.major = MAJOR(dev);
875                 r.param.mkdev.minor = MINOR(dev);
876                 tomoyo_check_acl(&r, tomoyo_check_mkdev_acl);
877                 error = tomoyo_audit_mkdev_log(&r);
878                 kfree(buf.name);
879         }
880         tomoyo_read_unlock(idx);
881         if (r.mode != TOMOYO_CONFIG_ENFORCING)
882                 error = 0;
883         return error;
884 }
885
886 /**
887  * tomoyo_path2_perm - Check permission for "rename", "link" and "pivot_root".
888  *
889  * @operation: Type of operation.
890  * @path1:      Pointer to "struct path".
891  * @path2:      Pointer to "struct path".
892  *
893  * Returns 0 on success, negative value otherwise.
894  */
895 int tomoyo_path2_perm(const u8 operation, struct path *path1,
896                       struct path *path2)
897 {
898         int error = -ENOMEM;
899         struct tomoyo_path_info buf1;
900         struct tomoyo_path_info buf2;
901         struct tomoyo_request_info r;
902         int idx;
903
904         if (!path1->mnt || !path2->mnt ||
905             tomoyo_init_request_info(&r, NULL, tomoyo_pp2mac[operation])
906             == TOMOYO_CONFIG_DISABLED)
907                 return 0;
908         buf1.name = NULL;
909         buf2.name = NULL;
910         idx = tomoyo_read_lock();
911         if (!tomoyo_get_realpath(&buf1, path1) ||
912             !tomoyo_get_realpath(&buf2, path2))
913                 goto out;
914         switch (operation) {
915                 struct dentry *dentry;
916         case TOMOYO_TYPE_RENAME:
917         case TOMOYO_TYPE_LINK:
918                 dentry = path1->dentry;
919                 if (!dentry->d_inode || !S_ISDIR(dentry->d_inode->i_mode))
920                         break;
921                 /* fall through */
922         case TOMOYO_TYPE_PIVOT_ROOT:
923                 tomoyo_add_slash(&buf1);
924                 tomoyo_add_slash(&buf2);
925                 break;
926         }
927         r.param_type = TOMOYO_TYPE_PATH2_ACL;
928         r.param.path2.operation = operation;
929         r.param.path2.filename1 = &buf1;
930         r.param.path2.filename2 = &buf2;
931         do {
932                 tomoyo_check_acl(&r, tomoyo_check_path2_acl);
933                 error = tomoyo_audit_path2_log(&r);
934         } while (error == TOMOYO_RETRY_REQUEST);
935  out:
936         kfree(buf1.name);
937         kfree(buf2.name);
938         tomoyo_read_unlock(idx);
939         if (r.mode != TOMOYO_CONFIG_ENFORCING)
940                 error = 0;
941         return error;
942 }
943
944 /**
945  * tomoyo_same_mount_acl - Check for duplicated "struct tomoyo_mount_acl" entry.
946  *
947  * @a: Pointer to "struct tomoyo_acl_info".
948  * @b: Pointer to "struct tomoyo_acl_info".
949  *
950  * Returns true if @a == @b, false otherwise.
951  */
952 static bool tomoyo_same_mount_acl(const struct tomoyo_acl_info *a,
953                                   const struct tomoyo_acl_info *b)
954 {
955         const struct tomoyo_mount_acl *p1 = container_of(a, typeof(*p1), head);
956         const struct tomoyo_mount_acl *p2 = container_of(b, typeof(*p2), head);
957         return tomoyo_same_name_union(&p1->dev_name, &p2->dev_name) &&
958                 tomoyo_same_name_union(&p1->dir_name, &p2->dir_name) &&
959                 tomoyo_same_name_union(&p1->fs_type, &p2->fs_type) &&
960                 tomoyo_same_number_union(&p1->flags, &p2->flags);
961 }
962
963 /**
964  * tomoyo_update_mount_acl - Write "struct tomoyo_mount_acl" list.
965  *
966  * @param: Pointer to "struct tomoyo_acl_param".
967  *
968  * Returns 0 on success, negative value otherwise.
969  *
970  * Caller holds tomoyo_read_lock().
971  */
972 static int tomoyo_update_mount_acl(struct tomoyo_acl_param *param)
973 {
974         struct tomoyo_mount_acl e = { .head.type = TOMOYO_TYPE_MOUNT_ACL };
975         int error;
976         if (!tomoyo_parse_name_union(param, &e.dev_name) ||
977             !tomoyo_parse_name_union(param, &e.dir_name) ||
978             !tomoyo_parse_name_union(param, &e.fs_type) ||
979             !tomoyo_parse_number_union(param, &e.flags))
980                 error = -EINVAL;
981         else
982                 error = tomoyo_update_domain(&e.head, sizeof(e), param,
983                                              tomoyo_same_mount_acl, NULL);
984         tomoyo_put_name_union(&e.dev_name);
985         tomoyo_put_name_union(&e.dir_name);
986         tomoyo_put_name_union(&e.fs_type);
987         tomoyo_put_number_union(&e.flags);
988         return error;
989 }
990
991 /**
992  * tomoyo_write_file - Update file related list.
993  *
994  * @param: Pointer to "struct tomoyo_acl_param".
995  *
996  * Returns 0 on success, negative value otherwise.
997  *
998  * Caller holds tomoyo_read_lock().
999  */
1000 int tomoyo_write_file(struct tomoyo_acl_param *param)
1001 {
1002         u16 perm = 0;
1003         u8 type;
1004         const char *operation = tomoyo_read_token(param);
1005         for (type = 0; type < TOMOYO_MAX_PATH_OPERATION; type++)
1006                 if (tomoyo_permstr(operation, tomoyo_path_keyword[type]))
1007                         perm |= 1 << type;
1008         if (perm)
1009                 return tomoyo_update_path_acl(perm, param);
1010         for (type = 0; type < TOMOYO_MAX_PATH2_OPERATION; type++)
1011                 if (tomoyo_permstr(operation, tomoyo_path2_keyword[type]))
1012                         perm |= 1 << type;
1013         if (perm)
1014                 return tomoyo_update_path2_acl(perm, param);
1015         for (type = 0; type < TOMOYO_MAX_PATH_NUMBER_OPERATION; type++)
1016                 if (tomoyo_permstr(operation,
1017                                    tomoyo_path_number_keyword[type]))
1018                         perm |= 1 << type;
1019         if (perm)
1020                 return tomoyo_update_path_number_acl(perm, param);
1021         for (type = 0; type < TOMOYO_MAX_MKDEV_OPERATION; type++)
1022                 if (tomoyo_permstr(operation, tomoyo_mkdev_keyword[type]))
1023                         perm |= 1 << type;
1024         if (perm)
1025                 return tomoyo_update_mkdev_acl(perm, param);
1026         if (tomoyo_permstr(operation, "mount"))
1027                 return tomoyo_update_mount_acl(param);
1028         return -EINVAL;
1029 }