オープンソース・ソフトウェアの開発とダウンロード

TOMOYO

Subversion リポジトリの参照

/[tomoyo]/trunk/1.8.x/ccs-patch/security/ccsecurity/policy_io.c

Diff of /trunk/1.8.x/ccs-patch/security/ccsecurity/policy_io.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

branches/ccs-patch/security/ccsecurity/policy_io.c revision 3832 by kumaneko, Wed Jul 21 06:01:31 2010 UTC trunk/1.8.x/ccs-patch/security/ccsecurity/policy_io.c revision 4280 by kumaneko, Fri Dec 31 02:05:48 2010 UTC
# Line 3  Line 3 
3   *   *
4   * Copyright (C) 2005-2010  NTT DATA CORPORATION   * Copyright (C) 2005-2010  NTT DATA CORPORATION
5   *   *
6   * Version: 1.7.2+   2010/07/21   * Version: 1.8.0+   2010/12/31
  *  
  * This file is applicable to both 2.4.30 and 2.6.11 and later.  
  * See README.ccs for ChangeLog.  
  *  
7   */   */
8    
9  #include "internal.h"  #include "internal.h"
10    
11  static struct ccs_profile ccs_default_profile = {  #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)
12          .learning = &ccs_default_profile.preference,  
13          .permissive = &ccs_default_profile.preference,  /**
14          .enforcing = &ccs_default_profile.preference,   * __wait_event_interruptible_timeout - Sleep until a condition gets true or a timeout elapses.
15          .audit = &ccs_default_profile.preference,   *
16  #ifdef CONFIG_CCSECURITY_AUDIT   * @wq:        The waitqueue to wait on.
17          .preference.audit_max_grant_log = CONFIG_CCSECURITY_MAX_GRANT_LOG,   * @condition: A C expression for the event to wait for.
18          .preference.audit_max_reject_log = CONFIG_CCSECURITY_MAX_REJECT_LOG,   * @ret:       Timeout, in jiffies.
19     *
20     * Returns 0 if the @timeout elapsed, -ERESTARTSYS if it was interrupted by a
21     * signal, and the remaining jiffies otherwise if the condition evaluated to
22     * true before the timeout elapsed.
23     *
24     * This is for compatibility with older kernels.
25     */
26    #define __wait_event_interruptible_timeout(wq, condition, ret)          \
27    do {                                                                    \
28            wait_queue_t __wait;                                            \
29            init_waitqueue_entry(&__wait, current);                         \
30                                                                            \
31            add_wait_queue(&wq, &__wait);                                   \
32            for (;;) {                                                      \
33                    set_current_state(TASK_INTERRUPTIBLE);                  \
34                    if (condition)                                          \
35                            break;                                          \
36                    if (!signal_pending(current)) {                         \
37                            ret = schedule_timeout(ret);                    \
38                            if (!ret)                                       \
39                                    break;                                  \
40                            continue;                                       \
41                    }                                                       \
42                    ret = -ERESTARTSYS;                                     \
43                    break;                                                  \
44            }                                                               \
45            current->state = TASK_RUNNING;                                  \
46            remove_wait_queue(&wq, &__wait);                                \
47    } while (0)
48    
49    /**
50     * wait_event_interruptible_timeout - Sleep until a condition gets true or a timeout elapses.
51     *
52     * @wq:        The waitqueue to wait on.
53     * @condition: A C expression for the event to wait for.
54     * @timeout:   Timeout, in jiffies.
55     *
56     * Returns 0 if the @timeout elapsed, -ERESTARTSYS if it was interrupted by a
57     * signal, and the remaining jiffies otherwise if the condition evaluated to
58     * true before the timeout elapsed.
59     *
60     * This is for compatibility with older kernels.
61     */
62    #define wait_event_interruptible_timeout(wq, condition, timeout)        \
63    ({                                                                      \
64            long __ret = timeout;                                           \
65            if (!(condition))                                               \
66                    __wait_event_interruptible_timeout(wq, condition, __ret); \
67            __ret;                                                          \
68    })
69    
70  #endif  #endif
         .preference.audit_task_info = true,  
         .preference.audit_path_info = true,  
         .preference.enforcing_penalty = 0,  
         .preference.enforcing_verbose = true,  
         .preference.learning_max_entry = CONFIG_CCSECURITY_MAX_ACCEPT_ENTRY,  
         .preference.learning_verbose = false,  
         .preference.learning_exec_realpath = true,  
         .preference.learning_exec_argv0 = true,  
         .preference.learning_symlink_target = true,  
         .preference.permissive_verbose = true  
 };  
71    
72  /* Profile version. Currently only 20090903 is defined. */  /**
73     * list_for_each_cookie - iterate over a list with cookie.
74     *
75     * @pos:  Pointer to "struct list_head".
76     * @head: Pointer to "struct list_head".
77     */
78    #define list_for_each_cookie(pos, head)                                 \
79            for (pos = pos ? pos : srcu_dereference((head)->next, &ccs_ss); \
80                 pos != (head); pos = srcu_dereference(pos->next, &ccs_ss))
81    
82    
83    /* Profile version. Currently only 20100903 is defined. */
84  static unsigned int ccs_profile_version;  static unsigned int ccs_profile_version;
85    
86  /* Profile table. Memory is allocated as needed. */  /* Profile table. Memory is allocated as needed. */
87  static struct ccs_profile *ccs_profile_ptr[CCS_MAX_PROFILES];  static struct ccs_profile *ccs_profile_ptr[CCS_MAX_PROFILES];
88    
89  /* String table for functionality that takes 4 modes. */  /* String table for operation mode. */
90  const char *ccs_mode[CCS_CONFIG_MAX_MODE] = {  const char * const ccs_mode[CCS_CONFIG_MAX_MODE] = {
91          [CCS_CONFIG_DISABLED] = "disabled",          [CCS_CONFIG_DISABLED]   = "disabled",
92          [CCS_CONFIG_LEARNING] = "learning",          [CCS_CONFIG_LEARNING]   = "learning",
93          [CCS_CONFIG_PERMISSIVE] = "permissive",          [CCS_CONFIG_PERMISSIVE] = "permissive",
94          [CCS_CONFIG_ENFORCING] = "enforcing"          [CCS_CONFIG_ENFORCING]  = "enforcing"
95    };
96    
97    /* String table for /proc/ccs/profile interface. */
98    const char * const ccs_mac_keywords[CCS_MAX_MAC_INDEX
99                                        + CCS_MAX_MAC_CATEGORY_INDEX] = {
100            /* CONFIG::file group */
101            [CCS_MAC_FILE_EXECUTE]    = "execute",
102            [CCS_MAC_FILE_OPEN]       = "open",
103            [CCS_MAC_FILE_CREATE]     = "create",
104            [CCS_MAC_FILE_UNLINK]     = "unlink",
105            [CCS_MAC_FILE_GETATTR]    = "getattr",
106            [CCS_MAC_FILE_MKDIR]      = "mkdir",
107            [CCS_MAC_FILE_RMDIR]      = "rmdir",
108            [CCS_MAC_FILE_MKFIFO]     = "mkfifo",
109            [CCS_MAC_FILE_MKSOCK]     = "mksock",
110            [CCS_MAC_FILE_TRUNCATE]   = "truncate",
111            [CCS_MAC_FILE_SYMLINK]    = "symlink",
112            [CCS_MAC_FILE_MKBLOCK]    = "mkblock",
113            [CCS_MAC_FILE_MKCHAR]     = "mkchar",
114            [CCS_MAC_FILE_LINK]       = "link",
115            [CCS_MAC_FILE_RENAME]     = "rename",
116            [CCS_MAC_FILE_CHMOD]      = "chmod",
117            [CCS_MAC_FILE_CHOWN]      = "chown",
118            [CCS_MAC_FILE_CHGRP]      = "chgrp",
119            [CCS_MAC_FILE_IOCTL]      = "ioctl",
120            [CCS_MAC_FILE_CHROOT]     = "chroot",
121            [CCS_MAC_FILE_MOUNT]      = "mount",
122            [CCS_MAC_FILE_UMOUNT]     = "unmount",
123            [CCS_MAC_FILE_PIVOT_ROOT] = "pivot_root",
124            /* CONFIG::misc group */
125            [CCS_MAC_ENVIRON] = "env",
126            /* CONFIG::network group */
127            [CCS_MAC_NETWORK_INET_STREAM_BIND]       = "inet_stream_bind",
128            [CCS_MAC_NETWORK_INET_STREAM_LISTEN]     = "inet_stream_listen",
129            [CCS_MAC_NETWORK_INET_STREAM_CONNECT]    = "inet_stream_connect",
130            [CCS_MAC_NETWORK_INET_STREAM_ACCEPT]     = "inet_stream_accept",
131            [CCS_MAC_NETWORK_INET_DGRAM_BIND]        = "inet_dgram_bind",
132            [CCS_MAC_NETWORK_INET_DGRAM_SEND]        = "inet_dgram_send",
133            [CCS_MAC_NETWORK_INET_DGRAM_RECV]        = "inet_dgram_recv",
134            [CCS_MAC_NETWORK_INET_RAW_BIND]          = "inet_raw_bind",
135            [CCS_MAC_NETWORK_INET_RAW_SEND]          = "inet_raw_send",
136            [CCS_MAC_NETWORK_INET_RAW_RECV]          = "inet_raw_recv",
137            [CCS_MAC_NETWORK_UNIX_STREAM_BIND]       = "unix_stream_bind",
138            [CCS_MAC_NETWORK_UNIX_STREAM_LISTEN]     = "unix_stream_listen",
139            [CCS_MAC_NETWORK_UNIX_STREAM_CONNECT]    = "unix_stream_connect",
140            [CCS_MAC_NETWORK_UNIX_STREAM_ACCEPT]     = "unix_stream_accept",
141            [CCS_MAC_NETWORK_UNIX_DGRAM_BIND]        = "unix_dgram_bind",
142            [CCS_MAC_NETWORK_UNIX_DGRAM_SEND]        = "unix_dgram_send",
143            [CCS_MAC_NETWORK_UNIX_DGRAM_RECV]        = "unix_dgram_recv",
144            [CCS_MAC_NETWORK_UNIX_SEQPACKET_BIND]    = "unix_seqpacket_bind",
145            [CCS_MAC_NETWORK_UNIX_SEQPACKET_LISTEN]  = "unix_seqpacket_listen",
146            [CCS_MAC_NETWORK_UNIX_SEQPACKET_CONNECT] = "unix_seqpacket_connect",
147            [CCS_MAC_NETWORK_UNIX_SEQPACKET_ACCEPT]  = "unix_seqpacket_accept",
148            /* CONFIG::ipc group */
149            [CCS_MAC_SIGNAL] = "signal",
150            /* CONFIG::capability group */
151            [CCS_MAC_CAPABILITY_USE_ROUTE_SOCKET]  = "use_route",
152            [CCS_MAC_CAPABILITY_USE_PACKET_SOCKET] = "use_packet",
153            [CCS_MAC_CAPABILITY_SYS_REBOOT]        = "SYS_REBOOT",
154            [CCS_MAC_CAPABILITY_SYS_VHANGUP]       = "SYS_VHANGUP",
155            [CCS_MAC_CAPABILITY_SYS_SETTIME]       = "SYS_TIME",
156            [CCS_MAC_CAPABILITY_SYS_NICE]          = "SYS_NICE",
157            [CCS_MAC_CAPABILITY_SYS_SETHOSTNAME]   = "SYS_SETHOSTNAME",
158            [CCS_MAC_CAPABILITY_USE_KERNEL_MODULE] = "use_kernel_module",
159            [CCS_MAC_CAPABILITY_SYS_KEXEC_LOAD]    = "SYS_KEXEC_LOAD",
160            [CCS_MAC_CAPABILITY_SYS_PTRACE]        = "SYS_PTRACE",
161            /* CONFIG group */
162            [CCS_MAX_MAC_INDEX + CCS_MAC_CATEGORY_FILE]       = "file",
163            [CCS_MAX_MAC_INDEX + CCS_MAC_CATEGORY_NETWORK]    = "network",
164            [CCS_MAX_MAC_INDEX + CCS_MAC_CATEGORY_MISC]       = "misc",
165            [CCS_MAX_MAC_INDEX + CCS_MAC_CATEGORY_IPC]        = "ipc",
166            [CCS_MAX_MAC_INDEX + CCS_MAC_CATEGORY_CAPABILITY] = "capability",
167  };  };
168    
169  /* String table for /proc/ccs/profile */  /* String table for path operation. */
170  static const char *ccs_mac_keywords[CCS_MAX_MAC_INDEX +  const char * const ccs_path_keyword[CCS_MAX_PATH_OPERATION] = {
171                                      CCS_MAX_CAPABILITY_INDEX +          [CCS_TYPE_EXECUTE]    = "execute",
172                                      CCS_MAX_MAC_CATEGORY_INDEX] = {          [CCS_TYPE_READ]       = "read",
173          [CCS_MAC_FILE_EXECUTE]          [CCS_TYPE_WRITE]      = "write",
174          = "file::execute",          [CCS_TYPE_APPEND]     = "append",
175          [CCS_MAC_FILE_OPEN]          [CCS_TYPE_UNLINK]     = "unlink",
176          = "file::open",          [CCS_TYPE_GETATTR]    = "getattr",
177          [CCS_MAC_FILE_CREATE]          [CCS_TYPE_RMDIR]      = "rmdir",
178          = "file::create",          [CCS_TYPE_TRUNCATE]   = "truncate",
179          [CCS_MAC_FILE_UNLINK]          [CCS_TYPE_SYMLINK]    = "symlink",
180          = "file::unlink",          [CCS_TYPE_CHROOT]     = "chroot",
181          [CCS_MAC_FILE_MKDIR]          [CCS_TYPE_UMOUNT]     = "unmount",
182          = "file::mkdir",  };
183          [CCS_MAC_FILE_RMDIR]  
184          = "file::rmdir",  /* String table for categories. */
185          [CCS_MAC_FILE_MKFIFO]  static const char * const ccs_category_keywords[CCS_MAX_MAC_CATEGORY_INDEX] = {
186          = "file::mkfifo",          [CCS_MAC_CATEGORY_FILE]       = "file",
187          [CCS_MAC_FILE_MKSOCK]          [CCS_MAC_CATEGORY_NETWORK]    = "network",
188          = "file::mksock",          [CCS_MAC_CATEGORY_MISC]       = "misc",
189          [CCS_MAC_FILE_TRUNCATE]          [CCS_MAC_CATEGORY_IPC]        = "ipc",
190          = "file::truncate",          [CCS_MAC_CATEGORY_CAPABILITY] = "capability",
191          [CCS_MAC_FILE_SYMLINK]  };
192          = "file::symlink",  
193          [CCS_MAC_FILE_MKBLOCK]  /* String table for conditions. */
194          = "file::mkblock",  const char * const ccs_condition_keyword[CCS_MAX_CONDITION_KEYWORD] = {
195          [CCS_MAC_FILE_MKCHAR]          [CCS_TASK_UID]             = "task.uid",
196          = "file::mkchar",          [CCS_TASK_EUID]            = "task.euid",
197          [CCS_MAC_FILE_LINK]          [CCS_TASK_SUID]            = "task.suid",
198          = "file::link",          [CCS_TASK_FSUID]           = "task.fsuid",
199          [CCS_MAC_FILE_RENAME]          [CCS_TASK_GID]             = "task.gid",
200          = "file::rename",          [CCS_TASK_EGID]            = "task.egid",
201          [CCS_MAC_FILE_CHMOD]          [CCS_TASK_SGID]            = "task.sgid",
202          = "file::chmod",          [CCS_TASK_FSGID]           = "task.fsgid",
203          [CCS_MAC_FILE_CHOWN]          [CCS_TASK_PID]             = "task.pid",
204          = "file::chown",          [CCS_TASK_PPID]            = "task.ppid",
205          [CCS_MAC_FILE_CHGRP]          [CCS_EXEC_ARGC]            = "exec.argc",
206          = "file::chgrp",          [CCS_EXEC_ENVC]            = "exec.envc",
207          [CCS_MAC_FILE_IOCTL]          [CCS_TYPE_IS_SOCKET]       = "socket",
208          = "file::ioctl",          [CCS_TYPE_IS_SYMLINK]      = "symlink",
209          [CCS_MAC_FILE_CHROOT]          [CCS_TYPE_IS_FILE]         = "file",
210          = "file::chroot",          [CCS_TYPE_IS_BLOCK_DEV]    = "block",
211          [CCS_MAC_FILE_MOUNT]          [CCS_TYPE_IS_DIRECTORY]    = "directory",
212          = "file::mount",          [CCS_TYPE_IS_CHAR_DEV]     = "char",
213          [CCS_MAC_FILE_UMOUNT]          [CCS_TYPE_IS_FIFO]         = "fifo",
214          = "file::umount",          [CCS_MODE_SETUID]          = "setuid",
215          [CCS_MAC_FILE_PIVOT_ROOT]          [CCS_MODE_SETGID]          = "setgid",
216          = "file::pivot_root",          [CCS_MODE_STICKY]          = "sticky",
217          [CCS_MAC_FILE_TRANSIT]          [CCS_MODE_OWNER_READ]      = "owner_read",
218          = "file::transit",          [CCS_MODE_OWNER_WRITE]     = "owner_write",
219          [CCS_MAC_ENVIRON]          [CCS_MODE_OWNER_EXECUTE]   = "owner_execute",
220          = "misc::env",          [CCS_MODE_GROUP_READ]      = "group_read",
221          [CCS_MAC_NETWORK_UDP_BIND]          [CCS_MODE_GROUP_WRITE]     = "group_write",
222          = "network::inet_udp_bind",          [CCS_MODE_GROUP_EXECUTE]   = "group_execute",
223          [CCS_MAC_NETWORK_UDP_CONNECT]          [CCS_MODE_OTHERS_READ]     = "others_read",
224          = "network::inet_udp_connect",          [CCS_MODE_OTHERS_WRITE]    = "others_write",
225          [CCS_MAC_NETWORK_TCP_BIND]          [CCS_MODE_OTHERS_EXECUTE]  = "others_execute",
226          = "network::inet_tcp_bind",          [CCS_TASK_TYPE]            = "task.type",
227          [CCS_MAC_NETWORK_TCP_LISTEN]          [CCS_TASK_EXECUTE_HANDLER] = "execute_handler",
228          = "network::inet_tcp_listen",          [CCS_EXEC_REALPATH]        = "exec.realpath",
229          [CCS_MAC_NETWORK_TCP_CONNECT]          [CCS_SYMLINK_TARGET]       = "symlink.target",
230          = "network::inet_tcp_connect",          [CCS_PATH1_UID]            = "path1.uid",
231          [CCS_MAC_NETWORK_TCP_ACCEPT]          [CCS_PATH1_GID]            = "path1.gid",
232          = "network::inet_tcp_accept",          [CCS_PATH1_INO]            = "path1.ino",
233          [CCS_MAC_NETWORK_RAW_BIND]          [CCS_PATH1_MAJOR]          = "path1.major",
234          = "network::inet_raw_bind",          [CCS_PATH1_MINOR]          = "path1.minor",
235          [CCS_MAC_NETWORK_RAW_CONNECT]          [CCS_PATH1_PERM]           = "path1.perm",
236          = "network::inet_raw_connect",          [CCS_PATH1_TYPE]           = "path1.type",
237          [CCS_MAC_SIGNAL]          [CCS_PATH1_DEV_MAJOR]      = "path1.dev_major",
238          = "ipc::signal",          [CCS_PATH1_DEV_MINOR]      = "path1.dev_minor",
239          [CCS_MAX_MAC_INDEX + CCS_INET_STREAM_SOCKET_CREATE]          [CCS_PATH2_UID]            = "path2.uid",
240          = "capability::inet_tcp_create",          [CCS_PATH2_GID]            = "path2.gid",
241          [CCS_MAX_MAC_INDEX + CCS_INET_STREAM_SOCKET_LISTEN]          [CCS_PATH2_INO]            = "path2.ino",
242          = "capability::inet_tcp_listen",          [CCS_PATH2_MAJOR]          = "path2.major",
243          [CCS_MAX_MAC_INDEX + CCS_INET_STREAM_SOCKET_CONNECT]          [CCS_PATH2_MINOR]          = "path2.minor",
244          = "capability::inet_tcp_connect",          [CCS_PATH2_PERM]           = "path2.perm",
245          [CCS_MAX_MAC_INDEX + CCS_USE_INET_DGRAM_SOCKET]          [CCS_PATH2_TYPE]           = "path2.type",
246          = "capability::use_inet_udp",          [CCS_PATH2_DEV_MAJOR]      = "path2.dev_major",
247          [CCS_MAX_MAC_INDEX + CCS_USE_INET_RAW_SOCKET]          [CCS_PATH2_DEV_MINOR]      = "path2.dev_minor",
248          = "capability::use_inet_ip",          [CCS_PATH1_PARENT_UID]     = "path1.parent.uid",
249          [CCS_MAX_MAC_INDEX + CCS_USE_ROUTE_SOCKET]          [CCS_PATH1_PARENT_GID]     = "path1.parent.gid",
250          = "capability::use_route",          [CCS_PATH1_PARENT_INO]     = "path1.parent.ino",
251          [CCS_MAX_MAC_INDEX + CCS_USE_PACKET_SOCKET]          [CCS_PATH1_PARENT_PERM]    = "path1.parent.perm",
252          = "capability::use_packet",          [CCS_PATH2_PARENT_UID]     = "path2.parent.uid",
253          [CCS_MAX_MAC_INDEX + CCS_SYS_MOUNT]          [CCS_PATH2_PARENT_GID]     = "path2.parent.gid",
254          = "capability::SYS_MOUNT",          [CCS_PATH2_PARENT_INO]     = "path2.parent.ino",
255          [CCS_MAX_MAC_INDEX + CCS_SYS_UMOUNT]          [CCS_PATH2_PARENT_PERM]    = "path2.parent.perm",
256          = "capability::SYS_UMOUNT",  };
257          [CCS_MAX_MAC_INDEX + CCS_SYS_REBOOT]  
258          = "capability::SYS_REBOOT",  /* String table for PREFERENCE keyword. */
259          [CCS_MAX_MAC_INDEX + CCS_SYS_CHROOT]  static const char * const ccs_pref_keywords[CCS_MAX_PREF] = {
260          = "capability::SYS_CHROOT",          [CCS_PREF_MAX_AUDIT_LOG]      = "max_audit_log",
261          [CCS_MAX_MAC_INDEX + CCS_SYS_KILL]          [CCS_PREF_MAX_LEARNING_ENTRY] = "max_learning_entry",
262          = "capability::SYS_KILL",          [CCS_PREF_ENFORCING_PENALTY]  = "enforcing_penalty",
         [CCS_MAX_MAC_INDEX + CCS_SYS_VHANGUP]  
         = "capability::SYS_VHANGUP",  
         [CCS_MAX_MAC_INDEX + CCS_SYS_SETTIME]  
         = "capability::SYS_TIME",  
         [CCS_MAX_MAC_INDEX + CCS_SYS_NICE]  
         = "capability::SYS_NICE",  
         [CCS_MAX_MAC_INDEX + CCS_SYS_SETHOSTNAME]  
         = "capability::SYS_SETHOSTNAME",  
         [CCS_MAX_MAC_INDEX + CCS_USE_KERNEL_MODULE]  
         = "capability::use_kernel_module",  
         [CCS_MAX_MAC_INDEX + CCS_CREATE_FIFO]  
         = "capability::create_fifo",  
         [CCS_MAX_MAC_INDEX + CCS_CREATE_BLOCK_DEV]  
         = "capability::create_block_dev",  
         [CCS_MAX_MAC_INDEX + CCS_CREATE_CHAR_DEV]  
         = "capability::create_char_dev",  
         [CCS_MAX_MAC_INDEX + CCS_CREATE_UNIX_SOCKET]  
         = "capability::create_unix_socket",  
         [CCS_MAX_MAC_INDEX + CCS_SYS_LINK]  
         = "capability::SYS_LINK",  
         [CCS_MAX_MAC_INDEX + CCS_SYS_SYMLINK]  
         = "capability::SYS_SYMLINK",  
         [CCS_MAX_MAC_INDEX + CCS_SYS_RENAME]  
         = "capability::SYS_RENAME",  
         [CCS_MAX_MAC_INDEX + CCS_SYS_UNLINK]  
         = "capability::SYS_UNLINK",  
         [CCS_MAX_MAC_INDEX + CCS_SYS_CHMOD]  
         = "capability::SYS_CHMOD",  
         [CCS_MAX_MAC_INDEX + CCS_SYS_CHOWN]  
         = "capability::SYS_CHOWN",  
         [CCS_MAX_MAC_INDEX + CCS_SYS_IOCTL]  
         = "capability::SYS_IOCTL",  
         [CCS_MAX_MAC_INDEX + CCS_SYS_KEXEC_LOAD]  
         = "capability::SYS_KEXEC_LOAD",  
         [CCS_MAX_MAC_INDEX + CCS_SYS_PIVOT_ROOT]  
         = "capability::SYS_PIVOT_ROOT",  
         [CCS_MAX_MAC_INDEX + CCS_SYS_PTRACE]  
         = "capability::SYS_PTRACE",  
         [CCS_MAX_MAC_INDEX + CCS_CONCEAL_MOUNT]  
         = "capability::conceal_mount",  
         [CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX  
          + CCS_MAC_CATEGORY_FILE] = "file",  
         [CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX  
          + CCS_MAC_CATEGORY_NETWORK] = "network",  
         [CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX  
          + CCS_MAC_CATEGORY_MISC] = "misc",  
         [CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX  
          + CCS_MAC_CATEGORY_IPC] = "ipc",  
         [CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX  
          + CCS_MAC_CATEGORY_CAPABILITY] = "capability",  
263  };  };
264    
265  /* Permit policy management by non-root user? */  /* Permit policy management by non-root user? */
266  static bool ccs_manage_by_non_root;  static bool ccs_manage_by_non_root;
267    
268  /**  /**
269   * ccs_cap2keyword - Convert capability operation to capability name.   * ccs_yesno - Return "yes" or "no".
270   *   *
271   * @operation: The capability index.   * @value: Bool value.
272   *   *
273   * Returns the name of the specified capability's name.   * Returns "yes" if @value is not 0, "no" otherwise.
274   */   */
275  const char *ccs_cap2keyword(const u8 operation)  const char *ccs_yesno(const unsigned int value)
276  {  {
277          return operation < CCS_MAX_CAPABILITY_INDEX          return value ? "yes" : "no";
                 ? ccs_mac_keywords[CCS_MAX_MAC_INDEX + operation] + 12 : NULL;  
278  }  }
279    
280    /* Prototype fpr ccs_addprintf(). */
281    static void ccs_addprintf(char *buffer, int len, const char *fmt, ...)
282            __attribute__ ((format(printf, 3, 4)));
283    
284  /**  /**
285   * ccs_yesno - Return "yes" or "no".   * ccs_addprintf - strncat()-like-snprintf().
286   *   *
287   * @value: Bool value.   * @buffer: Buffer to write to. Must be '\0'-terminated.
288     * @len:    Size of @buffer.
289     * @fmt:    The printf()'s format string, followed by parameters.
290     *
291     * Returns nothing.
292   */   */
 static const char *ccs_yesno(const unsigned int value)  
 {  
         return value ? "yes" : "no";  
 }  
   
