TOMOYO: Cleanup header file.
[linux-2.6.git] / security / tomoyo / common.h
1 /*
2  * security/tomoyo/common.h
3  *
4  * Header file for TOMOYO.
5  *
6  * Copyright (C) 2005-2010  NTT DATA CORPORATION
7  */
8
9 #ifndef _SECURITY_TOMOYO_COMMON_H
10 #define _SECURITY_TOMOYO_COMMON_H
11
12 #include <linux/ctype.h>
13 #include <linux/string.h>
14 #include <linux/mm.h>
15 #include <linux/file.h>
16 #include <linux/kmod.h>
17 #include <linux/fs.h>
18 #include <linux/sched.h>
19 #include <linux/namei.h>
20 #include <linux/mount.h>
21 #include <linux/list.h>
22 #include <linux/cred.h>
23 #include <linux/poll.h>
24 struct linux_binprm;
25
26 /********** Constants definitions. **********/
27
28 /*
29  * TOMOYO uses this hash only when appending a string into the string
30  * table. Frequency of appending strings is very low. So we don't need
31  * large (e.g. 64k) hash size. 256 will be sufficient.
32  */
33 #define TOMOYO_HASH_BITS  8
34 #define TOMOYO_MAX_HASH (1u<<TOMOYO_HASH_BITS)
35
36 #define TOMOYO_EXEC_TMPSIZE     4096
37
38 /* Profile number is an integer between 0 and 255. */
39 #define TOMOYO_MAX_PROFILES 256
40
41 /* Group number is an integer between 0 and 255. */
42 #define TOMOYO_MAX_ACL_GROUPS 256
43
44 /* Index numbers for operation mode. */
45 enum tomoyo_mode_index {
46         TOMOYO_CONFIG_DISABLED,
47         TOMOYO_CONFIG_LEARNING,
48         TOMOYO_CONFIG_PERMISSIVE,
49         TOMOYO_CONFIG_ENFORCING,
50         TOMOYO_CONFIG_MAX_MODE,
51         TOMOYO_CONFIG_WANT_REJECT_LOG =  64,
52         TOMOYO_CONFIG_WANT_GRANT_LOG  = 128,
53         TOMOYO_CONFIG_USE_DEFAULT     = 255,
54 };
55
56 /* Index numbers for entry type. */
57 enum tomoyo_policy_id {
58         TOMOYO_ID_GROUP,
59         TOMOYO_ID_PATH_GROUP,
60         TOMOYO_ID_NUMBER_GROUP,
61         TOMOYO_ID_TRANSITION_CONTROL,
62         TOMOYO_ID_AGGREGATOR,
63         TOMOYO_ID_MANAGER,
64         TOMOYO_ID_NAME,
65         TOMOYO_ID_ACL,
66         TOMOYO_ID_DOMAIN,
67         TOMOYO_MAX_POLICY
68 };
69
70 /* Index numbers for domain's attributes. */
71 enum tomoyo_domain_info_flags_index {
72         /* Quota warnning flag.   */
73         TOMOYO_DIF_QUOTA_WARNED,
74         /*
75          * This domain was unable to create a new domain at
76          * tomoyo_find_next_domain() because the name of the domain to be
77          * created was too long or it could not allocate memory.
78          * More than one process continued execve() without domain transition.
79          */
80         TOMOYO_DIF_TRANSITION_FAILED,
81         TOMOYO_MAX_DOMAIN_INFO_FLAGS
82 };
83
84 /* Index numbers for group entries. */
85 enum tomoyo_group_id {
86         TOMOYO_PATH_GROUP,
87         TOMOYO_NUMBER_GROUP,
88         TOMOYO_MAX_GROUP
89 };
90
91 /* Index numbers for type of numeric values. */
92 enum tomoyo_value_type {
93         TOMOYO_VALUE_TYPE_INVALID,
94         TOMOYO_VALUE_TYPE_DECIMAL,
95         TOMOYO_VALUE_TYPE_OCTAL,
96         TOMOYO_VALUE_TYPE_HEXADECIMAL,
97 };
98
99 /* Index numbers for domain transition control keywords. */
100 enum tomoyo_transition_type {
101         /* Do not change this order, */
102         TOMOYO_TRANSITION_CONTROL_NO_RESET,
103         TOMOYO_TRANSITION_CONTROL_RESET,
104         TOMOYO_TRANSITION_CONTROL_NO_INITIALIZE,
105         TOMOYO_TRANSITION_CONTROL_INITIALIZE,
106         TOMOYO_TRANSITION_CONTROL_NO_KEEP,
107         TOMOYO_TRANSITION_CONTROL_KEEP,
108         TOMOYO_MAX_TRANSITION_TYPE
109 };
110
111 /* Index numbers for Access Controls. */
112 enum tomoyo_acl_entry_type_index {
113         TOMOYO_TYPE_PATH_ACL,
114         TOMOYO_TYPE_PATH2_ACL,
115         TOMOYO_TYPE_PATH_NUMBER_ACL,
116         TOMOYO_TYPE_MKDEV_ACL,
117         TOMOYO_TYPE_MOUNT_ACL,
118 };
119
120 /* Index numbers for access controls with one pathname. */
121 enum tomoyo_path_acl_index {
122         TOMOYO_TYPE_EXECUTE,
123         TOMOYO_TYPE_READ,
124         TOMOYO_TYPE_WRITE,
125         TOMOYO_TYPE_APPEND,
126         TOMOYO_TYPE_UNLINK,
127         TOMOYO_TYPE_GETATTR,
128         TOMOYO_TYPE_RMDIR,
129         TOMOYO_TYPE_TRUNCATE,
130         TOMOYO_TYPE_SYMLINK,
131         TOMOYO_TYPE_CHROOT,
132         TOMOYO_TYPE_UMOUNT,
133         TOMOYO_MAX_PATH_OPERATION
134 };
135
136 /* Index numbers for /sys/kernel/security/tomoyo/stat interface. */
137 enum tomoyo_memory_stat_type {
138         TOMOYO_MEMORY_POLICY,
139         TOMOYO_MEMORY_AUDIT,
140         TOMOYO_MEMORY_QUERY,
141         TOMOYO_MAX_MEMORY_STAT
142 };
143
144 enum tomoyo_mkdev_acl_index {
145         TOMOYO_TYPE_MKBLOCK,
146         TOMOYO_TYPE_MKCHAR,
147         TOMOYO_MAX_MKDEV_OPERATION
148 };
149
150 /* Index numbers for access controls with two pathnames. */
151 enum tomoyo_path2_acl_index {
152         TOMOYO_TYPE_LINK,
153         TOMOYO_TYPE_RENAME,
154         TOMOYO_TYPE_PIVOT_ROOT,
155         TOMOYO_MAX_PATH2_OPERATION
156 };
157
158 /* Index numbers for access controls with one pathname and one number. */
159 enum tomoyo_path_number_acl_index {
160         TOMOYO_TYPE_CREATE,
161         TOMOYO_TYPE_MKDIR,
162         TOMOYO_TYPE_MKFIFO,
163         TOMOYO_TYPE_MKSOCK,
164         TOMOYO_TYPE_IOCTL,
165         TOMOYO_TYPE_CHMOD,
166         TOMOYO_TYPE_CHOWN,
167         TOMOYO_TYPE_CHGRP,
168         TOMOYO_MAX_PATH_NUMBER_OPERATION
169 };
170
171 /* Index numbers for /sys/kernel/security/tomoyo/ interfaces. */
172 enum tomoyo_securityfs_interface_index {
173         TOMOYO_DOMAINPOLICY,
174         TOMOYO_EXCEPTIONPOLICY,
175         TOMOYO_DOMAIN_STATUS,
176         TOMOYO_PROCESS_STATUS,
177         TOMOYO_STAT,
178         TOMOYO_SELFDOMAIN,
179         TOMOYO_AUDIT,
180         TOMOYO_VERSION,
181         TOMOYO_PROFILE,
182         TOMOYO_QUERY,
183         TOMOYO_MANAGER
184 };
185
186 /* Index numbers for special mount operations. */
187 enum tomoyo_special_mount {
188         TOMOYO_MOUNT_BIND,            /* mount --bind /source /dest   */
189         TOMOYO_MOUNT_MOVE,            /* mount --move /old /new       */
190         TOMOYO_MOUNT_REMOUNT,         /* mount -o remount /dir        */
191         TOMOYO_MOUNT_MAKE_UNBINDABLE, /* mount --make-unbindable /dir */
192         TOMOYO_MOUNT_MAKE_PRIVATE,    /* mount --make-private /dir    */
193         TOMOYO_MOUNT_MAKE_SLAVE,      /* mount --make-slave /dir      */
194         TOMOYO_MOUNT_MAKE_SHARED,     /* mount --make-shared /dir     */
195         TOMOYO_MAX_SPECIAL_MOUNT
196 };
197
198 /* Index numbers for functionality. */
199 enum tomoyo_mac_index {
200         TOMOYO_MAC_FILE_EXECUTE,
201         TOMOYO_MAC_FILE_OPEN,
202         TOMOYO_MAC_FILE_CREATE,
203         TOMOYO_MAC_FILE_UNLINK,
204         TOMOYO_MAC_FILE_GETATTR,
205         TOMOYO_MAC_FILE_MKDIR,
206         TOMOYO_MAC_FILE_RMDIR,
207         TOMOYO_MAC_FILE_MKFIFO,
208         TOMOYO_MAC_FILE_MKSOCK,
209         TOMOYO_MAC_FILE_TRUNCATE,
210         TOMOYO_MAC_FILE_SYMLINK,
211         TOMOYO_MAC_FILE_MKBLOCK,
212         TOMOYO_MAC_FILE_MKCHAR,
213         TOMOYO_MAC_FILE_LINK,
214         TOMOYO_MAC_FILE_RENAME,
215         TOMOYO_MAC_FILE_CHMOD,
216         TOMOYO_MAC_FILE_CHOWN,
217         TOMOYO_MAC_FILE_CHGRP,
218         TOMOYO_MAC_FILE_IOCTL,
219         TOMOYO_MAC_FILE_CHROOT,
220         TOMOYO_MAC_FILE_MOUNT,
221         TOMOYO_MAC_FILE_UMOUNT,
222         TOMOYO_MAC_FILE_PIVOT_ROOT,
223         TOMOYO_MAX_MAC_INDEX
224 };
225
226 /* Index numbers for category of functionality. */
227 enum tomoyo_mac_category_index {
228         TOMOYO_MAC_CATEGORY_FILE,
229         TOMOYO_MAX_MAC_CATEGORY_INDEX
230 };
231
232 /*
233  * Retry this request. Returned by tomoyo_supervisor() if policy violation has
234  * occurred in enforcing mode and the userspace daemon decided to retry.
235  *
236  * We must choose a positive value in order to distinguish "granted" (which is
237  * 0) and "rejected" (which is a negative value) and "retry".
238  */
239 #define TOMOYO_RETRY_REQUEST 1
240
241 /* Index numbers for /sys/kernel/security/tomoyo/stat interface. */
242 enum tomoyo_policy_stat_type {
243         /* Do not change this order. */
244         TOMOYO_STAT_POLICY_UPDATES,
245         TOMOYO_STAT_POLICY_LEARNING,   /* == TOMOYO_CONFIG_LEARNING */
246         TOMOYO_STAT_POLICY_PERMISSIVE, /* == TOMOYO_CONFIG_PERMISSIVE */
247         TOMOYO_STAT_POLICY_ENFORCING,  /* == TOMOYO_CONFIG_ENFORCING */
248         TOMOYO_MAX_POLICY_STAT
249 };
250
251 /* Index numbers for profile's PREFERENCE values. */
252 enum tomoyo_pref_index {
253         TOMOYO_PREF_MAX_AUDIT_LOG,
254         TOMOYO_PREF_MAX_LEARNING_ENTRY,
255         TOMOYO_MAX_PREF
256 };
257
258 /********** Structure definitions. **********/
259
260 /* Common header for holding ACL entries. */
261 struct tomoyo_acl_head {
262         struct list_head list;
263         bool is_deleted;
264 } __packed;
265
266 /* Common header for shared entries. */
267 struct tomoyo_shared_acl_head {
268         struct list_head list;
269         atomic_t users;
270 } __packed;
271
272 struct tomoyo_policy_namespace;
273
274 /* Structure for request info. */
275 struct tomoyo_request_info {
276         struct tomoyo_domain_info *domain;
277         /* For holding parameters. */
278         union {
279                 struct {
280                         const struct tomoyo_path_info *filename;
281                         /* For using wildcards at tomoyo_find_next_domain(). */
282                         const struct tomoyo_path_info *matched_path;
283                         /* One of values in "enum tomoyo_path_acl_index". */
284                         u8 operation;
285                 } path;
286                 struct {
287                         const struct tomoyo_path_info *filename1;
288                         const struct tomoyo_path_info *filename2;
289                         /* One of values in "enum tomoyo_path2_acl_index". */
290                         u8 operation;
291                 } path2;
292                 struct {
293                         const struct tomoyo_path_info *filename;
294                         unsigned int mode;
295                         unsigned int major;
296                         unsigned int minor;
297                         /* One of values in "enum tomoyo_mkdev_acl_index". */
298                         u8 operation;
299                 } mkdev;
300                 struct {
301                         const struct tomoyo_path_info *filename;
302                         unsigned long number;
303                         /*
304                          * One of values in
305                          * "enum tomoyo_path_number_acl_index".
306                          */
307                         u8 operation;
308                 } path_number;
309                 struct {
310                         const struct tomoyo_path_info *type;
311                         const struct tomoyo_path_info *dir;
312                         const struct tomoyo_path_info *dev;
313                         unsigned long flags;
314                         int need_dev;
315                 } mount;
316         } param;
317         u8 param_type;
318         bool granted;
319         u8 retry;
320         u8 profile;
321         u8 mode; /* One of tomoyo_mode_index . */
322         u8 type;
323 };
324
325 /* Structure for holding a token. */
326 struct tomoyo_path_info {
327         const char *name;
328         u32 hash;          /* = full_name_hash(name, strlen(name)) */
329         u16 const_len;     /* = tomoyo_const_part_length(name)     */
330         bool is_dir;       /* = tomoyo_strendswith(name, "/")      */
331         bool is_patterned; /* = tomoyo_path_contains_pattern(name) */
332 };
333
334 /* Structure for holding string data. */
335 struct tomoyo_name {
336         struct tomoyo_shared_acl_head head;
337         struct tomoyo_path_info entry;
338 };
339
340 /* Structure for holding a word. */
341 struct tomoyo_name_union {
342         /* Either @filename or @group is NULL. */
343         const struct tomoyo_path_info *filename;
344         struct tomoyo_group *group;
345 };
346
347 /* Structure for holding a number. */
348 struct tomoyo_number_union {
349         unsigned long values[2];
350         struct tomoyo_group *group; /* Maybe NULL. */
351         /* One of values in "enum tomoyo_value_type". */
352         u8 value_type[2];
353 };
354
355 /* Structure for "path_group"/"number_group" directive. */
356 struct tomoyo_group {
357         struct tomoyo_shared_acl_head head;
358         const struct tomoyo_path_info *group_name;
359         struct list_head member_list;
360 };
361
362 /* Structure for "path_group" directive. */
363 struct tomoyo_path_group {
364         struct tomoyo_acl_head head;
365         const struct tomoyo_path_info *member_name;
366 };
367
368 /* Structure for "number_group" directive. */
369 struct tomoyo_number_group {
370         struct tomoyo_acl_head head;
371         struct tomoyo_number_union number;
372 };
373
374 /* Common header for individual entries. */
375 struct tomoyo_acl_info {
376         struct list_head list;
377         bool is_deleted;
378         u8 type; /* One of values in "enum tomoyo_acl_entry_type_index". */
379 } __packed;
380
381 /* Structure for domain information. */
382 struct tomoyo_domain_info {
383         struct list_head list;
384         struct list_head acl_info_list;
385         /* Name of this domain. Never NULL.          */
386         const struct tomoyo_path_info *domainname;
387         /* Namespace for this domain. Never NULL. */
388         struct tomoyo_policy_namespace *ns;
389         u8 profile;        /* Profile number to use. */
390         u8 group;          /* Group number to use.   */
391         bool is_deleted;   /* Delete flag.           */
392         bool flags[TOMOYO_MAX_DOMAIN_INFO_FLAGS];
393         atomic_t users; /* Number of referring credentials. */
394 };
395
396 /*
397  * Structure for "file execute", "file read", "file write", "file append",
398  * "file unlink", "file getattr", "file rmdir", "file truncate",
399  * "file symlink", "file chroot" and "file unmount" directive.
400  */
401 struct tomoyo_path_acl {
402         struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH_ACL */
403         u16 perm; /* Bitmask of values in "enum tomoyo_path_acl_index". */
404         struct tomoyo_name_union name;
405 };
406
407 /*
408  * Structure for "file create", "file mkdir", "file mkfifo", "file mksock",
409  * "file ioctl", "file chmod", "file chown" and "file chgrp" directive.
410  */
411 struct tomoyo_path_number_acl {
412         struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH_NUMBER_ACL */
413         /* Bitmask of values in "enum tomoyo_path_number_acl_index". */
414         u8 perm;
415         struct tomoyo_name_union name;
416         struct tomoyo_number_union number;
417 };
418
419 /* Structure for "file mkblock" and "file mkchar" directive. */
420 struct tomoyo_mkdev_acl {
421         struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_MKDEV_ACL */
422         u8 perm; /* Bitmask of values in "enum tomoyo_mkdev_acl_index". */
423         struct tomoyo_name_union name;
424         struct tomoyo_number_union mode;
425         struct tomoyo_number_union major;
426         struct tomoyo_number_union minor;
427 };
428
429 /*
430  * Structure for "file rename", "file link" and "file pivot_root" directive.
431  */
432 struct tomoyo_path2_acl {
433         struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH2_ACL */
434         u8 perm; /* Bitmask of values in "enum tomoyo_path2_acl_index". */
435         struct tomoyo_name_union name1;
436         struct tomoyo_name_union name2;
437 };
438
439 /* Structure for "file mount" directive. */
440 struct tomoyo_mount_acl {
441         struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_MOUNT_ACL */
442         struct tomoyo_name_union dev_name;
443         struct tomoyo_name_union dir_name;
444         struct tomoyo_name_union fs_type;
445         struct tomoyo_number_union flags;
446 };
447
448 /* Structure for holding a line from /sys/kernel/security/tomoyo/ interface. */
449 struct tomoyo_acl_param {
450         char *data;
451         struct list_head *list;
452         struct tomoyo_policy_namespace *ns;
453         bool is_delete;
454 };
455
456 #define TOMOYO_MAX_IO_READ_QUEUE 64
457
458 /*
459  * Structure for reading/writing policy via /sys/kernel/security/tomoyo
460  * interfaces.
461  */
462 struct tomoyo_io_buffer {
463         void (*read) (struct tomoyo_io_buffer *);
464         int (*write) (struct tomoyo_io_buffer *);
465         int (*poll) (struct file *file, poll_table *wait);
466         /* Exclusive lock for this structure.   */
467         struct mutex io_sem;
468         char __user *read_user_buf;
469         size_t read_user_buf_avail;
470         struct {
471                 struct list_head *ns;
472                 struct list_head *domain;
473                 struct list_head *group;
474                 struct list_head *acl;
475                 size_t avail;
476                 unsigned int step;
477                 unsigned int query_index;
478                 u16 index;
479                 u8 acl_group_index;
480                 u8 bit;
481                 u8 w_pos;
482                 bool eof;
483                 bool print_this_domain_only;
484                 bool print_transition_related_only;
485                 const char *w[TOMOYO_MAX_IO_READ_QUEUE];
486         } r;
487         struct {
488                 struct tomoyo_policy_namespace *ns;
489                 /* The position currently writing to.   */
490                 struct tomoyo_domain_info *domain;
491                 /* Bytes available for writing.         */
492                 size_t avail;
493                 bool is_delete;
494         } w;
495         /* Buffer for reading.                  */
496         char *read_buf;
497         /* Size of read buffer.                 */
498         size_t readbuf_size;
499         /* Buffer for writing.                  */
500         char *write_buf;
501         /* Size of write buffer.                */
502         size_t writebuf_size;
503         /* Type of this interface.              */
504         enum tomoyo_securityfs_interface_index type;
505         /* Users counter protected by tomoyo_io_buffer_list_lock. */
506         u8 users;
507         /* List for telling GC not to kfree() elements. */
508         struct list_head list;
509 };
510
511 /*
512  * Structure for "initialize_domain"/"no_initialize_domain"/"keep_domain"/
513  * "no_keep_domain" keyword.
514  */
515 struct tomoyo_transition_control {
516         struct tomoyo_acl_head head;
517         u8 type; /* One of values in "enum tomoyo_transition_type".  */
518         /* True if the domainname is tomoyo_get_last_name(). */
519         bool is_last_name;
520         const struct tomoyo_path_info *domainname; /* Maybe NULL */
521         const struct tomoyo_path_info *program;    /* Maybe NULL */
522 };
523
524 /* Structure for "aggregator" keyword. */
525 struct tomoyo_aggregator {
526         struct tomoyo_acl_head head;
527         const struct tomoyo_path_info *original_name;
528         const struct tomoyo_path_info *aggregated_name;
529 };
530
531 /* Structure for policy manager. */
532 struct tomoyo_manager {
533         struct tomoyo_acl_head head;
534         bool is_domain;  /* True if manager is a domainname. */
535         /* A path to program or a domainname. */
536         const struct tomoyo_path_info *manager;
537 };
538
539 struct tomoyo_preference {
540         unsigned int learning_max_entry;
541         bool enforcing_verbose;
542         bool learning_verbose;
543         bool permissive_verbose;
544 };
545
546 /* Structure for /sys/kernel/security/tomnoyo/profile interface. */
547 struct tomoyo_profile {
548         const struct tomoyo_path_info *comment;
549         struct tomoyo_preference *learning;
550         struct tomoyo_preference *permissive;
551         struct tomoyo_preference *enforcing;
552         struct tomoyo_preference preference;
553         u8 default_config;
554         u8 config[TOMOYO_MAX_MAC_INDEX + TOMOYO_MAX_MAC_CATEGORY_INDEX];
555         unsigned int pref[TOMOYO_MAX_PREF];
556 };
557
558 /* Structure for representing YYYY/MM/DD hh/mm/ss. */
559 struct tomoyo_time {
560         u16 year;
561         u8 month;
562         u8 day;
563         u8 hour;
564         u8 min;
565         u8 sec;
566 };
567
568 /* Structure for policy namespace. */
569 struct tomoyo_policy_namespace {
570         /* Profile table. Memory is allocated as needed. */
571         struct tomoyo_profile *profile_ptr[TOMOYO_MAX_PROFILES];
572         /* List of "struct tomoyo_group". */
573         struct list_head group_list[TOMOYO_MAX_GROUP];
574         /* List of policy. */
575         struct list_head policy_list[TOMOYO_MAX_POLICY];
576         /* The global ACL referred by "use_group" keyword. */
577         struct list_head acl_group[TOMOYO_MAX_ACL_GROUPS];
578         /* List for connecting to tomoyo_namespace_list list. */
579         struct list_head namespace_list;
580         /* Profile version. Currently only 20100903 is defined. */
581         unsigned int profile_version;
582         /* Name of this namespace (e.g. "<kernel>", "</usr/sbin/httpd>" ). */
583         const char *name;
584 };
585
586 /********** Function prototypes. **********/
587
588 bool tomoyo_compare_number_union(const unsigned long value,
589                                  const struct tomoyo_number_union *ptr);
590 bool tomoyo_correct_domain(const unsigned char *domainname);
591 bool tomoyo_correct_path(const char *filename);
592 bool tomoyo_correct_word(const char *string);
593 bool tomoyo_domain_def(const unsigned char *buffer);
594 bool tomoyo_domain_quota_is_ok(struct tomoyo_request_info *r);
595 bool tomoyo_memory_ok(void *ptr);
596 bool tomoyo_number_matches_group(const unsigned long min,
597                                  const unsigned long max,
598                                  const struct tomoyo_group *group);
599 bool tomoyo_parse_name_union(struct tomoyo_acl_param *param,
600                              struct tomoyo_name_union *ptr);
601 bool tomoyo_parse_number_union(struct tomoyo_acl_param *param,
602                                struct tomoyo_number_union *ptr);
603 bool tomoyo_path_matches_pattern(const struct tomoyo_path_info *filename,
604                                  const struct tomoyo_path_info *pattern);
605 bool tomoyo_permstr(const char *string, const char *keyword);
606 bool tomoyo_str_starts(char **src, const char *find);
607 char *tomoyo_encode(const char *str);
608 char *tomoyo_init_log(struct tomoyo_request_info *r, int len, const char *fmt,
609                       va_list args);
610 char *tomoyo_read_token(struct tomoyo_acl_param *param);
611 char *tomoyo_realpath_from_path(struct path *path);
612 char *tomoyo_realpath_nofollow(const char *pathname);
613 const char *tomoyo_get_exe(void);
614 const char *tomoyo_yesno(const unsigned int value);
615 const struct tomoyo_path_info *tomoyo_compare_name_union
616 (const struct tomoyo_path_info *name, const struct tomoyo_name_union *ptr);
617 const struct tomoyo_path_info *tomoyo_get_name(const char *name);
618 const struct tomoyo_path_info *tomoyo_path_matches_group
619 (const struct tomoyo_path_info *pathname, const struct tomoyo_group *group);
620 int tomoyo_check_open_permission(struct tomoyo_domain_info *domain,
621                                  struct path *path, const int flag);
622 int tomoyo_close_control(struct tomoyo_io_buffer *head);
623 int tomoyo_find_next_domain(struct linux_binprm *bprm);
624 int tomoyo_get_mode(const struct tomoyo_policy_namespace *ns, const u8 profile,
625                     const u8 index);
626 int tomoyo_init_request_info(struct tomoyo_request_info *r,
627                              struct tomoyo_domain_info *domain,
628                              const u8 index);
629 int tomoyo_mkdev_perm(const u8 operation, struct path *path,
630                       const unsigned int mode, unsigned int dev);
631 int tomoyo_mount_permission(char *dev_name, struct path *path,
632                             const char *type, unsigned long flags,
633                             void *data_page);
634 int tomoyo_open_control(const u8 type, struct file *file);
635 int tomoyo_path2_perm(const u8 operation, struct path *path1,
636                       struct path *path2);
637 int tomoyo_path_number_perm(const u8 operation, struct path *path,
638                             unsigned long number);
639 int tomoyo_path_perm(const u8 operation, struct path *path);
640 int tomoyo_path_permission(struct tomoyo_request_info *r, u8 operation,
641                            const struct tomoyo_path_info *filename);
642 int tomoyo_poll_control(struct file *file, poll_table *wait);
643 int tomoyo_poll_log(struct file *file, poll_table *wait);
644 int tomoyo_supervisor(struct tomoyo_request_info *r, const char *fmt, ...)
645         __printf(2, 3);
646 int tomoyo_update_domain(struct tomoyo_acl_info *new_entry, const int size,
647                          struct tomoyo_acl_param *param,
648                          bool (*check_duplicate)
649                          (const struct tomoyo_acl_info *,
650                           const struct tomoyo_acl_info *),
651                          bool (*merge_duplicate)
652                          (struct tomoyo_acl_info *, struct tomoyo_acl_info *,
653                           const bool));
654 int tomoyo_update_policy(struct tomoyo_acl_head *new_entry, const int size,
655                          struct tomoyo_acl_param *param,
656                          bool (*check_duplicate)
657                          (const struct tomoyo_acl_head *,
658                           const struct tomoyo_acl_head *));
659 int tomoyo_write_aggregator(struct tomoyo_acl_param *param);
660 int tomoyo_write_file(struct tomoyo_acl_param *param);
661 int tomoyo_write_group(struct tomoyo_acl_param *param, const u8 type);
662 int tomoyo_write_transition_control(struct tomoyo_acl_param *param,
663                                     const u8 type);
664 ssize_t tomoyo_read_control(struct tomoyo_io_buffer *head, char __user *buffer,
665                             const int buffer_len);
666 ssize_t tomoyo_write_control(struct tomoyo_io_buffer *head,
667                              const char __user *buffer, const int buffer_len);
668 struct tomoyo_domain_info *tomoyo_assign_domain(const char *domainname,
669                                                 const bool transit);
670 struct tomoyo_domain_info *tomoyo_find_domain(const char *domainname);
671 struct tomoyo_group *tomoyo_get_group(struct tomoyo_acl_param *param,
672                                       const u8 idx);
673 struct tomoyo_policy_namespace *tomoyo_assign_namespace
674 (const char *domainname);
675 struct tomoyo_profile *tomoyo_profile(const struct tomoyo_policy_namespace *ns,
676                                       const u8 profile);
677 unsigned int tomoyo_check_flags(const struct tomoyo_domain_info *domain,
678                                 const u8 index);
679 void *tomoyo_commit_ok(void *data, const unsigned int size);
680 void __init tomoyo_load_builtin_policy(void);
681 void __init tomoyo_mm_init(void);
682 void tomoyo_check_acl(struct tomoyo_request_info *r,
683                       bool (*check_entry) (struct tomoyo_request_info *,
684                                            const struct tomoyo_acl_info *));
685 void tomoyo_check_profile(void);
686 void tomoyo_convert_time(time_t time, struct tomoyo_time *stamp);
687 void tomoyo_fill_path_info(struct tomoyo_path_info *ptr);
688 void tomoyo_init_policy_namespace(struct tomoyo_policy_namespace *ns);
689 void tomoyo_io_printf(struct tomoyo_io_buffer *head, const char *fmt, ...)
690          __printf(2, 3);
691 void tomoyo_load_policy(const char *filename);
692 void tomoyo_memory_free(void *ptr);
693 void tomoyo_normalize_line(unsigned char *buffer);
694 void tomoyo_notify_gc(struct tomoyo_io_buffer *head, const bool is_register);
695 void tomoyo_print_ulong(char *buffer, const int buffer_len,
696                         const unsigned long value, const u8 type);
697 void tomoyo_put_name_union(struct tomoyo_name_union *ptr);
698 void tomoyo_put_number_union(struct tomoyo_number_union *ptr);
699 void tomoyo_read_log(struct tomoyo_io_buffer *head);
700 void tomoyo_update_stat(const u8 index);
701 void tomoyo_warn_oom(const char *function);
702 void tomoyo_write_log(struct tomoyo_request_info *r, const char *fmt, ...)
703         __printf(2, 3);
704 void tomoyo_write_log2(struct tomoyo_request_info *r, int len, const char *fmt,
705                        va_list args);
706
707 /********** External variable definitions. **********/
708
709 extern bool tomoyo_policy_loaded;
710 extern const char * const tomoyo_dif[TOMOYO_MAX_DOMAIN_INFO_FLAGS];
711 extern const char * const tomoyo_mac_keywords[TOMOYO_MAX_MAC_INDEX
712                                               + TOMOYO_MAX_MAC_CATEGORY_INDEX];
713 extern const char * const tomoyo_mode[TOMOYO_CONFIG_MAX_MODE];
714 extern const char * const tomoyo_path_keyword[TOMOYO_MAX_PATH_OPERATION];
715 extern const u8 tomoyo_index2category[TOMOYO_MAX_MAC_INDEX];
716 extern const u8 tomoyo_pn2mac[TOMOYO_MAX_PATH_NUMBER_OPERATION];
717 extern const u8 tomoyo_pnnn2mac[TOMOYO_MAX_MKDEV_OPERATION];
718 extern const u8 tomoyo_pp2mac[TOMOYO_MAX_PATH2_OPERATION];
719 extern struct list_head tomoyo_domain_list;
720 extern struct list_head tomoyo_name_list[TOMOYO_MAX_HASH];
721 extern struct list_head tomoyo_namespace_list;
722 extern struct mutex tomoyo_policy_lock;
723 extern struct srcu_struct tomoyo_ss;
724 extern struct tomoyo_domain_info tomoyo_kernel_domain;
725 extern struct tomoyo_policy_namespace tomoyo_kernel_namespace;
726 extern unsigned int tomoyo_memory_quota[TOMOYO_MAX_MEMORY_STAT];
727 extern unsigned int tomoyo_memory_used[TOMOYO_MAX_MEMORY_STAT];
728
729 /********** Inlined functions. **********/
730
731 /**
732  * tomoyo_read_lock - Take lock for protecting policy.
733  *
734  * Returns index number for tomoyo_read_unlock().
735  */
736 static inline int tomoyo_read_lock(void)
737 {
738         return srcu_read_lock(&tomoyo_ss);
739 }
740
741 /**
742  * tomoyo_read_unlock - Release lock for protecting policy.
743  *
744  * @idx: Index number returned by tomoyo_read_lock().
745  *
746  * Returns nothing.
747  */
748 static inline void tomoyo_read_unlock(int idx)
749 {
750         srcu_read_unlock(&tomoyo_ss, idx);
751 }
752
753 /**
754  * tomoyo_pathcmp - strcmp() for "struct tomoyo_path_info" structure.
755  *
756  * @a: Pointer to "struct tomoyo_path_info".
757  * @b: Pointer to "struct tomoyo_path_info".
758  *
759  * Returns true if @a == @b, false otherwise.
760  */
761 static inline bool tomoyo_pathcmp(const struct tomoyo_path_info *a,
762                                   const struct tomoyo_path_info *b)
763 {
764         return a->hash != b->hash || strcmp(a->name, b->name);
765 }
766
767 /**
768  * tomoyo_put_name - Drop reference on "struct tomoyo_name".
769  *
770  * @name: Pointer to "struct tomoyo_path_info". Maybe NULL.
771  *
772  * Returns nothing.
773  */
774 static inline void tomoyo_put_name(const struct tomoyo_path_info *name)
775 {
776         if (name) {
777                 struct tomoyo_name *ptr =
778                         container_of(name, typeof(*ptr), entry);
779                 atomic_dec(&ptr->head.users);
780         }
781 }
782
783 /**
784  * tomoyo_put_group - Drop reference on "struct tomoyo_group".
785  *
786  * @group: Pointer to "struct tomoyo_group". Maybe NULL.
787  *
788  * Returns nothing.
789  */
790 static inline void tomoyo_put_group(struct tomoyo_group *group)
791 {
792         if (group)
793                 atomic_dec(&group->head.users);
794 }
795
796 /**
797  * tomoyo_domain - Get "struct tomoyo_domain_info" for current thread.
798  *
799  * Returns pointer to "struct tomoyo_domain_info" for current thread.
800  */
801 static inline struct tomoyo_domain_info *tomoyo_domain(void)
802 {
803         return current_cred()->security;
804 }
805
806 /**
807  * tomoyo_real_domain - Get "struct tomoyo_domain_info" for specified thread.
808  *
809  * @task: Pointer to "struct task_struct".
810  *
811  * Returns pointer to "struct tomoyo_security" for specified thread.
812  */
813 static inline struct tomoyo_domain_info *tomoyo_real_domain(struct task_struct
814                                                             *task)
815 {
816         return task_cred_xxx(task, security);
817 }
818
819 /**
820  * tomoyo_same_name_union - Check for duplicated "struct tomoyo_name_union" entry.
821  *
822  * @a: Pointer to "struct tomoyo_name_union".
823  * @b: Pointer to "struct tomoyo_name_union".
824  *
825  * Returns true if @a == @b, false otherwise.
826  */
827 static inline bool tomoyo_same_name_union
828 (const struct tomoyo_name_union *a, const struct tomoyo_name_union *b)
829 {
830         return a->filename == b->filename && a->group == b->group;
831 }
832
833 /**
834  * tomoyo_same_number_union - Check for duplicated "struct tomoyo_number_union" entry.
835  *
836  * @a: Pointer to "struct tomoyo_number_union".
837  * @b: Pointer to "struct tomoyo_number_union".
838  *
839  * Returns true if @a == @b, false otherwise.
840  */
841 static inline bool tomoyo_same_number_union
842 (const struct tomoyo_number_union *a, const struct tomoyo_number_union *b)
843 {
844         return a->values[0] == b->values[0] && a->values[1] == b->values[1] &&
845                 a->group == b->group && a->value_type[0] == b->value_type[0] &&
846                 a->value_type[1] == b->value_type[1];
847 }
848
849 /**
850  * tomoyo_current_namespace - Get "struct tomoyo_policy_namespace" for current thread.
851  *
852  * Returns pointer to "struct tomoyo_policy_namespace" for current thread.
853  */
854 static inline struct tomoyo_policy_namespace *tomoyo_current_namespace(void)
855 {
856         return tomoyo_domain()->ns;
857 }
858
859 #if defined(CONFIG_SLOB)
860
861 /**
862  * tomoyo_round2 - Round up to power of 2 for calculating memory usage.
863  *
864  * @size: Size to be rounded up.
865  *
866  * Returns @size.
867  *
868  * Since SLOB does not round up, this function simply returns @size.
869  */
870 static inline int tomoyo_round2(size_t size)
871 {
872         return size;
873 }
874
875 #else
876
877 /**
878  * tomoyo_round2 - Round up to power of 2 for calculating memory usage.
879  *
880  * @size: Size to be rounded up.
881  *
882  * Returns rounded size.
883  *
884  * Strictly speaking, SLAB may be able to allocate (e.g.) 96 bytes instead of
885  * (e.g.) 128 bytes.
886  */
887 static inline int tomoyo_round2(size_t size)
888 {
889 #if PAGE_SIZE == 4096
890         size_t bsize = 32;
891 #else
892         size_t bsize = 64;
893 #endif
894         if (!size)
895                 return 0;
896         while (size > bsize)
897                 bsize <<= 1;
898         return bsize;
899 }
900
901 #endif
902
903 /**
904  * list_for_each_cookie - iterate over a list with cookie.
905  * @pos:        the &struct list_head to use as a loop cursor.
906  * @head:       the head for your list.
907  */
908 #define list_for_each_cookie(pos, head)                                 \
909         if (!pos)                                                       \
910                 pos =  srcu_dereference((head)->next, &tomoyo_ss);      \
911         for ( ; pos != (head); pos = srcu_dereference(pos->next, &tomoyo_ss))
912
913 #endif /* !defined(_SECURITY_TOMOYO_COMMON_H) */