293  static void ccs_addprintf(char *buffer, int len, const char *fmt, ...)  static void ccs_addprintf(char *buffer, int len, const char *fmt, ...)
294  {  {
295          va_list args;          va_list args;
# Line 231  static void ccs_addprintf(char *buffer, Line 302  static void ccs_addprintf(char *buffer,
302  /**  /**
303   * ccs_flush - Flush queued string to userspace's buffer.   * ccs_flush - Flush queued string to userspace's buffer.
304   *   *
305   * @head:   Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
306   *   *
307   * Returns true if all data was flushed, false otherwise.   * Returns true if all data was flushed, false otherwise.
308   */   */
# Line 277  static bool ccs_flush(struct ccs_io_buff Line 348  static bool ccs_flush(struct ccs_io_buff
348   * @head:   Pointer to "struct ccs_io_buffer".   * @head:   Pointer to "struct ccs_io_buffer".
349   * @string: String to print.   * @string: String to print.
350   *   *
351     * Returns nothing.
352     *
353   * Note that @string has to be kept valid until @head is kfree()d.   * Note that @string has to be kept valid until @head is kfree()d.
354   * This means that char[] allocated on stack memory cannot be passed to   * This means that char[] allocated on stack memory cannot be passed to
355   * this function. Use ccs_io_printf() for char[] allocated on stack memory.   * this function. Use ccs_io_printf() for char[] allocated on stack memory.
# Line 295  static void ccs_set_string(struct ccs_io Line 368  static void ccs_set_string(struct ccs_io
368   *   *
369   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
370   * @fmt:  The printf()'s format string, followed by parameters.   * @fmt:  The printf()'s format string, followed by parameters.
371     *
372     * Returns nothing.
373   */   */
374  void ccs_io_printf(struct ccs_io_buffer *head, const char *fmt, ...)  void ccs_io_printf(struct ccs_io_buffer *head, const char *fmt, ...)
375  {  {
# Line 315  void ccs_io_printf(struct ccs_io_buffer Line 390  void ccs_io_printf(struct ccs_io_buffer
390          ccs_set_string(head, head->read_buf + pos);          ccs_set_string(head, head->read_buf + pos);
391  }  }
392    
393    /**
394     * ccs_set_space - Put a space to "struct ccs_io_buffer" structure.
395     *
396     * @head: Pointer to "struct ccs_io_buffer".
397     *
398     * Returns nothing.
399     */
400  static void ccs_set_space(struct ccs_io_buffer *head)  static void ccs_set_space(struct ccs_io_buffer *head)
401  {  {
402          ccs_set_string(head, " ");          ccs_set_string(head, " ");
403  }  }
404    
405    /**
406     * ccs_set_lf - Put a line feed to "struct ccs_io_buffer" structure.
407     *
408     * @head: Pointer to "struct ccs_io_buffer".
409     *
410     * Returns nothing.
411     */
412  static bool ccs_set_lf(struct ccs_io_buffer *head)  static bool ccs_set_lf(struct ccs_io_buffer *head)
413  {  {
414          ccs_set_string(head, "\n");          ccs_set_string(head, "\n");
# Line 348  static struct ccs_profile *ccs_assign_pr Line 437  static struct ccs_profile *ccs_assign_pr
437          ptr = ccs_profile_ptr[profile];          ptr = ccs_profile_ptr[profile];
438          if (!ptr && ccs_memory_ok(entry, sizeof(*entry))) {          if (!ptr && ccs_memory_ok(entry, sizeof(*entry))) {
439                  ptr = entry;                  ptr = entry;
                 ptr->audit = &ccs_default_profile.preference;  
                 ptr->learning = &ccs_default_profile.preference;  
                 ptr->permissive = &ccs_default_profile.preference;  
                 ptr->enforcing = &ccs_default_profile.preference;  
440                  ptr->default_config = CCS_CONFIG_DISABLED |                  ptr->default_config = CCS_CONFIG_DISABLED |
441                          CCS_CONFIG_WANT_GRANT_LOG | CCS_CONFIG_WANT_REJECT_LOG;                          CCS_CONFIG_WANT_GRANT_LOG | CCS_CONFIG_WANT_REJECT_LOG;
442                  memset(ptr->config, CCS_CONFIG_USE_DEFAULT,                  memset(ptr->config, CCS_CONFIG_USE_DEFAULT,
443                         sizeof(ptr->config));                         sizeof(ptr->config));
444                    ptr->pref[CCS_PREF_MAX_AUDIT_LOG] =
445                            CONFIG_CCSECURITY_MAX_AUDIT_LOG;
446                    ptr->pref[CCS_PREF_MAX_LEARNING_ENTRY] =
447                            CONFIG_CCSECURITY_MAX_ACCEPT_ENTRY;
448                  mb(); /* Avoid out-of-order execution. */                  mb(); /* Avoid out-of-order execution. */
449                  ccs_profile_ptr[profile] = ptr;                  ccs_profile_ptr[profile] = ptr;
450                  entry = NULL;                  entry = NULL;
451          }          }
452          mutex_unlock(&ccs_policy_lock);          mutex_unlock(&ccs_policy_lock);
453   out:  out:
454          kfree(entry);          kfree(entry);
455          return ptr;          return ptr;
456  }  }
457    
458  /**  /**
459   * ccs_check_profile - Check all profiles currently assigned to domains are defined.   * ccs_check_profile - Check all profiles currently assigned to domains are defined.
460     *
461     * Returns nothing.
462   */   */
463  static void ccs_check_profile(void)  static void ccs_check_profile(void)
464  {  {
465          struct ccs_domain_info *domain;          struct ccs_domain_info *domain;
466          const int idx = ccs_read_lock();          const int idx = ccs_read_lock();
467          ccs_policy_loaded = true;          ccs_policy_loaded = true;
468          list_for_each_entry_rcu(domain, &ccs_domain_list, list) {          list_for_each_entry_srcu(domain, &ccs_domain_list, list, &ccs_ss) {
469                  const u8 profile = domain->profile;                  const u8 profile = domain->profile;
470                  if (ccs_profile_ptr[profile])                  if (ccs_profile_ptr[profile])
471                          continue;                          continue;
472                    printk(KERN_ERR "Profile %u must be defined before using it.\n",
473                           profile);
474                    printk(KERN_ERR "Please see http://tomoyo.sourceforge.jp/1.8/ "
475                           "for more information.\n");
476                  panic("Profile %u (used by '%s') not defined.\n",                  panic("Profile %u (used by '%s') not defined.\n",
477                        profile, domain->domainname->name);                        profile, domain->domainname->name);
478          }          }
479          ccs_read_unlock(idx);          ccs_read_unlock(idx);
480          if (ccs_profile_version != 20090903)          if (ccs_profile_version != 20100903) {
481                    printk(KERN_ERR "Userland tools must be installed for "
482                           "TOMOYO 1.8, and policy must be initialized.\n");
483                    printk(KERN_ERR "Please see http://tomoyo.sourceforge.jp/1.8/ "
484                           "for more information.\n");
485                  panic("Profile version %u is not supported.\n",                  panic("Profile version %u is not supported.\n",
486                        ccs_profile_version);                        ccs_profile_version);
487          printk(KERN_INFO "CCSecurity: 1.7.2+   2010/07/21\n");          }
488            printk(KERN_INFO "CCSecurity: 1.8.0+   2010/12/31\n");
489          printk(KERN_INFO "Mandatory Access Control activated.\n");          printk(KERN_INFO "Mandatory Access Control activated.\n");
490  }  }
491    
# Line 398  static void ccs_check_profile(void) Line 498  static void ccs_check_profile(void)
498   */   */
499  struct ccs_profile *ccs_profile(const u8 profile)  struct ccs_profile *ccs_profile(const u8 profile)
500  {  {
501            static struct ccs_profile ccs_null_profile;
502          struct ccs_profile *ptr = ccs_profile_ptr[profile];          struct ccs_profile *ptr = ccs_profile_ptr[profile];
503          if (!ccs_policy_loaded)          if (!ptr)
504                  return &ccs_default_profile;                  ptr = &ccs_null_profile;
         BUG_ON(!ptr);  
505          return ptr;          return ptr;
506  }  }
507    
508    /**
509     * ccs_find_yesno - Find values for specified keyword.
510     *
511     * @string: String to check.
512     * @find:   Name of keyword.
513     *
514     * Returns 1 if "@find=yes" was found, 0 if "@find=no" was found, -1 otherwise.
515     */
516  static s8 ccs_find_yesno(const char *string, const char *find)  static s8 ccs_find_yesno(const char *string, const char *find)
517  {  {
518          const char *cp = strstr(string, find);          const char *cp = strstr(string, find);
# Line 418  static s8 ccs_find_yesno(const char *str Line 526  static s8 ccs_find_yesno(const char *str
526          return -1;          return -1;
527  }  }
528    
529  static void ccs_set_bool(bool *b, const char *string, const char *find)  /**
530  {   * ccs_set_uint - Set value for specified preference.
531          switch (ccs_find_yesno(string, find)) {   *
532          case 1:   * @i:      Pointer to "unsigned int".
533                  *b = true;   * @string: String to check.
534                  break;   * @find:   Name of keyword.
535          case 0:   *
536                  *b = false;   * Returns nothing.
537                  break;   */
         }  
 }  
   
538  static void ccs_set_uint(unsigned int *i, const char *string, const char *find)  static void ccs_set_uint(unsigned int *i, const char *string, const char *find)
539  {  {
540          const char *cp = strstr(string, find);          const char *cp = strstr(string, find);
# Line 437  static void ccs_set_uint(unsigned int *i Line 542  static void ccs_set_uint(unsigned int *i
542                  sscanf(cp + strlen(find), "=%u", i);                  sscanf(cp + strlen(find), "=%u", i);
543  }  }
544    
545  static void ccs_set_pref(const char *name, const char *value,  /**
546                           const bool use_default, struct ccs_profile *profile)   * ccs_set_mode - Set mode for specified profile.
547  {   *
548          struct ccs_preference **pref;   * @name:    Name of functionality.
549          bool *verbose;   * @value:   Mode for @name.
550          if (!strcmp(name, "audit")) {   * @profile: Pointer to "struct ccs_profile".
551                  if (use_default) {   *
552                          pref = &profile->audit;   * Returns 0 on success, negative value otherwise.
553                          goto set_default;   */
554                  }  static int ccs_set_mode(char *name, const char *value,
                 profile->audit = &profile->preference;  
 #ifdef CONFIG_CCSECURITY_AUDIT  
                 ccs_set_uint(&profile->preference.audit_max_grant_log, value,  
                              "max_grant_log");  
                 ccs_set_uint(&profile->preference.audit_max_reject_log, value,  
                              "max_reject_log");  
 #endif  
                 ccs_set_bool(&profile->preference.audit_task_info, value,  
                              "task_info");  
                 ccs_set_bool(&profile->preference.audit_path_info, value,  
                              "path_info");  
                 return;  
         }  
         if (!strcmp(name, "enforcing")) {  
                 if (use_default) {  
                         pref = &profile->enforcing;  
                         goto set_default;  
                 }  
                 profile->enforcing = &profile->preference;  
                 ccs_set_uint(&profile->preference.enforcing_penalty, value,  
                              "penalty");  
                 verbose = &profile->preference.enforcing_verbose;  
                 goto set_verbose;  
         }  
         if (!strcmp(name, "permissive")) {  
                 if (use_default) {  
                         pref = &profile->permissive;  
                         goto set_default;  
                 }  
                 profile->permissive = &profile->preference;  
                 verbose = &profile->preference.permissive_verbose;  
                 goto set_verbose;  
         }  
         if (!strcmp(name, "learning")) {  
                 if (use_default) {  
                         pref = &profile->learning;  
                         goto set_default;  
                 }  
                 profile->learning = &profile->preference;  
                 ccs_set_uint(&profile->preference.learning_max_entry, value,  
                              "max_entry");  
                 ccs_set_bool(&profile->preference.learning_exec_realpath,  
                              value, "exec.realpath");  
                 ccs_set_bool(&profile->preference.learning_exec_argv0, value,  
                              "exec.argv0");  
                 ccs_set_bool(&profile->preference.learning_symlink_target,  
                              value, "symlink.target");  
                 verbose = &profile->preference.learning_verbose;  
                 goto set_verbose;  
         }  
         return;  
  set_default:  
         *pref = &ccs_default_profile.preference;  
         return;  
  set_verbose:  
         ccs_set_bool(verbose, value, "verbose");  
 }  
   
 static int ccs_set_mode(char *name, const char *value, const bool use_default,  
555                          struct ccs_profile *profile)                          struct ccs_profile *profile)
556  {  {
557          u8 i;          u8 i;
558          u8 config;          u8 config;
559          if (!strcmp(name, "CONFIG")) {          if (!strcmp(name, "CONFIG")) {
560                  i = CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX                  i = CCS_MAX_MAC_INDEX + CCS_MAX_MAC_CATEGORY_INDEX;
                         + CCS_MAX_MAC_CATEGORY_INDEX;  
561                  config = profile->default_config;                  config = profile->default_config;
562          } else if (ccs_str_starts(&name, "CONFIG::")) {          } else if (ccs_str_starts(&name, "CONFIG::")) {
563                  config = 0;                  config = 0;
564                  for (i = 0; i < CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX                  for (i = 0; i < CCS_MAX_MAC_INDEX + CCS_MAX_MAC_CATEGORY_INDEX;
565                               + CCS_MAX_MAC_CATEGORY_INDEX; i++) {                       i++) {
566                          if (strcmp(name, ccs_mac_keywords[i]))                          int len = 0;
567                            if (i < CCS_MAX_MAC_INDEX) {
568                                    const u8 c = ccs_index2category[i];
569                                    const char *category =
570                                            ccs_category_keywords[c];
571                                    len = strlen(category);
572                                    if (strncmp(name, category, len) ||
573                                        name[len++] != ':' || name[len++] != ':')
574                                            continue;
575                            }
576                            if (strcmp(name + len, ccs_mac_keywords[i]))
577                                  continue;                                  continue;
578                          config = profile->config[i];                          config = profile->config[i];
579                          break;                          break;
580                  }                  }
581                  if (i == CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX                  if (i == CCS_MAX_MAC_INDEX + CCS_MAX_MAC_CATEGORY_INDEX)
                     + CCS_MAX_MAC_CATEGORY_INDEX)  
582                          return -EINVAL;                          return -EINVAL;
583          } else {          } else {
584                  return -EINVAL;                  return -EINVAL;
585          }          }
586          if (use_default) {          if (strstr(value, "use_default")) {
587                  config = CCS_CONFIG_USE_DEFAULT;                  config = CCS_CONFIG_USE_DEFAULT;
588          } else {          } else {
589                  u8 mode;                  u8 mode;
# Line 540  static int ccs_set_mode(char *name, cons Line 594  static int ccs_set_mode(char *name, cons
594                                   * 'config' from 'CCS_CONFIG_USE_DEAFULT'.                                   * 'config' from 'CCS_CONFIG_USE_DEAFULT'.
595                                   */                                   */
596                                  config = (config & ~7) | mode;                                  config = (config & ~7) | mode;
 #ifdef CONFIG_CCSECURITY_AUDIT  
597                  if (config != CCS_CONFIG_USE_DEFAULT) {                  if (config != CCS_CONFIG_USE_DEFAULT) {
598                          switch (ccs_find_yesno(value, "grant_log")) {                          switch (ccs_find_yesno(value, "grant_log")) {
599                          case 1:                          case 1:
# Line 559  static int ccs_set_mode(char *name, cons Line 612  static int ccs_set_mode(char *name, cons
612                                  break;                                  break;
613                          }                          }
614                  }                  }
 #endif  
615          }          }
616          if (i < CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX          if (i < CCS_MAX_MAC_INDEX + CCS_MAX_MAC_CATEGORY_INDEX)
             + CCS_MAX_MAC_CATEGORY_INDEX)  
617                  profile->config[i] = config;                  profile->config[i] = config;
618          else if (config != CCS_CONFIG_USE_DEFAULT)          else if (config != CCS_CONFIG_USE_DEFAULT)
619                  profile->default_config = config;                  profile->default_config = config;
# Line 580  static int ccs_write_profile(struct ccs_ Line 631  static int ccs_write_profile(struct ccs_
631  {  {
632          char *data = head->write_buf;          char *data = head->write_buf;
633          unsigned int i;          unsigned int i;
         bool use_default = false;  
634          char *cp;          char *cp;
635          struct ccs_profile *profile;          struct ccs_profile *profile;
636          if (sscanf(data, "PROFILE_VERSION=%u", &ccs_profile_version) == 1)          if (sscanf(data, "PROFILE_VERSION=%u", &ccs_profile_version) == 1)
637                  return 0;                  return 0;
638          i = simple_strtoul(data, &cp, 10);          i = simple_strtoul(data, &cp, 10);
639          if (data == cp) {          if (*cp != '-')
640                  profile = &ccs_default_profile;                  return -EINVAL;
641          } else {          data = cp + 1;
642                  if (*cp != '-')          profile = ccs_assign_profile(i);
643                          return -EINVAL;          if (!profile)
644                  data = cp + 1;                  return -EINVAL;
                 profile = ccs_assign_profile(i);  
                 if (!profile)  
                         return -EINVAL;  
         }  
645          cp = strchr(data, '=');          cp = strchr(data, '=');
646          if (!cp)          if (!cp)
647                  return -EINVAL;                  return -EINVAL;
648          *cp++ = '\0';          *cp++ = '\0';
         if (profile != &ccs_default_profile)  
                 use_default = strstr(cp, "use_default") != NULL;  
         if (ccs_str_starts(&data, "PREFERENCE::")) {  
                 ccs_set_pref(data, cp, use_default, profile);  
                 return 0;  
         }  
         if (profile == &ccs_default_profile)  
                 return -EINVAL;  
649          if (!strcmp(data, "COMMENT")) {          if (!strcmp(data, "COMMENT")) {
650                  const struct ccs_path_info *old_comment = profile->comment;                  const struct ccs_path_info *old_comment = profile->comment;
651                  profile->comment = ccs_get_name(cp);                  profile->comment = ccs_get_name(cp);
652                  ccs_put_name(old_comment);                  ccs_put_name(old_comment);
653                  return 0;                  return 0;
654          }          }
655          return ccs_set_mode(data, cp, use_default, profile);          if (!strcmp(data, "PREFERENCE")) {
656  }                  for (i = 0; i < CCS_MAX_PREF; i++)
657                            ccs_set_uint(&profile->pref[i], cp,
658  static void ccs_print_preference(struct ccs_io_buffer *head, const int idx)                                       ccs_pref_keywords[i]);
659  {                  return 0;
         struct ccs_preference *pref = &ccs_default_profile.preference;  
         const struct ccs_profile *profile = idx >= 0 ?  
                 ccs_profile_ptr[idx] : NULL;  
         char buffer[16] = "";  
         if (profile) {  
                 buffer[sizeof(buffer) - 1] = '\0';  
                 snprintf(buffer, sizeof(buffer) - 1, "%u-", idx);  
         }  
         if (profile) {  
                 pref = profile->audit;  
                 if (pref == &ccs_default_profile.preference)  
                         goto skip0;  
         }  
         ccs_io_printf(head, "%sPREFERENCE::%s={ "  
 #ifdef CONFIG_CCSECURITY_AUDIT  
                       "max_grant_log=%u max_reject_log=%u "  
 #endif  
                       "task_info=%s path_info=%s }\n", buffer,  
                       "audit",  
 #ifdef CONFIG_CCSECURITY_AUDIT  
                       pref->audit_max_grant_log,  
                       pref->audit_max_reject_log,  
 #endif  
                       ccs_yesno(pref->audit_task_info),  
                       ccs_yesno(pref->audit_path_info));  
  skip0:  
         if (profile) {  
                 pref = profile->learning;  
                 if (pref == &ccs_default_profile.preference)  
                         goto skip1;  
         }  
         ccs_io_printf(head, "%sPREFERENCE::%s={ "  
                       "verbose=%s max_entry=%u exec.realpath=%s "  
                       "exec.argv0=%s symlink.target=%s }\n",  
                       buffer, "learning",  
                       ccs_yesno(pref->learning_verbose),  
                       pref->learning_max_entry,  
                       ccs_yesno(pref->learning_exec_realpath),  
                       ccs_yesno(pref->learning_exec_argv0),  
                       ccs_yesno(pref->learning_symlink_target));  
  skip1:  
         if (profile) {  
                 pref = profile->permissive;  
                 if (pref == &ccs_default_profile.preference)  
                         goto skip2;  
         }  
         ccs_io_printf(head, "%sPREFERENCE::%s={ verbose=%s }\n",  
                       buffer, "permissive",  
                       ccs_yesno(pref->permissive_verbose));  
  skip2:  
         if (profile) {  
                 pref = profile->enforcing;  
                 if (pref == &ccs_default_profile.preference)  
                         return;  
660          }          }
661          ccs_io_printf(head, "%sPREFERENCE::%s={ verbose=%s "          return ccs_set_mode(data, cp, profile);
                       "penalty=%u }\n", buffer, "enforcing",  
                       ccs_yesno(pref->enforcing_verbose),  
                       pref->enforcing_penalty);  
662  }  }
663    
664    /**
665     * ccs_print_config - Print mode for specified functionality.
666     *
667     * @head:   Pointer to "struct ccs_io_buffer".
668     * @config: Mode for that functionality.
669     *
670     * Returns nothing.
671     *
672     * Caller prints functionality's name.
673     */
674  static void ccs_print_config(struct ccs_io_buffer *head, const u8 config)  static void ccs_print_config(struct ccs_io_buffer *head, const u8 config)
675  {  {
676          ccs_io_printf(head, "={ mode=%s", ccs_mode[config & 3]);          ccs_io_printf(head, "={ mode=%s grant_log=%s reject_log=%s }\n",
677  #ifdef CONFIG_CCSECURITY_AUDIT                        ccs_mode[config & 3],
         ccs_io_printf(head, " grant_log=%s reject_log=%s",  
678                        ccs_yesno(config & CCS_CONFIG_WANT_GRANT_LOG),                        ccs_yesno(config & CCS_CONFIG_WANT_GRANT_LOG),
679                        ccs_yesno(config & CCS_CONFIG_WANT_REJECT_LOG));                        ccs_yesno(config & CCS_CONFIG_WANT_REJECT_LOG));
 #endif  
         ccs_set_string(head, " }\n");  
680  }  }
681    
682  /**  /**
683   * ccs_read_profile - Read profile table.   * ccs_read_profile - Read profile table.
684   *   *
685   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
686     *
687     * Returns nothing.
688   */   */
689  static void ccs_read_profile(struct ccs_io_buffer *head)  static void ccs_read_profile(struct ccs_io_buffer *head)
690  {  {
691          u8 index;          u8 index;
692          const struct ccs_profile *profile;          const struct ccs_profile *profile;
693   next:  next:
694          index = head->r.index;          index = head->r.index;
695          profile = ccs_profile_ptr[index];          profile = ccs_profile_ptr[index];
696          switch (head->r.step) {          switch (head->r.step) {
697          case 0:          case 0:
698                  ccs_io_printf(head, "PROFILE_VERSION=%s\n", "20090903");                  ccs_io_printf(head, "PROFILE_VERSION=%s\n", "20100903");
                 ccs_print_preference(head, -1);  
699                  head->r.step++;                  head->r.step++;
700                  break;                  break;
701          case 1:          case 1:
# Line 720  static void ccs_read_profile(struct ccs_ Line 709  static void ccs_read_profile(struct ccs_
709                  break;                  break;
710          case 2:          case 2:
711                  {                  {
712                            u8 i;
713                          const struct ccs_path_info *comment = profile->comment;                          const struct ccs_path_info *comment = profile->comment;
714                          ccs_io_printf(head, "%u-COMMENT=", index);                          ccs_io_printf(head, "%u-COMMENT=", index);
715                          ccs_set_string(head, comment ? comment->name : "");                          ccs_set_string(head, comment ? comment->name : "");
716                          ccs_set_lf(head);                          ccs_set_lf(head);
717                            ccs_io_printf(head, "%u-PREFERENCE={ ", index);
718                            for (i = 0; i < CCS_MAX_PREF; i++)
719                                    ccs_io_printf(head, "%s=%u ",
720                                                  ccs_pref_keywords[i],
721                                                  profile->pref[i]);
722                            ccs_set_string(head, " }\n");
723                          head->r.step++;                          head->r.step++;
724                  }                  }
725                  break;                  break;
# Line 737  static void ccs_read_profile(struct ccs_ Line 733  static void ccs_read_profile(struct ccs_
733                  break;                  break;
734          case 4:          case 4:
735                  for ( ; head->r.bit < CCS_MAX_MAC_INDEX                  for ( ; head->r.bit < CCS_MAX_MAC_INDEX
                               + CCS_MAX_CAPABILITY_INDEX  
736                                + CCS_MAX_MAC_CATEGORY_INDEX; head->r.bit++) {                                + CCS_MAX_MAC_CATEGORY_INDEX; head->r.bit++) {
737                          const u8 i = head->r.bit;                          const u8 i = head->r.bit;
738                          const u8 config = profile->config[i];                          const u8 config = profile->config[i];
739                          if (config == CCS_CONFIG_USE_DEFAULT)                          if (config == CCS_CONFIG_USE_DEFAULT)
740                                  continue;                                  continue;
741                          ccs_io_printf(head, "%u-%s%s", index, "CONFIG::",                          if (i < CCS_MAX_MAC_INDEX)
742                                        ccs_mac_keywords[i]);                                  ccs_io_printf(head, "%u-CONFIG::%s::%s", index,
743                                                  ccs_category_keywords
744                                                  [ccs_index2category[i]],
745                                                  ccs_mac_keywords[i]);
746                            else
747                                    ccs_io_printf(head, "%u-CONFIG::%s", index,
748                                                  ccs_mac_keywords[i]);
749                          ccs_print_config(head, config);                          ccs_print_config(head, config);
750                          head->r.bit++;                          head->r.bit++;
751                          break;                          break;
752                  }                  }
753                  if (head->r.bit == CCS_MAX_MAC_INDEX                  if (head->r.bit == CCS_MAX_MAC_INDEX
                     + CCS_MAX_CAPABILITY_INDEX  
754                      + CCS_MAX_MAC_CATEGORY_INDEX) {                      + CCS_MAX_MAC_CATEGORY_INDEX) {
                         ccs_print_preference(head, index);  
755                          head->r.index++;                          head->r.index++;
756                          head->r.step = 1;                          head->r.step = 1;
757                  }                  }
# Line 762  static void ccs_read_profile(struct ccs_ Line 761  static void ccs_read_profile(struct ccs_
761                  goto next;                  goto next;
762  }  }
763    
764    /**
765     * ccs_same_manager - Check for duplicated "struct ccs_manager" entry.
766     *
767     * @a: Pointer to "struct ccs_acl_head".
768     * @b: Pointer to "struct ccs_acl_head".
769     *
770     * Returns true if @a == @b, false otherwise.
771     */
772  static bool ccs_same_manager(const struct ccs_acl_head *a,  static bool ccs_same_manager(const struct ccs_acl_head *a,
773                               const struct ccs_acl_head *b)                               const struct ccs_acl_head *b)
774  {  {
# Line 809  static int ccs_update_manager_entry(cons Line 816  static int ccs_update_manager_entry(cons
816  static int ccs_write_manager(struct ccs_io_buffer *head)  static int ccs_write_manager(struct ccs_io_buffer *head)
817  {  {
818          char *data = head->write_buf;          char *data = head->write_buf;
819          bool is_delete = ccs_str_starts(&data, CCS_KEYWORD_DELETE);          bool is_delete = ccs_str_starts(&data, "delete ");
820          if (!strcmp(data, "manage_by_non_root")) {          if (!strcmp(data, "manage_by_non_root")) {
821                  ccs_manage_by_non_root = !is_delete;                  ccs_manage_by_non_root = !is_delete;
822                  return 0;                  return 0;
# Line 822  static int ccs_write_manager(struct ccs_ Line 829  static int ccs_write_manager(struct ccs_
829   *   *
830   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
831   *   *
832     * Returns nothing.
833     *
834   * Caller holds ccs_read_lock().   * Caller holds ccs_read_lock().
835   */   */
836  static void ccs_read_manager(struct ccs_io_buffer *head)  static void ccs_read_manager(struct ccs_io_buffer *head)
# Line 853  static bool ccs_manager(void) Line 862  static bool ccs_manager(void)
862  {  {
863          struct ccs_manager *ptr;          struct ccs_manager *ptr;
864          const char *exe;          const char *exe;
865          struct task_struct *task = current;          struct ccs_security *task = ccs_current_security();
866          const struct ccs_path_info *domainname          const struct ccs_path_info *domainname
867                  = ccs_current_domain()->domainname;                  = ccs_current_domain()->domainname;
868          bool found = false;          bool found = false;
# Line 864  static bool ccs_manager(void) Line 873  static bool ccs_manager(void)
873          if (!ccs_manage_by_non_root && (current_uid() || current_euid()))          if (!ccs_manage_by_non_root && (current_uid() || current_euid()))
874                  return false;                  return false;
875          exe = ccs_get_exe();          exe = ccs_get_exe();
876          list_for_each_entry_rcu(ptr, &ccs_policy_list[CCS_ID_MANAGER],          list_for_each_entry_srcu(ptr, &ccs_policy_list[CCS_ID_MANAGER],
877                                  head.list) {                                   head.list, &ccs_ss) {
878                  if (ptr->head.is_deleted)                  if (ptr->head.is_deleted)
879                          continue;                          continue;
880                  if (ptr->is_domain) {                  if (ptr->is_domain) {
# Line 894  static bool ccs_manager(void) Line 903  static bool ccs_manager(void)
903  }  }
904    
905  /**  /**
  * ccs_find_condition_part - Find condition part from the statement.  
  *  
  * @data: String to parse.  
  *  
  * Returns pointer to the condition part if it was found in the statement,  
  * NULL otherwise.  
  */  
 static char *ccs_find_condition_part(char *data)  
 {  
         char *cp = strstr(data, " if ");  
         if (!cp)  
                 cp = strstr(data, " ; set ");  
         if (cp)  
                 *cp++ = '\0';  
         return cp;  
 }  
   
 /**  
906   * ccs_select_one - Parse select command.   * ccs_select_one - Parse select command.
907   *   *
908   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
# Line 957  static bool ccs_select_one(struct ccs_io Line 948  static bool ccs_select_one(struct ccs_io
948                  return true; /* Do nothing if open(O_WRONLY). */                  return true; /* Do nothing if open(O_WRONLY). */
949          memset(&head->r, 0, sizeof(head->r));          memset(&head->r, 0, sizeof(head->r));
950          head->r.print_this_domain_only = true;          head->r.print_this_domain_only = true;
951          head->r.eof = !domain;          if (domain)
952          head->r.domain = &domain->list;                  head->r.domain = &domain->list;
953            else
954                    head->r.eof = true;
955          ccs_io_printf(head, "# select %s\n", data);          ccs_io_printf(head, "# select %s\n", data);
956          if (domain && domain->is_deleted)          if (domain && domain->is_deleted)
957                  ccs_set_string(head, "# This is a deleted domain.\n");                  ccs_set_string(head, "# This is a deleted domain.\n");
958          return true;          return true;
959  }  }
960    
961    /**
962     * ccs_same_handler_acl - Check for duplicated "struct ccs_handler_acl" entry.
963     *
964     * @a: Pointer to "struct ccs_acl_info".
965     * @b: Pointer to "struct ccs_acl_info".
966     *
967     * Returns true if @a == @b, false otherwise.
968     */
969    static bool ccs_same_handler_acl(const struct ccs_acl_info *a,
970                                     const struct ccs_acl_info *b)
971    {
972            const struct ccs_handler_acl *p1 = container_of(a, typeof(*p1), head);
973            const struct ccs_handler_acl *p2 = container_of(b, typeof(*p2), head);
974            return p1->handler == p2->handler;
975    }
976    
977    /**
978     * ccs_same_task_acl - Check for duplicated "struct ccs_task_acl" entry.
979     *
980     * @a: Pointer to "struct ccs_acl_info".
981     * @b: Pointer to "struct ccs_acl_info".
982     *
983     * Returns true if @a == @b, false otherwise.
984     */
985    static bool ccs_same_task_acl(const struct ccs_acl_info *a,
986                                  const struct ccs_acl_info *b)
987    {
988            const struct ccs_task_acl *p1 = container_of(a, typeof(*p1), head);
989            const struct ccs_task_acl *p2 = container_of(b, typeof(*p2), head);
990            return p1->domainname == p2->domainname;
991    }
992    
993    /**
994     * ccs_write_task - Update task related list.
995     *
996     * @param: Pointer to "struct ccs_acl_param".
997     *
998     * Returns 0 on success, negative value otherwise.
999     */
1000    static int ccs_write_task(struct ccs_acl_param *param)
1001    {
1002            int error;
1003            const bool is_auto = ccs_str_starts(&param->data,
1004                                                "auto_domain_transition ");
1005            if (!is_auto && !ccs_str_starts(&param->data,
1006                                            "manual_domain_transition ")) {
1007                    struct ccs_handler_acl e = { };
1008                    char *handler;
1009                    if (ccs_str_starts(&param->data, "auto_execute_handler "))
1010                            e.head.type = CCS_TYPE_AUTO_EXECUTE_HANDLER;
1011                    else if (ccs_str_starts(&param->data,
1012                                            "denied_execute_handler "))
1013                            e.head.type = CCS_TYPE_DENIED_EXECUTE_HANDLER;
1014                    else
1015                            return -EINVAL;
1016                    handler = ccs_read_token(param);
1017                    if (!ccs_correct_path(handler))
1018                            return -EINVAL;
1019                    e.handler = ccs_get_name(handler);
1020                    if (!e.handler)
1021                            return -ENOMEM;
1022                    if (e.handler->is_patterned)
1023                            error = -EINVAL; /* No patterns allowed. */
1024                    else
1025                            error = ccs_update_domain(&e.head, sizeof(e), param,
1026                                                      ccs_same_handler_acl, NULL);
1027                    ccs_put_name(e.handler);
1028            } else {
1029                    struct ccs_task_acl e = {
1030                            .head.type = is_auto ?
1031                            CCS_TYPE_AUTO_TASK_ACL : CCS_TYPE_MANUAL_TASK_ACL,
1032                            .domainname = ccs_get_domainname(param),
1033                    };
1034                    if (!e.domainname)
1035                            error = -EINVAL;
1036                    else
1037                            error = ccs_update_domain(&e.head, sizeof(e), param,
1038                                                      ccs_same_task_acl, NULL);
1039                    ccs_put_name(e.domainname);
1040            }
1041            return error;
1042    }
1043    
1044    /**
1045     * ccs_write_domain2 - Write domain policy.
1046     *
1047     * @data:      Policy to be interpreted.
1048     * @domain:    Pointer to "struct ccs_domain_info".
1049     * @is_delete: True if it is a delete request.
1050     *
1051     * Returns 0 on success, negative value otherwise.
1052     */
1053  static int ccs_write_domain2(char *data, struct ccs_domain_info *domain,  static int ccs_write_domain2(char *data, struct ccs_domain_info *domain,
1054                               const bool is_delete)                               const bool is_delete)
1055  {  {
1056            struct ccs_acl_param param = {
1057                    .data = data,
1058                    .domain = domain,
1059                    .is_delete = is_delete,
1060            };
1061          static const struct {          static const struct {
1062                  const char *keyword;                  const char *keyword;
1063                  int (*write) (char *, struct ccs_domain_info *,                  int (*write) (struct ccs_acl_param *);
1064                                struct ccs_condition *, const bool);          } ccs_callback[7] = {
1065          } ccs_callback[4] = {                  { "file ", ccs_write_file },
1066                  { "network ", ccs_write_network },                  { "network inet ", ccs_write_inet_network },
1067                    { "network unix ", ccs_write_unix_network },
1068                  { "misc ", ccs_write_misc },                  { "misc ", ccs_write_misc },
1069                  { "capability ", ccs_write_capability },                  { "capability ", ccs_write_capability },
1070                  { "ipc ", ccs_write_ipc },                  { "ipc ", ccs_write_ipc },
1071                    { "task ", ccs_write_task },
1072          };          };
         int (*write) (char *, struct ccs_domain_info *, struct ccs_condition *,  
                       const bool) = ccs_write_file;  
         int error;  
1073          u8 i;          u8 i;
1074          struct ccs_condition *cond = NULL;          for (i = 0; i < 7; i++) {
1075          char *cp = ccs_find_condition_part(data);                  if (!ccs_str_starts(&param.data, ccs_callback[i].keyword))
         if (cp) {  
                 cond = ccs_get_condition(cp);  
                 if (!cond)  
                         return -EINVAL;  
         }  
         for (i = 0; i < 4; i++) {  
                 if (!ccs_str_starts(&data, ccs_callback[i].keyword))  
1076                          continue;                          continue;
1077                  write = ccs_callback[i].write;                  return ccs_callback[i].write(&param);
                 break;  
1078          }          }
1079          error = write(data, domain, cond, is_delete);          return -EINVAL;
         if (cond)  
                 ccs_put_condition(cond);  
         return error;  
1080  }  }
1081    
1082  static const char *ccs_dif[CCS_MAX_DOMAIN_INFO_FLAGS] = {  /* String table for domain flags. */
1083          [CCS_DIF_QUOTA_WARNED] = CCS_KEYWORD_QUOTA_EXCEEDED "\n",  const char * const ccs_dif[CCS_MAX_DOMAIN_INFO_FLAGS] = {
1084          [CCS_DIF_TRANSITION_FAILED] = CCS_KEYWORD_TRANSITION_FAILED "\n"          [CCS_DIF_QUOTA_WARNED]      = "quota_exceeded\n",
1085            [CCS_DIF_TRANSITION_FAILED] = "transition_failed\n",
1086  };  };
1087            
1088  /**  /**
1089   * ccs_write_domain - Write domain policy.   * ccs_write_domain - Write domain policy.
1090   *   *
# Line 1020  static int ccs_write_domain(struct ccs_i Line 1099  static int ccs_write_domain(struct ccs_i
1099          bool is_delete = false;          bool is_delete = false;
1100          bool is_select = false;          bool is_select = false;
1101          unsigned int profile;          unsigned int profile;
1102          if (ccs_str_starts(&data, CCS_KEYWORD_DELETE))          if (ccs_str_starts(&data, "delete "))
1103                  is_delete = true;                  is_delete = true;
1104          else if (ccs_str_starts(&data, CCS_KEYWORD_SELECT))          else if (ccs_str_starts(&data, "select "))
1105                  is_select = true;                  is_select = true;
1106          if (is_select && ccs_select_one(head, data))          if (is_select && ccs_select_one(head, data))
1107                  return 0;                  return 0;
# Line 1036  static int ccs_write_domain(struct ccs_i Line 1115  static int ccs_write_domain(struct ccs_i
1115                  else if (is_select)                  else if (is_select)
1116                          domain = ccs_find_domain(data);                          domain = ccs_find_domain(data);
1117                  else                  else
1118                          domain = ccs_assign_domain(data, 0, 0);                          domain = ccs_assign_domain(data, 0, 0, false);
1119                  head->w.domain = domain;                  head->w.domain = domain;
1120                  return 0;                  return 0;
1121          }          }
1122          if (!domain)          if (!domain)
1123                  return -EINVAL;                  return -EINVAL;
1124    
1125          if (sscanf(data, CCS_KEYWORD_USE_PROFILE "%u", &profile) == 1          if (sscanf(data, "use_profile %u\n", &profile) == 1
1126              && profile < CCS_MAX_PROFILES) {              && profile < CCS_MAX_PROFILES) {
1127                  if (!ccs_policy_loaded || ccs_profile_ptr[(u8) profile])                  if (!ccs_policy_loaded || ccs_profile_ptr[(u8) profile])
1128                          domain->profile = (u8) profile;                          if (!is_delete)
1129                                    domain->profile = (u8) profile;
1130                  return 0;                  return 0;
1131          }          }
1132          if (sscanf(data, CCS_KEYWORD_USE_GROUP "%u", &profile) == 1          if (sscanf(data, "use_group %u\n", &profile) == 1
1133              && profile < CCS_MAX_ACL_GROUPS) {              && profile < CCS_MAX_ACL_GROUPS) {
1134                  domain->group = (u8) profile;                  if (!is_delete)
1135                            domain->group = (u8) profile;
1136                  return 0;                  return 0;
1137          }          }
1138          for (profile = 0; profile < CCS_MAX_DOMAIN_INFO_FLAGS; profile++) {          for (profile = 0; profile < CCS_MAX_DOMAIN_INFO_FLAGS; profile++) {
# Line 1069  static int ccs_write_domain(struct ccs_i Line 1150  static int ccs_write_domain(struct ccs_i
1150   *   *
1151   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
1152   * @ptr:  Pointer to "struct ccs_name_union".   * @ptr:  Pointer to "struct ccs_name_union".
1153     *
1154     * Returns nothing.
1155   */   */
1156  static void ccs_print_name_union(struct ccs_io_buffer *head,  static void ccs_print_name_union(struct ccs_io_buffer *head,
1157                                   const struct ccs_name_union *ptr)                                   const struct ccs_name_union *ptr)
# Line 1093  static void ccs_print_name_union(struct Line 1176  static void ccs_print_name_union(struct
1176   *   *
1177   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
1178   * @ptr:  Pointer to "struct ccs_number_union".   * @ptr:  Pointer to "struct ccs_number_union".
1179     *
1180     * Returns nothing.
1181   */   */
1182  static void ccs_print_number_union(struct ccs_io_buffer *head,  static void ccs_print_number_union(struct ccs_io_buffer *head,
1183                                     const struct ccs_number_union *ptr)                                     const struct ccs_number_union *ptr)
# Line 1148  static bool ccs_print_condition(struct c Line 1233  static bool ccs_print_condition(struct c
1233  {  {
1234          switch (head->r.cond_step) {          switch (head->r.cond_step) {
1235          case 0:          case 0:
1236                  {                  head->r.cond_index = 0;
1237                          if (cond->condc)                  head->r.cond_step++;
                                 ccs_set_string(head, " if");  
                         head->r.cond_index = 0;  
                         head->r.cond_step++;  
                 }  
1238                  /* fall through */                  /* fall through */
1239          case 1:          case 1:
1240                  {                  {
# Line 1262  static bool ccs_print_condition(struct c Line 1343  static bool ccs_print_condition(struct c
1343                  head->r.cond_step++;                  head->r.cond_step++;
1344                  /* fall through */                  /* fall through */
1345          case 3:          case 3:
1346                  {                  if (cond->grant_log != CCS_GRANTLOG_AUTO)
1347                          u8 j;                          ccs_io_printf(head, " grant_log=%s",
1348                          const u8 i = cond->post_state[3];                                        ccs_yesno(cond->grant_log ==
1349                          if (i)                                                  CCS_GRANTLOG_YES));
1350                                  ccs_set_string(head, " ; set");                  if (cond->transit) {
1351                          for (j = 0; j < 3; j++)                          ccs_set_string(head, " auto_domain_transition=\"");
1352                                  if ((i & (1 << j)))                          ccs_set_string(head, cond->transit->name);
1353                                          ccs_io_printf(head,                          ccs_set_string(head, "\"");
                                                       " task.state[%u]=%u", j,  
                                                       cond->post_state[j]);  
                         if (i & (1 << 4))  
                                 ccs_io_printf(head, " audit=%s",  
                                               ccs_yesno(cond->post_state[4]));  
1354                  }                  }
1355                  ccs_set_lf(head);                  ccs_set_lf(head);
1356                  return true;                  return true;
# Line 1298  static u8 ccs_fns(const u8 perm, u8 bit) Line 1374  static u8 ccs_fns(const u8 perm, u8 bit)
1374          return bit;          return bit;
1375  }  }
1376    
1377    /**
1378     * ccs_set_group - Print "acl_group " header keyword.
1379     *
1380     * @head: Pointer to "struct ccs_io_buffer".
1381     *
1382     * Returns nothing.
1383     */
1384  static void ccs_set_group(struct ccs_io_buffer *head)  static void ccs_set_group(struct ccs_io_buffer *head)
1385  {  {
1386          if (head->type == CCS_EXCEPTIONPOLICY)          if (head->type == CCS_EXCEPTIONPOLICY)
# Line 1321  static bool ccs_print_entry(struct ccs_i Line 1404  static bool ccs_print_entry(struct ccs_i
1404                  goto print_cond_part;                  goto print_cond_part;
1405          if (acl->is_deleted)          if (acl->is_deleted)
1406                  return true;                  return true;
1407   next:  next:
1408          bit = head->r.bit;          bit = head->r.bit;
1409          if (!ccs_flush(head))          if (!ccs_flush(head))
1410                  return false;                  return false;
# Line 1333  static bool ccs_print_entry(struct ccs_i Line 1416  static bool ccs_print_entry(struct ccs_i
1416                          if (!(perm & (1 << bit)))                          if (!(perm & (1 << bit)))
1417                                  continue;                                  continue;
1418                          if (head->r.print_execute_only &&                          if (head->r.print_execute_only &&
1419                              bit != CCS_TYPE_EXECUTE && bit != CCS_TYPE_TRANSIT)                              bit != CCS_TYPE_EXECUTE
1420                                /* && bit != CCS_TYPE_TRANSIT */)
1421                                  continue;                                  continue;
1422                          break;                          break;
1423                  }                  }
# Line 1343  static bool ccs_print_entry(struct ccs_i Line 1427  static bool ccs_print_entry(struct ccs_i
1427                  ccs_set_string(head, "file ");                  ccs_set_string(head, "file ");
1428                  ccs_set_string(head, ccs_path_keyword[bit]);                  ccs_set_string(head, ccs_path_keyword[bit]);
1429                  ccs_print_name_union(head, &ptr->name);                  ccs_print_name_union(head, &ptr->name);
1430          } else if (acl_type == CCS_TYPE_EXECUTE_HANDLER ||          } else if (acl_type == CCS_TYPE_AUTO_EXECUTE_HANDLER ||
1431                     acl_type == CCS_TYPE_DENIED_EXECUTE_HANDLER) {                     acl_type == CCS_TYPE_DENIED_EXECUTE_HANDLER) {
1432                  struct ccs_execute_handler *ptr                  struct ccs_handler_acl *ptr
1433                          = container_of(acl, typeof(*ptr), head);                          = container_of(acl, typeof(*ptr), head);
1434                  ccs_set_group(head);                  ccs_set_group(head);
1435                  ccs_io_printf(head, "%s ",                  ccs_set_string(head, "task ");
1436                                acl_type == CCS_TYPE_EXECUTE_HANDLER ?                  ccs_set_string(head, acl_type == CCS_TYPE_AUTO_EXECUTE_HANDLER
1437                                CCS_KEYWORD_EXECUTE_HANDLER :                                 ? "auto_execute_handler " :
1438                                CCS_KEYWORD_DENIED_EXECUTE_HANDLER);                                 "denied_execute_handler ");
1439                  ccs_set_string(head, ptr->handler->name);                  ccs_set_string(head, ptr->handler->name);
1440            } else if (acl_type == CCS_TYPE_AUTO_TASK_ACL ||
1441                       acl_type == CCS_TYPE_MANUAL_TASK_ACL) {
1442                    struct ccs_task_acl *ptr =
1443                            container_of(acl, typeof(*ptr), head);
1444                    ccs_set_group(head);
1445                    ccs_set_string(head, "task ");
1446                    ccs_set_string(head, acl_type == CCS_TYPE_AUTO_TASK_ACL ?
1447                                   "auto_domain_transition " :
1448                                   "manual_domain_transition ");
1449                    ccs_set_string(head, ptr->domainname->name);
1450          } else if (head->r.print_execute_only) {          } else if (head->r.print_execute_only) {
1451                  return true;                  return true;
1452          } else if (acl_type == CCS_TYPE_MKDEV_ACL) {          } else if (acl_type == CCS_TYPE_MKDEV_ACL) {
# Line 1363  static bool ccs_print_entry(struct ccs_i Line 1457  static bool ccs_print_entry(struct ccs_i
1457                          goto done;                          goto done;
1458                  ccs_set_group(head);                  ccs_set_group(head);
1459                  ccs_set_string(head, "file ");                  ccs_set_string(head, "file ");
1460                  ccs_set_string(head, ccs_mkdev_keyword[bit]);                  ccs_set_string(head, ccs_mac_keywords[ccs_pnnn2mac[bit]]);
1461                  ccs_print_name_union(head, &ptr->name);                  ccs_print_name_union(head, &ptr->name);
1462                  ccs_print_number_union(head, &ptr->mode);                  ccs_print_number_union(head, &ptr->mode);
1463                  ccs_print_number_union(head, &ptr->major);                  ccs_print_number_union(head, &ptr->major);
# Line 1376  static bool ccs_print_entry(struct ccs_i Line 1470  static bool ccs_print_entry(struct ccs_i
1470                          goto done;                          goto done;
1471                  ccs_set_group(head);                  ccs_set_group(head);
1472                  ccs_set_string(head, "file ");                  ccs_set_string(head, "file ");
1473                  ccs_set_string(head, ccs_path2_keyword[bit]);                  ccs_set_string(head, ccs_mac_keywords[ccs_pp2mac[bit]]);
1474                  ccs_print_name_union(head, &ptr->name1);                  ccs_print_name_union(head, &ptr->name1);
1475                  ccs_print_name_union(head, &ptr->name2);                  ccs_print_name_union(head, &ptr->name2);
1476          } else if (acl_type == CCS_TYPE_PATH_NUMBER_ACL) {          } else if (acl_type == CCS_TYPE_PATH_NUMBER_ACL) {
# Line 1387  static bool ccs_print_entry(struct ccs_i Line 1481  static bool ccs_print_entry(struct ccs_i
1481                          goto done;                          goto done;
1482                  ccs_set_group(head);                  ccs_set_group(head);
1483                  ccs_set_string(head, "file ");                  ccs_set_string(head, "file ");
1484                  ccs_set_string(head, ccs_path_number_keyword[bit]);                  ccs_set_string(head, ccs_mac_keywords[ccs_pn2mac[bit]]);
1485                  ccs_print_name_union(head, &ptr->name);                  ccs_print_name_union(head, &ptr->name);
1486                  ccs_print_number_union(head, &ptr->number);                  ccs_print_number_union(head, &ptr->number);
1487          } else if (acl_type == CCS_TYPE_ENV_ACL) {          } else if (acl_type == CCS_TYPE_ENV_ACL) {
# Line 1401  static bool ccs_print_entry(struct ccs_i Line 1495  static bool ccs_print_entry(struct ccs_i
1495                          container_of(acl, typeof(*ptr), head);                          container_of(acl, typeof(*ptr), head);
1496                  ccs_set_group(head);                  ccs_set_group(head);
1497                  ccs_set_string(head, "capability ");                  ccs_set_string(head, "capability ");
1498                  ccs_set_string(head, ccs_cap2keyword(ptr->operation));                  ccs_set_string(head,
1499          } else if (acl_type == CCS_TYPE_IP_NETWORK_ACL) {                                 ccs_mac_keywords[ccs_c2mac[ptr->operation]]);
1500                  struct ccs_ip_network_acl *ptr =          } else if (acl_type == CCS_TYPE_INET_ACL) {
1501                    struct ccs_inet_acl *ptr =
1502                          container_of(acl, typeof(*ptr), head);                          container_of(acl, typeof(*ptr), head);
1503                  bit = ccs_fns(ptr->perm, bit);                  bit = ccs_fns(ptr->perm, bit);
1504                  if (bit >= CCS_MAX_NETWORK_OPERATION)                  if (bit >= CCS_MAX_NETWORK_OPERATION)
1505                          goto done;                          goto done;
1506                  ccs_set_group(head);                  ccs_set_group(head);
1507                  ccs_set_string(head, "network ");                  ccs_set_string(head, "network inet ");
1508                  ccs_set_string(head, ccs_net_keyword[bit]);                  ccs_set_string(head, ccs_proto_keyword[ptr->protocol]);
1509                    ccs_set_space(head);
1510                    ccs_set_string(head, ccs_socket_keyword[bit]);
1511                  ccs_set_space(head);                  ccs_set_space(head);
1512                  switch (ptr->address_type) {                  switch (ptr->address_type) {
1513                          char buf[128];                          char buf[128];
# Line 1431  static bool ccs_print_entry(struct ccs_i Line 1528  static bool ccs_print_entry(struct ccs_i
1528                          break;                          break;
1529                  }                  }
1530                  ccs_print_number_union(head, &ptr->port);                  ccs_print_number_union(head, &ptr->port);
1531            } else if (acl_type == CCS_TYPE_UNIX_ACL) {
1532                    struct ccs_unix_acl *ptr =
1533                            container_of(acl, typeof(*ptr), head);
1534                    bit = ccs_fns(ptr->perm, bit);
1535                    if (bit >= CCS_MAX_NETWORK_OPERATION)
1536                            goto done;
1537                    ccs_set_group(head);
1538                    ccs_set_string(head, "network unix ");
1539                    ccs_set_string(head, ccs_proto_keyword[ptr->protocol]);
1540                    ccs_set_space(head);
1541                    ccs_set_string(head, ccs_socket_keyword[bit]);
1542                    ccs_print_name_union(head, &ptr->name);
1543          } else if (acl_type == CCS_TYPE_SIGNAL_ACL) {          } else if (acl_type == CCS_TYPE_SIGNAL_ACL) {
1544                  struct ccs_signal_acl *ptr =                  struct ccs_signal_acl *ptr =
1545                          container_of(acl, typeof(*ptr), head);                          container_of(acl, typeof(*ptr), head);
# Line 1454  static bool ccs_print_entry(struct ccs_i Line 1563  static bool ccs_print_entry(struct ccs_i
1563                  head->r.cond_step = 0;                  head->r.cond_step = 0;
1564                  if (!ccs_flush(head))                  if (!ccs_flush(head))
1565                          return false;                          return false;
1566   print_cond_part:  print_cond_part:
1567                  if (!ccs_print_condition(head, acl->cond))                  if (!ccs_print_condition(head, acl->cond))
1568                          return false;                          return false;
1569                  head->r.print_cond_part = false;                  head->r.print_cond_part = false;
# Line 1466  static bool ccs_print_entry(struct ccs_i Line 1575  static bool ccs_print_entry(struct ccs_i
1575          case CCS_TYPE_MKDEV_ACL:          case CCS_TYPE_MKDEV_ACL:
1576          case CCS_TYPE_PATH2_ACL:          case CCS_TYPE_PATH2_ACL:
1577          case CCS_TYPE_PATH_NUMBER_ACL:          case CCS_TYPE_PATH_NUMBER_ACL:
1578          case CCS_TYPE_IP_NETWORK_ACL:          case CCS_TYPE_INET_ACL:
1579            case CCS_TYPE_UNIX_ACL:
1580                  goto next;                  goto next;
1581          }          }
1582   done:  done:
1583          head->r.bit = 0;          head->r.bit = 0;
1584          return true;          return true;
1585  }  }
# Line 1479  static bool ccs_print_entry(struct ccs_i Line 1589  static bool ccs_print_entry(struct ccs_i
1589   *   *
1590   * @head:   Pointer to "struct ccs_io_buffer".   * @head:   Pointer to "struct ccs_io_buffer".
1591   * @domain: Pointer to "struct ccs_domain_info".   * @domain: Pointer to "struct ccs_domain_info".
1592   *   * @index:  Index number.
  * Caller holds ccs_read_lock().  
1593   *   *
1594   * Returns true on success, false otherwise.   * Returns true on success, false otherwise.
1595     *
1596     * Caller holds ccs_read_lock().
1597   */   */
1598  static bool ccs_read_domain2(struct ccs_io_buffer *head,  static bool ccs_read_domain2(struct ccs_io_buffer *head,
1599                               struct ccs_domain_info *domain)                               struct ccs_domain_info *domain,
1600                                 const u8 index)
1601  {  {
1602          list_for_each_cookie(head->r.acl, &domain->acl_info_list) {          list_for_each_cookie(head->r.acl, &domain->acl_info_list[index]) {
1603                  struct ccs_acl_info *ptr =                  struct ccs_acl_info *ptr =
1604                          list_entry(head->r.acl, typeof(*ptr), list);                          list_entry(head->r.acl, typeof(*ptr), list);
1605                  if (!ccs_print_entry(head, ptr))                  if (!ccs_print_entry(head, ptr))
# Line 1502  static bool ccs_read_domain2(struct ccs_ Line 1614  static bool ccs_read_domain2(struct ccs_
1614   *   *
1615   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
1616   *   *
1617     * Returns nothing.
1618     *
1619   * Caller holds ccs_read_lock().   * Caller holds ccs_read_lock().
1620   */   */
1621  static void ccs_read_domain(struct ccs_io_buffer *head)  static void ccs_read_domain(struct ccs_io_buffer *head)
# Line 1520  static void ccs_read_domain(struct ccs_i Line 1634  static void ccs_read_domain(struct ccs_i
1634                          /* Print domainname and flags. */                          /* Print domainname and flags. */
1635                          ccs_set_string(head, domain->domainname->name);                          ccs_set_string(head, domain->domainname->name);
1636                          ccs_set_lf(head);                          ccs_set_lf(head);
1637                          ccs_io_printf(head, CCS_KEYWORD_USE_PROFILE "%u\n",                          ccs_io_printf(head, "use_profile %u\n",
1638                                        domain->profile);                                        domain->profile);
1639                          ccs_io_printf(head, CCS_KEYWORD_USE_GROUP "%u\n",                          ccs_io_printf(head, "use_group %u\n", domain->group);
                                       domain->group);  
1640                          for (i = 0; i < CCS_MAX_DOMAIN_INFO_FLAGS; i++)                          for (i = 0; i < CCS_MAX_DOMAIN_INFO_FLAGS; i++)
1641                                  if (domain->flags[i])                                  if (domain->flags[i])
1642                                          ccs_set_string(head, ccs_dif[i]);                                          ccs_set_string(head, ccs_dif[i]);
# Line 1531  static void ccs_read_domain(struct ccs_i Line 1644  static void ccs_read_domain(struct ccs_i
1644                          ccs_set_lf(head);                          ccs_set_lf(head);
1645                          /* fall through */                          /* fall through */
1646                  case 1:                  case 1:
1647                          if (!ccs_read_domain2(head, domain))                          if (!ccs_read_domain2(head, domain, 0))
1648                                    return;
1649                            head->r.step++;
1650                            /* fall through */
1651                    case 2:
1652                            if (!ccs_read_domain2(head, domain, 1))
1653                                  return;                                  return;
1654                          head->r.step++;                          head->r.step++;
1655                          if (!ccs_set_lf(head))                          if (!ccs_set_lf(head))
1656                                  return;                                  return;
1657                          /* fall through */                          /* fall through */
1658                  case 2:                  case 3:
1659                          head->r.step = 0;                          head->r.step = 0;
1660                          if (head->r.print_this_domain_only)                          if (head->r.print_this_domain_only)
1661                                  goto done;                                  goto done;
1662                  }                  }
1663          }          }
1664   done:  done:
1665          head->r.eof = true;          head->r.eof = true;
1666  }  }
1667    
# Line 1584  static int ccs_write_domain_profile(stru Line 1702  static int ccs_write_domain_profile(stru
1702   *   *
1703   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
1704   *   *
1705     * Returns nothing.
1706     *
1707   * This is equivalent to doing   * This is equivalent to doing
1708   *   *
1709   *     grep -A 1 '^<kernel>' /proc/ccs/domain_policy |   *     grep -A 1 '^<kernel>' /proc/ccs/domain_policy |
# Line 1612  static void ccs_read_domain_profile(stru Line 1732  static void ccs_read_domain_profile(stru
1732  }  }
1733    
1734  /**  /**
1735   * ccs_write_pid: Specify PID to obtain domainname.   * ccs_write_pid - Specify PID to obtain domainname.
1736   *   *
1737   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
1738   *   *
# Line 1668  static void ccs_read_pid(struct ccs_io_b Line 1788  static void ccs_read_pid(struct ccs_io_b
1788  #endif  #endif
1789          if (p) {          if (p) {
1790                  domain = ccs_task_domain(p);                  domain = ccs_task_domain(p);
1791                  ccs_flags = p->ccs_flags;                  ccs_flags = ccs_task_flags(p);
1792          }          }
1793          ccs_tasklist_unlock();          ccs_tasklist_unlock();
1794          if (!domain)          if (!domain)
# Line 1677  static void ccs_read_pid(struct ccs_io_b Line 1797  static void ccs_read_pid(struct ccs_io_b
1797                  ccs_io_printf(head, "%u %u ", pid, domain->profile);                  ccs_io_printf(head, "%u %u ", pid, domain->profile);
1798                  ccs_set_string(head, domain->domainname->name);                  ccs_set_string(head, domain->domainname->name);
1799          } else {          } else {
1800                  ccs_io_printf(head, "%u manager=%s execute_handler=%s "                  ccs_io_printf(head, "%u manager=%s execute_handler=%s ", pid,
                               "state[0]=%u state[1]=%u state[2]=%u", pid,  
1801                                ccs_yesno(ccs_flags &                                ccs_yesno(ccs_flags &
1802                                          CCS_TASK_IS_MANAGER),                                          CCS_TASK_IS_MANAGER),
1803                                ccs_yesno(ccs_flags &                                ccs_yesno(ccs_flags &
1804                                          CCS_TASK_IS_EXECUTE_HANDLER),                                          CCS_TASK_IS_EXECUTE_HANDLER));
                               (u8) (ccs_flags >> 24),  
                               (u8) (ccs_flags >> 16),  
                               (u8) (ccs_flags >> 8));  
1805          }          }
1806  }  }
1807    
1808  static const char *ccs_transition_type[CCS_MAX_TRANSITION_TYPE] = {  /* String table for domain transition control keywords. */
1809          [CCS_TRANSITION_CONTROL_NO_INITIALIZE]  static const char * const ccs_transition_type[CCS_MAX_TRANSITION_TYPE] = {
1810          = CCS_KEYWORD_NO_INITIALIZE_DOMAIN,          [CCS_TRANSITION_CONTROL_NO_INITIALIZE] = "no_initialize_domain ",
1811          [CCS_TRANSITION_CONTROL_INITIALIZE] = CCS_KEYWORD_INITIALIZE_DOMAIN,          [CCS_TRANSITION_CONTROL_INITIALIZE]    = "initialize_domain ",
1812          [CCS_TRANSITION_CONTROL_NO_KEEP] = CCS_KEYWORD_NO_KEEP_DOMAIN,          [CCS_TRANSITION_CONTROL_NO_KEEP]       = "no_keep_domain ",
1813          [CCS_TRANSITION_CONTROL_KEEP] = CCS_KEYWORD_KEEP_DOMAIN          [CCS_TRANSITION_CONTROL_KEEP]          = "keep_domain ",
1814  };  };
1815    
1816  static const char *ccs_group_name[CCS_MAX_GROUP] = {  /* String table for grouping keywords. */
1817          [CCS_PATH_GROUP] = CCS_KEYWORD_PATH_GROUP,  static const char * const ccs_group_name[CCS_MAX_GROUP] = {
1818          [CCS_NUMBER_GROUP] = CCS_KEYWORD_NUMBER_GROUP,          [CCS_PATH_GROUP]    = "path_group ",
1819          [CCS_ADDRESS_GROUP] = CCS_KEYWORD_ADDRESS_GROUP          [CCS_NUMBER_GROUP]  = "number_group ",
1820            [CCS_ADDRESS_GROUP] = "address_group ",
1821  };  };
1822    
1823  /**  /**
# Line 1713  static const char *ccs_group_name[CCS_MA Line 1830  static const char *ccs_group_name[CCS_MA
1830  static int ccs_write_exception(struct ccs_io_buffer *head)  static int ccs_write_exception(struct ccs_io_buffer *head)
1831  {  {
1832          char *data = head->write_buf;          char *data = head->write_buf;
1833          const bool is_delete = ccs_str_starts(&data, CCS_KEYWORD_DELETE);          const bool is_delete = ccs_str_starts(&data, "delete ");
1834          u8 i;          u8 i;
1835          static const struct {          static const struct {
1836                  const char *keyword;                  const char *keyword;
1837                  int (*write) (char *, const bool);                  int (*write) (char *, const bool);
1838          } ccs_callback[3] = {          } ccs_callback[2] = {
1839                  { CCS_KEYWORD_AGGREGATOR, ccs_write_aggregator },                  { "aggregator ",    ccs_write_aggregator },
1840                  { CCS_KEYWORD_FILE_PATTERN, ccs_write_pattern },                  { "deny_autobind ", ccs_write_reserved_port },
                 { CCS_KEYWORD_DENY_AUTOBIND, ccs_write_reserved_port }  
1841          };          };
1842          for (i = 0; i < 3; i++)          for (i = 0; i < 2; i++)
1843                  if (ccs_str_starts(&data, ccs_callback[i].keyword))                  if (ccs_str_starts(&data, ccs_callback[i].keyword))
1844                          return ccs_callback[i].write(data, is_delete);                          return ccs_callback[i].write(data, is_delete);
1845          for (i = 0; i < CCS_MAX_TRANSITION_TYPE; i++)          for (i = 0; i < CCS_MAX_TRANSITION_TYPE; i++)
# Line 1778  static bool ccs_read_group(struct ccs_io Line 1894  static bool ccs_read_group(struct ccs_io
1894                                                  head)->member_name->name);                                                  head)->member_name->name);
1895                          } else if (idx == CCS_NUMBER_GROUP) {                          } else if (idx == CCS_NUMBER_GROUP) {
1896                                  ccs_print_number_union(head, &container_of                                  ccs_print_number_union(head, &container_of
1897                                                         (ptr, struct ccs_number_group,                                                 (ptr, struct ccs_number_group,
1898                                                          head)->number);                                                  head)->number);
1899                          } else if (idx == CCS_ADDRESS_GROUP) {                          } else if (idx == CCS_ADDRESS_GROUP) {
1900                                  char buffer[128];                                  char buffer[128];
1901                                  struct ccs_address_group *member =                                  struct ccs_address_group *member =
# Line 1840  static bool ccs_read_policy(struct ccs_i Line 1956  static bool ccs_read_policy(struct ccs_i
1956                          {                          {
1957                                  struct ccs_aggregator *ptr =                                  struct ccs_aggregator *ptr =
1958                                          container_of(acl, typeof(*ptr), head);                                          container_of(acl, typeof(*ptr), head);
1959                                  ccs_set_string(head, CCS_KEYWORD_AGGREGATOR);                                  ccs_set_string(head, "aggregator ");
1960                                  ccs_set_string(head, ptr->original_name->name);                                  ccs_set_string(head, ptr->original_name->name);
1961                                  ccs_set_space(head);                                  ccs_set_space(head);
1962                                  ccs_set_string(head,                                  ccs_set_string(head,
1963                                                 ptr->aggregated_name->name);                                                 ptr->aggregated_name->name);
1964                          }                          }
1965                          break;                          break;
                 case CCS_ID_PATTERN:  
                         {  
                                 struct ccs_pattern *ptr =  
                                         container_of(acl, typeof(*ptr), head);  
                                 ccs_set_string(head, CCS_KEYWORD_FILE_PATTERN);  
                                 ccs_set_string(head, ptr->pattern->name);  
                         }  
                         break;  
1966                  case CCS_ID_RESERVEDPORT:                  case CCS_ID_RESERVEDPORT:
1967                          {                          {
1968                                  struct ccs_reserved *ptr =                                  struct ccs_reserved *ptr =
1969                                          container_of(acl, typeof(*ptr), head);                                          container_of(acl, typeof(*ptr), head);
1970                                  const u16 min_port = ptr->min_port;                                  const u16 min_port = ptr->min_port;
1971                                  const u16 max_port = ptr->max_port;                                  const u16 max_port = ptr->max_port;
1972                                  ccs_set_string(head,                                  ccs_set_string(head, "deny_autobind ");
                                                CCS_KEYWORD_DENY_AUTOBIND);  
1973                                  ccs_io_printf(head, "%u", min_port);                                  ccs_io_printf(head, "%u", min_port);
1974                                  if (min_port != max_port)                                  if (min_port != max_port)
1975                                          ccs_io_printf(head, "-%u", max_port);                                          ccs_io_printf(head, "-%u", max_port);
# Line 1882  static bool ccs_read_policy(struct ccs_i Line 1989  static bool ccs_read_policy(struct ccs_i
1989   *   *
1990   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
1991   *   *
1992     * Returns nothing.
1993     *
1994   * Caller holds ccs_read_lock().   * Caller holds ccs_read_lock().
1995   */   */
1996  static void ccs_read_exception(struct ccs_io_buffer *head)  static void ccs_read_exception(struct ccs_io_buffer *head)
# Line 1899  static void ccs_read_exception(struct cc Line 2008  static void ccs_read_exception(struct cc
2008          if (head->r.step < CCS_MAX_POLICY + CCS_MAX_GROUP)          if (head->r.step < CCS_MAX_POLICY + CCS_MAX_GROUP)
2009                  return;                  return;
2010          while (head->r.step < CCS_MAX_POLICY + CCS_MAX_GROUP          while (head->r.step < CCS_MAX_POLICY + CCS_MAX_GROUP
2011                 + CCS_MAX_ACL_GROUPS) {                 + CCS_MAX_ACL_GROUPS * 2) {
2012                  head->r.group_index = head->r.step - CCS_MAX_POLICY                  head->r.group_index = (head->r.step - CCS_MAX_POLICY
2013                          - CCS_MAX_GROUP;                                         - CCS_MAX_GROUP) / 2;
2014                  if (!ccs_read_domain2(head,                  if (!ccs_read_domain2(head,
2015                                        &ccs_acl_group[head->r.group_index]))                                        &ccs_acl_group[head->r.group_index],
2016                                          head->r.step & 1))
2017                          return;                          return;
2018                  head->r.step++;                  head->r.step++;
2019          }          }
2020          head->r.eof = true;          head->r.eof = true;
2021  }  }
2022    
2023  /* Wait queue for ccs_query_list. */  /* Wait queue for kernel -> userspace notification. */
2024  static DECLARE_WAIT_QUEUE_HEAD(ccs_query_wait);  static DECLARE_WAIT_QUEUE_HEAD(ccs_query_wait);
2025    /* Wait queue for userspace -> kernel notification. */
2026  /* Lock for manipulating ccs_query_list. */  static DECLARE_WAIT_QUEUE_HEAD(ccs_answer_wait);
 static DEFINE_SPINLOCK(ccs_query_list_lock);  
2027    
2028  /* Structure for query. */  /* Structure for query. */
2029  struct ccs_query {  struct ccs_query {
# Line 1924  struct ccs_query { Line 2033  struct ccs_query {
2033          unsigned int serial;          unsigned int serial;
2034          int timer;          int timer;
2035          int answer;          int answer;
2036            u8 retry;
2037  };  };
2038    
2039  /* The list for "struct ccs_query". */  /* The list for "struct ccs_query". */
2040  static LIST_HEAD(ccs_query_list);  static LIST_HEAD(ccs_query_list);
2041    
2042    /* Lock for manipulating ccs_query_list. */
2043    static DEFINE_SPINLOCK(ccs_query_list_lock);
2044    
2045  /* Number of "struct file" referring /proc/ccs/query interface. */  /* Number of "struct file" referring /proc/ccs/query interface. */
2046  static atomic_t ccs_query_observers = ATOMIC_INIT(0);  static atomic_t ccs_query_observers = ATOMIC_INIT(0);
2047    
2048  static void ccs_truncate(char *str)  /**
2049     * ccs_truncate - Truncate a line.
2050     *
2051     * @str: String to truncate.
2052     *
2053     * Returns length of truncated @str.
2054     */
2055    static int ccs_truncate(char *str)
2056  {  {
2057          while (* (unsigned char *) str > (unsigned char) ' ')          char *start = str;
2058            while (*(unsigned char *) str > (unsigned char) ' ')
2059                  str++;                  str++;
2060          *str = '\0';          *str = '\0';
2061            return strlen(start) + 1;
2062    }
2063    
2064    /**
2065     * ccs_add_entry - Add an ACL to current thread's domain. Used by learning mode.
2066     *
2067     * @header: Lines containing ACL.
2068     *
2069     * Returns nothing.
2070     */
2071    static void ccs_add_entry(char *header)
2072    {
2073            char *buffer;
2074            char *realpath = NULL;
2075            char *argv0 = NULL;
2076            char *symlink = NULL;
2077            char *handler;
2078            char *cp = strchr(header, '\n');
2079            int len;
2080            if (!cp)
2081                    return;
2082            cp = strchr(cp + 1, '\n');
2083            if (!cp)
2084                    return;
2085            *cp++ = '\0';
2086            len = strlen(cp) + 1;
2087            /* strstr() will return NULL if ordering is wrong. */
2088            if (*cp == 'f') {
2089                    argv0 = strstr(header, " argv[]={ \"");
2090                    if (argv0) {
2091                            argv0 += 10;
2092                            len += ccs_truncate(argv0) + 14;
2093                    }
2094                    realpath = strstr(header, " exec={ realpath=\"");
2095                    if (realpath) {
2096                            realpath += 8;
2097                            len += ccs_truncate(realpath) + 6;
2098                    }
2099                    symlink = strstr(header, " symlink.target=\"");
2100                    if (symlink)
2101                            len += ccs_truncate(symlink + 1) + 1;
2102            }
2103            handler = strstr(header, "type=execute_handler");
2104            if (handler)
2105                    len += ccs_truncate(handler) + 6;
2106            buffer = kmalloc(len, CCS_GFP_FLAGS);
2107            if (!buffer)
2108                    return;
2109            snprintf(buffer, len - 1, "%s", cp);
2110            if (handler)
2111                    ccs_addprintf(buffer, len, " task.%s", handler);
2112            if (realpath)
2113                    ccs_addprintf(buffer, len, " exec.%s", realpath);
2114            if (argv0)
2115                    ccs_addprintf(buffer, len, " exec.argv[0]=%s", argv0);
2116            if (symlink)
2117                    ccs_addprintf(buffer, len, "%s", symlink);
2118            ccs_normalize_line(buffer);
2119            if (!ccs_write_domain2(buffer, ccs_current_domain(), false))
2120                    ccs_update_stat(CCS_STAT_POLICY_UPDATES);
2121            kfree(buffer);
2122  }  }
2123    
2124  /**  /**
# Line 1953  static void ccs_truncate(char *str) Line 2135  static void ccs_truncate(char *str)
2135  int ccs_supervisor(struct ccs_request_info *r, const char *fmt, ...)  int ccs_supervisor(struct ccs_request_info *r, const char *fmt, ...)
2136  {  {
2137          va_list args;          va_list args;
2138          int error = -EPERM;          int error;
         int pos;  
2139          int len;          int len;
2140          static unsigned int ccs_serial;          static unsigned int ccs_serial;
2141          struct ccs_query *entry = NULL;          struct ccs_query entry = { };
2142          bool quota_exceeded = false;          bool quota_exceeded = false;
         char *header;  
         struct ccs_domain_info * const domain = ccs_current_domain();  
2143          va_start(args, fmt);          va_start(args, fmt);
2144          len = vsnprintf((char *) &pos, sizeof(pos) - 1, fmt, args) + 80;          len = vsnprintf((char *) &len, 1, fmt, args) + 1;
2145          va_end(args);          va_end(args);
2146          if (r->mode == CCS_CONFIG_LEARNING) {          /* Write /proc/ccs/audit. */
2147                  char *buffer;          va_start(args, fmt);
2148                  char *realpath = NULL;          ccs_write_log2(r, len, fmt, args);
2149                  char *argv0 = NULL;          va_end(args);
2150                  char *symlink = NULL;          /* Nothing more to do if granted. */
2151                  char *handler = NULL;          if (r->granted)
                 const struct ccs_preference *pref;  
                 if (!ccs_domain_quota_ok(r))  
                         return 0;  
                 header = ccs_init_log(&len, r);  
                 if (!header)  
                         return 0;  
                 pref = ccs_profile(r->profile)->learning;  
                 /* strstr() will return NULL if ordering is wrong. */  
                 if (r->param_type == CCS_TYPE_PATH_ACL &&  
                     r->param.path.operation == CCS_TYPE_EXECUTE) {  
                         if (pref->learning_exec_argv0) {  
                                 argv0 = strstr(header, " argv[]={ \"");  
                                 if (argv0) {  
                                         argv0 += 10;  
                                         ccs_truncate(argv0);  
                                 }  
                         }  
                         if (pref->learning_exec_realpath) {  
                                 realpath = strstr(header,  
                                                   " exec={ realpath=\"");  
                                 if (realpath) {  
                                         realpath += 8;  
                                         ccs_truncate(realpath);  
                                 }  
                         }  
                 } else if (r->param_type == CCS_TYPE_PATH_ACL &&  
                            r->param.path.operation == CCS_TYPE_SYMLINK &&  
                            pref->learning_symlink_target) {  
                         symlink = strstr(header, " symlink.target=\"");  
                         if (symlink)  
                                 ccs_truncate(symlink + 1);  
                 }  
                 handler = strstr(header, "type=execute_handler");  
                 if (handler)  
                         ccs_truncate(handler);  
                 buffer = kmalloc(len, CCS_GFP_FLAGS);  
                 if (buffer) {  
                         va_start(args, fmt);  
                         vsnprintf(buffer, len - 1, fmt, args);  
                         va_end(args);  
                         if (handler || realpath || argv0 || symlink) {  
                                 ccs_addprintf(buffer, len, " if");  
                                 if (handler)  
                                         ccs_addprintf(buffer, len, " task.%s",  
                                                       handler);  
                                 if (realpath)  
                                         ccs_addprintf(buffer, len, " exec.%s",  
                                                       realpath);  
                                 if (argv0)  
                                         ccs_addprintf(buffer, len,  
                                                       " exec.argv[0]=%s",  
                                                       argv0);  
                                 if (symlink)  
                                         ccs_addprintf(buffer, len, "%s",  
                                                       symlink);  
                         }  
                         ccs_normalize_line(buffer);  
                         ccs_write_domain2(buffer, domain, false);  
                         kfree(buffer);  
                 }  
                 kfree(header);  
                 return 0;  
         }  
         if (r->mode != CCS_CONFIG_ENFORCING)  
2152                  return 0;                  return 0;
2153          if (!atomic_read(&ccs_query_observers)) {          if (r->mode)
2154                    ccs_update_stat(r->mode);
2155            switch (r->mode) {
2156                  int i;                  int i;
2157                  if (current->ccs_flags & CCS_DONT_SLEEP_ON_ENFORCE_ERROR)                  struct ccs_profile *p;
2158                          return -EPERM;          case CCS_CONFIG_ENFORCING:
2159                  for (i = 0; i < ccs_profile(domain->profile)->enforcing->                  error = -EPERM;
2160                               enforcing_penalty; i++) {                  if (atomic_read(&ccs_query_observers))
2161                            break;
2162                    if (r->dont_sleep_on_enforce_error)
2163                            goto out;
2164                    p = ccs_profile(r->profile);
2165                    /* Check enforcing_penalty parameter. */
2166                    for (i = 0; i < p->pref[CCS_PREF_ENFORCING_PENALTY]; i++) {
2167                          set_current_state(TASK_INTERRUPTIBLE);                          set_current_state(TASK_INTERRUPTIBLE);
2168                          schedule_timeout(HZ / 10);                          schedule_timeout(HZ / 10);
2169                  }                  }
                 return -EPERM;  
         }  
         header = ccs_init_log(&len, r);  
         if (!header)  
2170                  goto out;                  goto out;
2171          entry = kzalloc(sizeof(*entry), CCS_GFP_FLAGS);          case CCS_CONFIG_LEARNING:
2172          if (!entry)                  error = 0;
2173                    /* Check mac_learning_entry parameter. */
2174                    if (ccs_domain_quota_ok(r))
2175                            break;
2176                    /* fall through */
2177            default:
2178                    return 0;
2179            }
2180            /* Get message. */
2181            va_start(args, fmt);
2182            entry.query = ccs_init_log(r, len, fmt, args);
2183            va_end(args);
2184            if (!entry.query)
2185                  goto out;                  goto out;
2186          len = ccs_round2(len);          entry.query_len = strlen(entry.query) + 1;
2187          entry->query = kzalloc(len, CCS_GFP_FLAGS);          if (!error) {
2188          if (!entry->query)                  ccs_add_entry(entry.query);
2189                  goto out;                  goto out;
2190            }
2191            len = ccs_round2(entry.query_len);
2192          spin_lock(&ccs_query_list_lock);          spin_lock(&ccs_query_list_lock);
2193          if (ccs_quota_for_query && ccs_query_memory_size + len +          if (ccs_memory_quota[CCS_MEMORY_QUERY] &&
2194              sizeof(*entry) >= ccs_quota_for_query) {              ccs_memory_used[CCS_MEMORY_QUERY] + len
2195                >= ccs_memory_quota[CCS_MEMORY_QUERY]) {
2196                  quota_exceeded = true;                  quota_exceeded = true;
2197          } else {          } else {
2198                  ccs_query_memory_size += len + sizeof(*entry);                  entry.serial = ccs_serial++;
2199                  entry->serial = ccs_serial++;                  entry.retry = r->retry;
2200                    ccs_memory_used[CCS_MEMORY_QUERY] += len;
2201                    list_add_tail(&entry.list, &ccs_query_list);
2202          }          }
2203          spin_unlock(&ccs_query_list_lock);          spin_unlock(&ccs_query_list_lock);
2204          if (quota_exceeded)          if (quota_exceeded)
2205                  goto out;                  goto out;
         pos = snprintf(entry->query, len - 1, "Q%u-%hu\n%s",  
                        entry->serial, r->retry, header);  
         kfree(header);  
         header = NULL;  
         va_start(args, fmt);  
         vsnprintf(entry->query + pos, len - 1 - pos, fmt, args);  
         entry->query_len = strlen(entry->query) + 1;  
         va_end(args);  
         spin_lock(&ccs_query_list_lock);  
         list_add_tail(&entry->list, &ccs_query_list);  
         spin_unlock(&ccs_query_list_lock);  
2206          /* Give 10 seconds for supervisor's opinion. */          /* Give 10 seconds for supervisor's opinion. */
2207          for (entry->timer = 0;          while (entry.timer < 10) {
2208               atomic_read(&ccs_query_observers) && entry->timer < 100;                  wake_up_all(&ccs_query_wait);
2209               entry->timer++) {                  if (wait_event_interruptible_timeout
2210                  wake_up(&ccs_query_wait);                      (ccs_answer_wait, entry.answer ||
2211                  set_current_state(TASK_INTERRUPTIBLE);                       !atomic_read(&ccs_query_observers), HZ))
                 schedule_timeout(HZ / 10);  
                 if (entry->answer)  
2212                          break;                          break;
2213                    else
2214                            entry.timer++;
2215          }          }
2216          spin_lock(&ccs_query_list_lock);          spin_lock(&ccs_query_list_lock);
2217          list_del(&entry->list);          list_del(&entry.list);
2218          ccs_query_memory_size -= len + sizeof(*entry);          ccs_memory_used[CCS_MEMORY_QUERY] -= len;
2219          spin_unlock(&ccs_query_list_lock);          spin_unlock(&ccs_query_list_lock);
2220          switch (entry->answer) {          switch (entry.answer) {
2221          case 3: /* Asked to retry by administrator. */          case 3: /* Asked to retry by administrator. */
2222                  error = CCS_RETRY_REQUEST;                  error = CCS_RETRY_REQUEST;
2223                  r->retry++;                  r->retry++;
# Line 2101  int ccs_supervisor(struct ccs_request_in Line 2226  int ccs_supervisor(struct ccs_request_in
2226                  /* Granted by administrator. */                  /* Granted by administrator. */
2227                  error = 0;                  error = 0;
2228                  break;                  break;
         case 0:  
                 /* Timed out. */  
                 break;  
2229          default:          default:
2230                  /* Rejected by administrator. */                  /* Timed out or rejected by administrator. */
2231                  break;                  break;
2232          }          }
2233   out:  out:
2234          if (entry)          kfree(entry.query);
                 kfree(entry->query);  
         kfree(entry);  
         kfree(header);  
2235          return error;          return error;
2236  }  }
2237    
# Line 2155  static int ccs_poll_query(struct file *f Line 2274  static int ccs_poll_query(struct file *f
2274   * ccs_read_query - Read access requests which violated policy in enforcing mode.   * ccs_read_query - Read access requests which violated policy in enforcing mode.
2275   *   *
2276   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
2277     *
2278     * Returns nothing.
2279   */   */
2280  static void ccs_read_query(struct ccs_io_buffer *head)  static void ccs_read_query(struct ccs_io_buffer *head)
2281  {  {
# Line 2164  static void ccs_read_query(struct ccs_io Line 2285  static void ccs_read_query(struct ccs_io
2285          char *buf;          char *buf;
2286          if (head->r.w_pos)          if (head->r.w_pos)
2287                  return;                  return;
2288          if (head->read_buf) {          kfree(head->read_buf);
2289                  kfree(head->read_buf);          head->read_buf = NULL;
                 head->read_buf = NULL;  
         }  
2290          spin_lock(&ccs_query_list_lock);          spin_lock(&ccs_query_list_lock);
2291          list_for_each(tmp, &ccs_query_list) {          list_for_each(tmp, &ccs_query_list) {
2292                  struct ccs_query *ptr = list_entry(tmp, typeof(*ptr), list);                  struct ccs_query *ptr = list_entry(tmp, typeof(*ptr), list);
# Line 2183  static void ccs_read_query(struct ccs_io Line 2302  static void ccs_read_query(struct ccs_io
2302                  head->r.query_index = 0;                  head->r.query_index = 0;
2303                  return;                  return;
2304          }          }
2305          buf = kzalloc(len, CCS_GFP_FLAGS);          buf = kzalloc(len + 32, CCS_GFP_FLAGS);
2306          if (!buf)          if (!buf)
2307                  return;                  return;
2308          pos = 0;          pos = 0;
# Line 2199  static void ccs_read_query(struct ccs_io Line 2318  static void ccs_read_query(struct ccs_io
2318                   * can change, but I don't care.                   * can change, but I don't care.
2319                   */                   */
2320                  if (len == ptr->query_len)                  if (len == ptr->query_len)
2321                          memmove(buf, ptr->query, len);                          snprintf(buf, len + 32, "Q%u-%hu\n%s", ptr->serial,
2322                                     ptr->retry, ptr->query);
2323                  break;                  break;
2324          }          }
2325          spin_unlock(&ccs_query_list_lock);          spin_unlock(&ccs_query_list_lock);
# Line 2243  static int ccs_write_answer(struct ccs_i Line 2363  static int ccs_write_answer(struct ccs_i
2363                  break;                  break;
2364          }          }
2365          spin_unlock(&ccs_query_list_lock);          spin_unlock(&ccs_query_list_lock);
2366            wake_up_all(&ccs_answer_wait);
2367          return 0;          return 0;
2368  }  }
2369    
2370  /**  /**
2371   * ccs_read_version: Get version.   * ccs_read_version - Get version.
2372   *   *
2373   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
2374     *
2375     * Returns nothing.
2376   */   */
2377  static void ccs_read_version(struct ccs_io_buffer *head)  static void ccs_read_version(struct ccs_io_buffer *head)
2378  {  {
2379          if (head->r.eof)          if (head->r.eof)
2380                  return;                  return;
2381          ccs_set_string(head, "1.7.2");          ccs_set_string(head, "1.8.0");
2382          head->r.eof = true;          head->r.eof = true;
2383  }  }
2384    
2385    /* String table for /proc/ccs/meminfo interface. */
2386    static const char * const ccs_policy_headers[CCS_MAX_POLICY_STAT] = {
2387            [CCS_STAT_POLICY_UPDATES]    = "update:",
2388            [CCS_STAT_POLICY_LEARNING]   = "violation in learning mode:",
2389            [CCS_STAT_POLICY_PERMISSIVE] = "violation in permissive mode:",
2390            [CCS_STAT_POLICY_ENFORCING]  = "violation in enforcing mode:",
2391    };
2392    
2393    /* String table for /proc/ccs/meminfo interface. */
2394    static const char * const ccs_memory_headers[CCS_MAX_MEMORY_STAT] = {
2395            [CCS_MEMORY_POLICY] = "policy:",
2396            [CCS_MEMORY_AUDIT]  = "audit log:",
2397            [CCS_MEMORY_QUERY]  = "query message:",
2398    };
2399    
2400    /* Timestamp counter for last updated. */
2401    static unsigned int ccs_stat_updated[CCS_MAX_POLICY_STAT];
2402    /* Counter for number of updates. */
2403    static unsigned int ccs_stat_modified[CCS_MAX_POLICY_STAT];
2404    
2405    /**
2406     * ccs_update_stat - Update statistic counters.
2407     *
2408     * @index: Index for policy type.
2409     *
2410     * Returns nothing.
2411     */
2412    void ccs_update_stat(const u8 index)
2413    {
2414            struct timeval tv;
2415            do_gettimeofday(&tv);
2416            /*
2417             * I don't use atomic operations because race condition is not fatal.
2418             */
2419            ccs_stat_updated[index]++;
2420            ccs_stat_modified[index] = tv.tv_sec;
2421    }
2422    
2423  /**  /**
2424   * ccs_read_self_domain - Get the current process's domainname.   * ccs_read_stat - Read statistic data.
2425   *   *
2426   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
2427     *
2428     * Returns nothing.
2429   */   */
2430  static void ccs_read_self_domain(struct ccs_io_buffer *head)  static void ccs_read_stat(struct ccs_io_buffer *head)
2431  {  {
2432            u8 i;
2433            unsigned int total = 0;
2434          if (head->r.eof)          if (head->r.eof)
2435                  return;                  return;
2436          /*          for (i = 0; i < CCS_MAX_POLICY_STAT; i++) {
2437           * ccs_current_domain()->domainname != NULL because every process                  ccs_io_printf(head, "Policy %-30s %10u", ccs_policy_headers[i],
2438           * belongs to a domain and the domain's name cannot be NULL.                                ccs_stat_updated[i]);
2439           */                  if (ccs_stat_modified[i]) {
2440          ccs_io_printf(head, "%s", ccs_current_domain()->domainname->name);                          struct ccs_time stamp;
2441                            ccs_convert_time(ccs_stat_modified[i], &stamp);
2442                            ccs_io_printf(head, " (Last: %04u/%02u/%02u "
2443                                          "%02u:%02u:%02u)",
2444                                          stamp.year, stamp.month, stamp.day,
2445                                          stamp.hour, stamp.min, stamp.sec);
2446                    }
2447                    ccs_set_lf(head);
2448            }
2449            for (i = 0; i < CCS_MAX_MEMORY_STAT; i++) {
2450                    unsigned int used = ccs_memory_used[i];
2451                    total += used;
2452                    ccs_io_printf(head, "Memory used by %-22s %10u",
2453                                  ccs_memory_headers[i], used);
2454                    used = ccs_memory_quota[i];
2455                    if (used)
2456                            ccs_io_printf(head, " (Quota: %10u)", used);
2457                    ccs_set_lf(head);
2458            }
2459            ccs_io_printf(head, "Total memory used:                    %10u\n",
2460                          total);
2461          head->r.eof = true;          head->r.eof = true;
2462  }  }
2463    
2464  /**  /**
2465     * ccs_write_stat - Set memory quota.
2466     *
2467     * @head: Pointer to "struct ccs_io_buffer".
2468     *
2469     * Returns 0.
2470     */
2471    static int ccs_write_stat(struct ccs_io_buffer *head)
2472    {
2473            char *data = head->write_buf;
2474            u8 i;
2475            if (ccs_str_starts(&data, "Memory used by "))
2476                    for (i = 0; i < CCS_MAX_MEMORY_STAT; i++)
2477                            if (ccs_str_starts(&data, ccs_memory_headers[i]))
2478                                    sscanf(data, "%u", &ccs_memory_quota[i]);
2479            return 0;
2480    }
2481    
2482    /* String table for /proc/ccs/meminfo interface. */
2483    static const char * const ccs_old_memory_header[CCS_MAX_MEMORY_STAT] = {
2484            [CCS_MEMORY_POLICY] = "Policy:",
2485            [CCS_MEMORY_AUDIT]  = "Audit logs:",
2486            [CCS_MEMORY_QUERY]  = "Query lists:",
2487    };
2488    
2489    /**
2490     * ccs_read_memory_counter - Read memory usage.
2491     *
2492     * @head: Pointer to "struct ccs_io_buffer".
2493     *
2494     * Returns nothing.
2495     */
2496    static void ccs_read_memory_counter(struct ccs_io_buffer *head)
2497    {
2498            unsigned int total = 0;
2499            int i;
2500            if (head->r.eof)
2501                    return;
2502            for (i = 0; i < CCS_MAX_MEMORY_STAT; i++) {
2503                    unsigned int used = ccs_memory_used[i];
2504                    total += used;
2505                    ccs_io_printf(head, "%-12s %10u", ccs_old_memory_header[i],
2506                                  used);
2507                    if (ccs_memory_quota[i])
2508                            ccs_io_printf(head, "   (Quota: %10u)",
2509                                          ccs_memory_quota[i]);
2510                    ccs_io_printf(head, "\n");
2511            }
2512            ccs_io_printf(head, "%-12s %10u\n", "Total:", total);
2513            head->r.eof = true;
2514    }
2515    
2516    /**
2517     * ccs_write_memory_quota - Set memory quota.
2518     *
2519     * @head: Pointer to "struct ccs_io_buffer".
2520     *
2521     * Returns 0.
2522     */
2523    static int ccs_write_memory_quota(struct ccs_io_buffer *head)
2524    {
2525            char *data = head->write_buf;
2526            u8 i;
2527            for (i = 0; i < CCS_MAX_MEMORY_STAT; i++)
2528                    if (ccs_str_starts(&data, ccs_old_memory_header[i]))
2529                            sscanf(data, "%u", &ccs_memory_quota[i]);
2530            return 0;
2531    }
2532    
2533    /**
2534   * ccs_open_control - open() for /proc/ccs/ interface.   * ccs_open_control - open() for /proc/ccs/ interface.
2535   *   *
2536   * @type: Type of interface.   * @type: Type of interface.
2537   * @file: Pointer to "struct file".   * @file: Pointer to "struct file".
2538   *   *
2539   * Associates policy handler and returns 0 on success, -ENOMEM otherwise.   * Returns 0 on success, negative value otherwise.
2540   */   */
2541  int ccs_open_control(const u8 type, struct file *file)  int ccs_open_control(const u8 type, struct file *file)
2542  {  {
# Line 2300  int ccs_open_control(const u8 type, stru Line 2554  int ccs_open_control(const u8 type, stru
2554                  head->write = ccs_write_exception;                  head->write = ccs_write_exception;
2555                  head->read = ccs_read_exception;                  head->read = ccs_read_exception;
2556                  break;                  break;
2557  #ifdef CONFIG_CCSECURITY_AUDIT          case CCS_AUDIT: /* /proc/ccs/audit */
         case CCS_GRANTLOG: /* /proc/ccs/grant_log */  
         case CCS_REJECTLOG: /* /proc/ccs/reject_log */  
2558                  head->poll = ccs_poll_log;                  head->poll = ccs_poll_log;
2559                  head->read = ccs_read_log;                  head->read = ccs_read_log;
2560                  break;                  break;
 #endif  
         case CCS_SELFDOMAIN: /* /proc/ccs/self_domain */  
                 head->read = ccs_read_self_domain;  
                 break;  
2561          case CCS_DOMAIN_STATUS: /* /proc/ccs/.domain_status */          case CCS_DOMAIN_STATUS: /* /proc/ccs/.domain_status */
2562                  head->write = ccs_write_domain_profile;                  head->write = ccs_write_domain_profile;
2563                  head->read = ccs_read_domain_profile;                  head->read = ccs_read_domain_profile;
2564                  break;                  break;
2565          case CCS_EXECUTE_HANDLER: /* /proc/ccs/.execute_handler */          case CCS_EXECUTE_HANDLER: /* /proc/ccs/.execute_handler */
2566                  /* Allow execute_handler to read process's status. */                  /* Allow execute_handler to read process's status. */
2567                  if (!(current->ccs_flags & CCS_TASK_IS_EXECUTE_HANDLER)) {                  if (!(ccs_current_flags() & CCS_TASK_IS_EXECUTE_HANDLER)) {
2568                          kfree(head);                          kfree(head);
2569                          return -EPERM;                          return -EPERM;
2570                  }                  }
# Line 2329  int ccs_open_control(const u8 type, stru Line 2577  int ccs_open_control(const u8 type, stru
2577                  head->read = ccs_read_version;                  head->read = ccs_read_version;
2578                  head->readbuf_size = 128;                  head->readbuf_size = 128;
2579                  break;                  break;
2580            case CCS_STAT: /* /proc/ccs/stat */
2581                    head->write = ccs_write_stat;
2582                    head->read = ccs_read_stat;
2583                    head->readbuf_size = 1024;
2584                    break;
2585          case CCS_MEMINFO: /* /proc/ccs/meminfo */          case CCS_MEMINFO: /* /proc/ccs/meminfo */
2586                  head->write = ccs_write_memory_quota;                  head->write = ccs_write_memory_quota;
2587                  head->read = ccs_read_memory_counter;                  head->read = ccs_read_memory_counter;
# Line 2380  int ccs_open_control(const u8 type, stru Line 2633  int ccs_open_control(const u8 type, stru
2633                          return -ENOMEM;                          return -ENOMEM;
2634                  }                  }
2635          }          }
         if (type != CCS_QUERY &&  
             type != CCS_GRANTLOG && type != CCS_REJECTLOG)  
                 head->reader_idx = ccs_lock();  
         file->private_data = head;  
2636          /*          /*
2637           * Call the handler now if the file is /proc/ccs/self_domain           * If the file is /proc/ccs/query, increment the observer counter.
          * so that the user can use "cat < /proc/ccs/self_domain" to  
          * know the current process's domainname.  
          */  
         if (type == CCS_SELFDOMAIN)  
                 ccs_read_control(file, NULL, 0);  
         /*  
          * If the file is /proc/ccs/query , increment the observer counter.  
2638           * The obserber counter is used by ccs_supervisor() to see if           * The obserber counter is used by ccs_supervisor() to see if
2639           * there is some process monitoring /proc/ccs/query.           * there is some process monitoring /proc/ccs/query.
2640           */           */
2641          else if (type == CCS_QUERY)          if (type == CCS_QUERY)
2642                  atomic_inc(&ccs_query_observers);                  atomic_inc(&ccs_query_observers);
2643            else if (type != CCS_AUDIT && type != CCS_VERSION &&
2644                     type != CCS_MEMINFO && type != CCS_STAT)
2645                    head->reader_idx = ccs_lock();
2646            file->private_data = head;
2647          return 0;          return 0;
2648  }  }
2649    
# Line 2407  int ccs_open_control(const u8 type, stru Line 2653  int ccs_open_control(const u8 type, stru
2653   * @file: Pointer to "struct file".   * @file: Pointer to "struct file".
2654   * @wait: Pointer to "poll_table".   * @wait: Pointer to "poll_table".
2655   *   *
2656     * Returns return value of poll().
2657     *
2658   * Waits for read readiness.   * Waits for read readiness.
2659   * /proc/ccs/query is handled by /usr/sbin/ccs-queryd and   * /proc/ccs/query is handled by /usr/sbin/ccs-queryd and
2660   * /proc/ccs/grant_log and /proc/ccs/reject_log are handled by   * /proc/ccs/audit is handled by /usr/sbin/ccs-auditd.
  * /usr/sbin/ccs-auditd .  
2661   */   */
2662  int ccs_poll_control(struct file *file, poll_table *wait)  int ccs_poll_control(struct file *file, poll_table *wait)
2663  {  {
# Line 2513  int ccs_write_control(struct file *file, Line 2760  int ccs_write_control(struct file *file,
2760                  cp0[head->w.avail - 1] = '\0';                  cp0[head->w.avail - 1] = '\0';
2761                  head->w.avail = 0;                  head->w.avail = 0;
2762                  ccs_normalize_line(cp0);                  ccs_normalize_line(cp0);
2763                  head->write(head);                  if (head->write(head))
2764                            continue;
2765                    switch (head->type) {
2766                    case CCS_DOMAINPOLICY:
2767                    case CCS_EXCEPTIONPOLICY:
2768                    case CCS_DOMAIN_STATUS:
2769                    case CCS_MEMINFO:
2770                    case CCS_PROFILE:
2771                    case CCS_MANAGER:
2772                            ccs_update_stat(CCS_STAT_POLICY_UPDATES);
2773                    }
2774          }          }
2775          ccs_read_unlock(idx);          ccs_read_unlock(idx);
2776          mutex_unlock(&head->io_sem);          mutex_unlock(&head->io_sem);
# Line 2525  int ccs_write_control(struct file *file, Line 2782  int ccs_write_control(struct file *file,
2782   *   *
2783   * @file: Pointer to "struct file".   * @file: Pointer to "struct file".
2784   *   *
2785   * Releases memory and returns 0.   * Returns 0.
2786   */   */
2787  int ccs_close_control(struct file *file)  int ccs_close_control(struct file *file)
2788  {  {
# Line 2533  int ccs_close_control(struct file *file) Line 2790  int ccs_close_control(struct file *file)
2790          const bool is_write = head->write_buf != NULL;          const bool is_write = head->write_buf != NULL;
2791          const u8 type = head->type;          const u8 type = head->type;
2792          /*          /*
2793           * If the file is /proc/ccs/query , decrement the observer counter.           * If the file is /proc/ccs/query, decrement the observer counter.
2794           */           */
2795          if (type == CCS_QUERY)          if (type == CCS_QUERY) {
2796                  atomic_dec(&ccs_query_observers);                  if (atomic_dec_and_test(&ccs_query_observers))
2797          if (type != CCS_QUERY &&                          wake_up_all(&ccs_answer_wait);
2798              type != CCS_GRANTLOG && type != CCS_REJECTLOG)          } else if (type != CCS_AUDIT && type != CCS_VERSION &&
2799                       type != CCS_MEMINFO && type != CCS_STAT)
2800                  ccs_unlock(head->reader_idx);                  ccs_unlock(head->reader_idx);
2801          /* Release memory used for policy I/O. */          /* Release memory used for policy I/O. */
2802          kfree(head->read_buf);          kfree(head->read_buf);
# Line 2553  int ccs_close_control(struct file *file) Line 2811  int ccs_close_control(struct file *file)
2811          return 0;          return 0;
2812  }  }
2813    
2814    /**
2815     * ccs_policy_io_init - Register hooks for policy I/O.
2816     *
2817     * Returns nothing.
2818     */
2819  void __init ccs_policy_io_init(void)  void __init ccs_policy_io_init(void)
2820  {  {
2821          ccsecurity_ops.check_profile = ccs_check_profile;          ccsecurity_ops.check_profile = ccs_check_profile;
Legend:
Removed from v.3832  
changed lines
  Added in v.4280
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
サイト情報
ソフトウェアを探す
ソフトウェアを作る
コミュニティ
ヘルプ