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

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 2915 by kumaneko, Mon Aug 17 10:56:21 2009 UTC trunk/1.7.x/ccs-patch/security/ccsecurity/policy_io.c revision 3275 by kumaneko, Sun Dec 20 07:07:04 2009 UTC
# Line 3  Line 3 
3   *   *
4   * Copyright (C) 2005-2009  NTT DATA CORPORATION   * Copyright (C) 2005-2009  NTT DATA CORPORATION
5   *   *
6   * Version: 1.7.0-pre   2009/08/08   * Version: 1.7.1+   2009/12/20
7   *   *
8   * This file is applicable to both 2.4.30 and 2.6.11 and later.   * This file is applicable to both 2.4.30 and 2.6.11 and later.
9   * See README.ccs for ChangeLog.   * See README.ccs for ChangeLog.
# Line 12  Line 12 
12    
13  #include "internal.h"  #include "internal.h"
14    
15  /* Lock for protecting ccs_profile->comment  */  static struct ccs_profile ccs_default_profile = {
16  static DEFINE_SPINLOCK(ccs_profile_comment_lock);          .learning = &ccs_default_profile.preference,
17            .permissive = &ccs_default_profile.preference,
18  /* String table for functionality that takes 2 modes. */          .enforcing = &ccs_default_profile.preference,
19  static const char *ccs_mode_2[2] = {          .audit = &ccs_default_profile.preference,
20          "disabled", "enabled"  #ifdef CONFIG_CCSECURITY_AUDIT
21            .preference.audit_max_grant_log = CONFIG_CCSECURITY_MAX_GRANT_LOG,
22            .preference.audit_max_reject_log = CONFIG_CCSECURITY_MAX_REJECT_LOG,
23    #endif
24            .preference.audit_task_info = true,
25            .preference.audit_path_info = true,
26            .preference.enforcing_penalty = 0,
27            .preference.enforcing_verbose = true,
28            .preference.learning_max_entry = CONFIG_CCSECURITY_MAX_ACCEPT_ENTRY,
29            .preference.learning_verbose = false,
30            .preference.learning_exec_realpath = true,
31            .preference.learning_exec_argv0 = true,
32            .preference.learning_symlink_target = true,
33            .preference.permissive_verbose = true
34  };  };
35    
36  static const char *ccs_keyword_mode[4] = {  /* Profile version. Currently only 20090903 is defined. */
37          "MAC_MODE_DISABLED", "MAC_MODE_LEARNING",  static unsigned int ccs_profile_version;
         "MAC_MODE_PERMISSIVE", "MAC_MODE_ENFORCING"  
 };  
38    
39  static const char *ccs_keyword_capability_mode[4] = {  /* Profile table. Memory is allocated as needed. */
40          "MAC_MODE_CAPABILITY_DISABLED", "MAC_MODE_CAPABILITY_LEARNING",  static struct ccs_profile *ccs_profile_ptr[CCS_MAX_PROFILES];
         "MAC_MODE_CAPABILITY_PERMISSIVE", "MAC_MODE_CAPABILITY_ENFORCING"  
 };  
41    
42  static const char *ccs_mac_keywords[CCS_MAX_MAC_INDEX] = {  /* String table for functionality that takes 4 modes. */
43          [CCS_MAC_EXECUTE]    = "execute",  static const char *ccs_mode_4[4] = {
44          [CCS_MAC_OPEN]       = "open",          "disabled", "learning", "permissive", "enforcing"
         [CCS_MAC_CREATE]     = "create",  
         [CCS_MAC_UNLINK]     = "unlink",  
         [CCS_MAC_MKDIR]      = "mkdir",  
         [CCS_MAC_RMDIR]      = "rmdir",  
         [CCS_MAC_MKFIFO]     = "mkfifo",  
         [CCS_MAC_MKSOCK]     = "mksock",  
         [CCS_MAC_TRUNCATE]   = "truncate",  
         [CCS_MAC_SYMLINK]    = "symlink",  
         [CCS_MAC_REWRITE]    = "rewrite",  
         [CCS_MAC_MKBLOCK]    = "mkblock",  
         [CCS_MAC_MKCHAR]     = "mkchar",  
         [CCS_MAC_LINK]       = "link",  
         [CCS_MAC_RENAME]     = "rename",  
         [CCS_MAC_CHMOD]      = "chmod",  
         [CCS_MAC_CHOWN]      = "chown",  
         [CCS_MAC_CHGRP]      = "chgrp",  
         [CCS_MAC_IOCTL]      = "ioctl",  
         [CCS_MAC_CHROOT]     = "chroot",  
         [CCS_MAC_MOUNT]      = "mount",  
         [CCS_MAC_UMOUNT]     = "umount",  
         [CCS_MAC_PIVOT_ROOT] = "pivot_root",  
         [CCS_MAC_ENVIRON]    = "env",  
         [CCS_MAC_NETWORK]    = "network",  
         [CCS_MAC_SIGNAL]     = "signal"  
45  };  };
46    
47  /* Table for profile. */  /* String table for /proc/ccs/profile */
48  static struct {  static const char *ccs_mac_keywords[CCS_MAX_MAC_INDEX +
49          const char *keyword;                                      CCS_MAX_CAPABILITY_INDEX +
50          unsigned int current_value;                                      CCS_MAX_MAC_CATEGORY_INDEX] = {
51          const unsigned int max_value;          [CCS_MAC_FILE_EXECUTE]
52  } ccs_control_array[CCS_MAX_CONTROL_INDEX] = {          = "file::execute",
53          [CCS_AUTOLEARN_EXEC_REALPATH] = { "AUTOLEARN_EXEC_REALPATH", 0, 1 },          [CCS_MAC_FILE_OPEN]
54          [CCS_AUTOLEARN_EXEC_ARGV0] = { "AUTOLEARN_EXEC_ARGV0", 0, 1 },          = "file::open",
55          [CCS_RESTRICT_AUTOBIND]   = { "RESTRICT_AUTOBIND",   0, 1 },          [CCS_MAC_FILE_CREATE]
56          [CCS_MAX_ACCEPT_ENTRY]          = "file::create",
57          = { "MAX_ACCEPT_ENTRY", CONFIG_CCSECURITY_MAX_ACCEPT_ENTRY, INT_MAX },          [CCS_MAC_FILE_UNLINK]
58  #ifdef CONFIG_CCSECURITY_AUDIT          = "file::unlink",
59          [CCS_MAX_GRANT_LOG]          [CCS_MAC_FILE_MKDIR]
60          = { "MAX_GRANT_LOG", CONFIG_CCSECURITY_MAX_GRANT_LOG, INT_MAX },          = "file::mkdir",
61          [CCS_MAX_REJECT_LOG]          [CCS_MAC_FILE_RMDIR]
62          = { "MAX_REJECT_LOG", CONFIG_CCSECURITY_MAX_REJECT_LOG, INT_MAX },          = "file::rmdir",
63  #endif          [CCS_MAC_FILE_MKFIFO]
64          [CCS_VERBOSE]             = { "TOMOYO_VERBOSE",      1, 1 },          = "file::mkfifo",
65          [CCS_SLEEP_PERIOD]          [CCS_MAC_FILE_MKSOCK]
66          = { "SLEEP_PERIOD",        0, 3000 }, /* in 0.1 second */          = "file::mksock",
67            [CCS_MAC_FILE_TRUNCATE]
68            = "file::truncate",
69            [CCS_MAC_FILE_SYMLINK]
70            = "file::symlink",
71            [CCS_MAC_FILE_REWRITE]
72            = "file::rewrite",
73            [CCS_MAC_FILE_MKBLOCK]
74            = "file::mkblock",
75            [CCS_MAC_FILE_MKCHAR]
76            = "file::mkchar",
77            [CCS_MAC_FILE_LINK]
78            = "file::link",
79            [CCS_MAC_FILE_RENAME]
80            = "file::rename",
81            [CCS_MAC_FILE_CHMOD]
82            = "file::chmod",
83            [CCS_MAC_FILE_CHOWN]
84            = "file::chown",
85            [CCS_MAC_FILE_CHGRP]
86            = "file::chgrp",
87            [CCS_MAC_FILE_IOCTL]
88            = "file::ioctl",
89            [CCS_MAC_FILE_CHROOT]
90            = "file::chroot",
91            [CCS_MAC_FILE_MOUNT]
92            = "file::mount",
93            [CCS_MAC_FILE_UMOUNT]
94            = "file::umount",
95            [CCS_MAC_FILE_PIVOT_ROOT]
96            = "file::pivot_root",
97            [CCS_MAC_ENVIRON]
98            = "misc::env",
99            [CCS_MAC_NETWORK_UDP_BIND]
100            = "network::inet_udp_bind",
101            [CCS_MAC_NETWORK_UDP_CONNECT]
102            = "network::inet_udp_connect",
103            [CCS_MAC_NETWORK_TCP_BIND]
104            = "network::inet_tcp_bind",
105            [CCS_MAC_NETWORK_TCP_LISTEN]
106            = "network::inet_tcp_listen",
107            [CCS_MAC_NETWORK_TCP_CONNECT]
108            = "network::inet_tcp_connect",
109            [CCS_MAC_NETWORK_TCP_ACCEPT]
110            = "network::inet_tcp_accept",
111            [CCS_MAC_NETWORK_RAW_BIND]
112            = "network::inet_raw_bind",
113            [CCS_MAC_NETWORK_RAW_CONNECT]
114            = "network::inet_raw_connect",
115            [CCS_MAC_SIGNAL]
116            = "ipc::signal",
117            [CCS_MAX_MAC_INDEX + CCS_INET_STREAM_SOCKET_CREATE]
118            = "capability::inet_tcp_create",
119            [CCS_MAX_MAC_INDEX + CCS_INET_STREAM_SOCKET_LISTEN]
120            = "capability::inet_tcp_listen",
121            [CCS_MAX_MAC_INDEX + CCS_INET_STREAM_SOCKET_CONNECT]
122            = "capability::inet_tcp_connect",
123            [CCS_MAX_MAC_INDEX + CCS_USE_INET_DGRAM_SOCKET]
124            = "capability::use_inet_udp",
125            [CCS_MAX_MAC_INDEX + CCS_USE_INET_RAW_SOCKET]
126            = "capability::use_inet_ip",
127            [CCS_MAX_MAC_INDEX + CCS_USE_ROUTE_SOCKET]
128            = "capability::use_route",
129            [CCS_MAX_MAC_INDEX + CCS_USE_PACKET_SOCKET]
130            = "capability::use_packet",
131            [CCS_MAX_MAC_INDEX + CCS_SYS_MOUNT]
132            = "capability::SYS_MOUNT",
133            [CCS_MAX_MAC_INDEX + CCS_SYS_UMOUNT]
134            = "capability::SYS_UMOUNT",
135            [CCS_MAX_MAC_INDEX + CCS_SYS_REBOOT]
136            = "capability::SYS_REBOOT",
137            [CCS_MAX_MAC_INDEX + CCS_SYS_CHROOT]
138            = "capability::SYS_CHROOT",
139            [CCS_MAX_MAC_INDEX + CCS_SYS_KILL]
140            = "capability::SYS_KILL",
141            [CCS_MAX_MAC_INDEX + CCS_SYS_VHANGUP]
142            = "capability::SYS_VHANGUP",
143            [CCS_MAX_MAC_INDEX + CCS_SYS_SETTIME]
144            = "capability::SYS_TIME",
145            [CCS_MAX_MAC_INDEX + CCS_SYS_NICE]
146            = "capability::SYS_NICE",
147            [CCS_MAX_MAC_INDEX + CCS_SYS_SETHOSTNAME]
148            = "capability::SYS_SETHOSTNAME",
149            [CCS_MAX_MAC_INDEX + CCS_USE_KERNEL_MODULE]
150            = "capability::use_kernel_module",
151            [CCS_MAX_MAC_INDEX + CCS_CREATE_FIFO]
152            = "capability::create_fifo",
153            [CCS_MAX_MAC_INDEX + CCS_CREATE_BLOCK_DEV]
154            = "capability::create_block_dev",
155            [CCS_MAX_MAC_INDEX + CCS_CREATE_CHAR_DEV]
156            = "capability::create_char_dev",
157            [CCS_MAX_MAC_INDEX + CCS_CREATE_UNIX_SOCKET]
158            = "capability::create_unix_socket",
159            [CCS_MAX_MAC_INDEX + CCS_SYS_LINK]
160            = "capability::SYS_LINK",
161            [CCS_MAX_MAC_INDEX + CCS_SYS_SYMLINK]
162            = "capability::SYS_SYMLINK",
163            [CCS_MAX_MAC_INDEX + CCS_SYS_RENAME]
164            = "capability::SYS_RENAME",
165            [CCS_MAX_MAC_INDEX + CCS_SYS_UNLINK]
166            = "capability::SYS_UNLINK",
167            [CCS_MAX_MAC_INDEX + CCS_SYS_CHMOD]
168            = "capability::SYS_CHMOD",
169            [CCS_MAX_MAC_INDEX + CCS_SYS_CHOWN]
170            = "capability::SYS_CHOWN",
171            [CCS_MAX_MAC_INDEX + CCS_SYS_IOCTL]
172            = "capability::SYS_IOCTL",
173            [CCS_MAX_MAC_INDEX + CCS_SYS_KEXEC_LOAD]
174            = "capability::SYS_KEXEC_LOAD",
175            [CCS_MAX_MAC_INDEX + CCS_SYS_PIVOT_ROOT]
176            = "capability::SYS_PIVOT_ROOT",
177            [CCS_MAX_MAC_INDEX + CCS_SYS_PTRACE]
178            = "capability::SYS_PTRACE",
179            [CCS_MAX_MAC_INDEX + CCS_CONCEAL_MOUNT]
180            = "capability::conceal_mount",
181            [CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX
182             + CCS_MAC_CATEGORY_FILE] = "file",
183            [CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX
184             + CCS_MAC_CATEGORY_NETWORK] = "network",
185            [CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX
186             + CCS_MAC_CATEGORY_MISC] = "misc",
187            [CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX
188             + CCS_MAC_CATEGORY_IPC] = "ipc",
189            [CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX
190             + CCS_MAC_CATEGORY_CAPABILITY] = "capability",
191  };  };
192    
193  /* Permit policy management by non-root user? */  /* Permit policy management by non-root user? */
194  static bool ccs_manage_by_non_root;  static bool ccs_manage_by_non_root;
195    
196  /**  /**
197   * ccs_quiet_setup - Set CCS_VERBOSE=0 by default.   * ccs_cap2keyword - Convert capability operation to capability name.
198   *   *
199   * @str: Unused.   * @operation: The capability index.
200   *   *
201   * Returns 0.   * Returns the name of the specified capability's name.
202   */   */
203  static int __init ccs_quiet_setup(char *str)  const char *ccs_cap2keyword(const u8 operation)
204  {  {
205          ccs_control_array[CCS_VERBOSE].current_value = 0;          return operation < CCS_MAX_CAPABILITY_INDEX
206          return 0;                  ? ccs_mac_keywords[CCS_MAX_MAC_INDEX + operation] + 12 : NULL;
207  }  }
208    
209  __setup("CCS_QUIET", ccs_quiet_setup);  /**
210     * ccs_yesno - Return "yes" or "no".
211     *
212     * @value: Bool value.
213     */
214    static const char *ccs_yesno(const unsigned int value)
215    {
216            return value ? "yes" : "no";
217    }
218    
219  /**  /**
220   * ccs_io_printf - Transactional printf() to "struct ccs_io_buffer" structure.   * ccs_io_printf - Transactional printf() to "struct ccs_io_buffer" structure.
# Line 138  static struct ccs_profile *ccs_find_or_a Line 255  static struct ccs_profile *ccs_find_or_a
255  {  {
256          struct ccs_profile *ptr;          struct ccs_profile *ptr;
257          struct ccs_profile *entry;          struct ccs_profile *entry;
         int i;  
258          if (profile >= CCS_MAX_PROFILES)          if (profile >= CCS_MAX_PROFILES)
259                  return NULL;                  return NULL;
260          ptr = ccs_profile_ptr[profile];          ptr = ccs_profile_ptr[profile];
# Line 149  static struct ccs_profile *ccs_find_or_a Line 265  static struct ccs_profile *ccs_find_or_a
265          ptr = ccs_profile_ptr[profile];          ptr = ccs_profile_ptr[profile];
266          if (!ptr && ccs_memory_ok(entry, sizeof(*entry))) {          if (!ptr && ccs_memory_ok(entry, sizeof(*entry))) {
267                  ptr = entry;                  ptr = entry;
268                  for (i = 0; i < CCS_MAX_CONTROL_INDEX; i++)                  ptr->audit = &ccs_default_profile.preference;
269                          ptr->value[i] = ccs_control_array[i].current_value;                  ptr->learning = &ccs_default_profile.preference;
270                    ptr->permissive = &ccs_default_profile.preference;
271                    ptr->enforcing = &ccs_default_profile.preference;
272                    ptr->default_config = CCS_CONFIG_DISABLED |
273                            CCS_CONFIG_WANT_GRANT_LOG | CCS_CONFIG_WANT_REJECT_LOG;
274                    memset(ptr->config, CCS_CONFIG_USE_DEFAULT,
275                           sizeof(ptr->config));
276                  mb(); /* Avoid out-of-order execution. */                  mb(); /* Avoid out-of-order execution. */
277                  ccs_profile_ptr[profile] = ptr;                  ccs_profile_ptr[profile] = ptr;
278                  entry = NULL;                  entry = NULL;
# Line 161  static struct ccs_profile *ccs_find_or_a Line 283  static struct ccs_profile *ccs_find_or_a
283  }  }
284    
285  /**  /**
286     * ccs_check_profile - Check all profiles currently assigned to domains are defined.
287     */
288    void ccs_check_profile(void)
289    {
290            struct ccs_domain_info *domain;
291            ccs_policy_loaded = true;
292            list_for_each_entry_rcu(domain, &ccs_domain_list, list) {
293                    const u8 profile = domain->profile;
294                    if (ccs_profile_ptr[profile])
295                            continue;
296                    panic("Profile %u (used by '%s') not defined.\n",
297                          profile, domain->domainname->name);
298            }
299            if (ccs_profile_version != 20090903)
300                    panic("Profile version %u is not supported.\n",
301                          ccs_profile_version);
302    }
303    
304    /**
305     * ccs_profile - Find a profile.
306     *
307     * @profile: Profile number to find.
308     *
309     * Returns pointer to "struct ccs_profile".
310     */
311    struct ccs_profile *ccs_profile(const u8 profile)
312    {
313            struct ccs_profile *ptr = ccs_profile_ptr[profile];
314            if (!ccs_policy_loaded)
315                    return &ccs_default_profile;
316            BUG_ON(!ptr);
317            return ptr;
318    }
319    
320    /**
321   * ccs_write_profile - Write profile table.   * ccs_write_profile - Write profile table.
322   *   *
323   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
# Line 171  static int ccs_write_profile(struct ccs_ Line 328  static int ccs_write_profile(struct ccs_
328  {  {
329          char *data = head->write_buf;          char *data = head->write_buf;
330          unsigned int i;          unsigned int i;
331          unsigned int value;          int value;
332          int mode;          int mode;
333            u8 config;
334            bool use_default = false;
335          char *cp;          char *cp;
336          struct ccs_profile *ccs_profile;          struct ccs_profile *profile;
337            if (sscanf(data, "PROFILE_VERSION=%u", &ccs_profile_version) == 1)
338                    return 0;
339          i = simple_strtoul(data, &cp, 10);          i = simple_strtoul(data, &cp, 10);
340          if (data != cp) {          if (data == cp) {
341                    profile = &ccs_default_profile;
342            } else {
343                  if (*cp != '-')                  if (*cp != '-')
344                          return -EINVAL;                          return -EINVAL;
345                  data = cp + 1;                  data = cp + 1;
346                    profile = ccs_find_or_assign_new_profile(i);
347                    if (!profile)
348                            return -EINVAL;
349          }          }
         ccs_profile = ccs_find_or_assign_new_profile(i);  
         if (!ccs_profile)  
                 return -EINVAL;  
350          cp = strchr(data, '=');          cp = strchr(data, '=');
351          if (!cp)          if (!cp)
352                  return -EINVAL;                  return -EINVAL;
353          *cp = '\0';          *cp++ = '\0';
354          if (!strcmp(data, "COMMENT")) {          if (profile != &ccs_default_profile)
355                  const struct ccs_path_info *new_comment                  use_default = strstr(cp, "use_default") != NULL;
356                          = ccs_get_name(cp + 1);          if (strstr(cp, "verbose=yes"))
357                  const struct ccs_path_info *old_comment;                  value = 1;
358                  /* Protect reader from ccs_put_name(). */          else if (strstr(cp, "verbose=no"))
359                  /***** CRITICAL SECTION START *****/                  value = 0;
360                  spin_lock(&ccs_profile_comment_lock);          else
361                  old_comment = ccs_profile->comment;                  value = -1;
362                  ccs_profile->comment = new_comment;          if (!strcmp(data, "PREFERENCE::audit")) {
363                  spin_unlock(&ccs_profile_comment_lock);  #ifdef CONFIG_CCSECURITY_AUDIT
364                  /***** CRITICAL SECTION END *****/                  char *cp2;
365                  ccs_put_name(old_comment);  #endif
366                    if (use_default) {
367                            profile->audit = &ccs_default_profile.preference;
368                            return 0;
369                    }
370                    profile->audit = &profile->preference;
371    #ifdef CONFIG_CCSECURITY_AUDIT
372                    cp2 = strstr(cp, "max_grant_log=");
373                    if (cp2)
374                            sscanf(cp2 + 14, "%u",
375                                   &profile->preference.audit_max_grant_log);
376                    cp2 = strstr(cp, "max_reject_log=");
377                    if (cp2)
378                            sscanf(cp2 + 15, "%u",
379                                   &profile->preference.audit_max_reject_log);
380    #endif
381                    if (strstr(cp, "task_info=yes"))
382                            profile->preference.audit_task_info = true;
383                    else if (strstr(cp, "task_info=no"))
384                            profile->preference.audit_task_info = false;
385                    if (strstr(cp, "path_info=yes"))
386                            profile->preference.audit_path_info = true;
387                    else if (strstr(cp, "path_info=no"))
388                            profile->preference.audit_path_info = false;
389                  return 0;                  return 0;
390          }          }
391          for (mode = 0; mode < 4; mode++) {          if (!strcmp(data, "PREFERENCE::enforcing")) {
392                  if (strcmp(data, ccs_keyword_mode[mode]))                  char *cp2;
393                          continue;                  if (use_default) {
394                  cp++;                          profile->enforcing = &ccs_default_profile.preference;
395                  while (1) {                          return 0;
                         char *cp2 = strchr(cp, ' ');  
                         if (cp2)  
                                 *cp2 = '\0';  
                         for (i = 0; i < CCS_MAX_MAC_INDEX; i++) {  
                                 if (strcmp(cp, ccs_mac_keywords[i]))  
                                         continue;  
                                 ccs_profile->mac_mode[i] = mode;  
                         }  
                         if (!cp2)  
                                 break;  
                         cp = cp2 + 1;  
396                  }                  }
397                    profile->enforcing = &profile->preference;
398                    if (value >= 0)
399                            profile->preference.enforcing_verbose = value;
400                    cp2 = strstr(cp, "penalty=");
401                    if (cp2)
402                            sscanf(cp2 + 8, "%u",
403                                   &profile->preference.enforcing_penalty);
404                  return 0;                  return 0;
405          }          }
406          for (mode = 0; mode < 4; mode++) {          if (!strcmp(data, "PREFERENCE::permissive")) {
407                  if (strcmp(data, ccs_keyword_capability_mode[mode]))                  if (use_default) {
408                          continue;                          profile->permissive = &ccs_default_profile.preference;
409                  cp++;                          return 0;
                 while (1) {  
                         char *cp2 = strchr(cp, ' ');  
                         if (cp2)  
                                 *cp2 = '\0';  
                         for (i = 0; i < CCS_MAX_CAPABILITY_INDEX; i++) {  
                                 if (strcmp(cp, ccs_capability_list[i]))  
                                         continue;  
                                 ccs_profile->mac_capability_mode[i] = mode;  
                         }  
                         if (!cp2)  
                                 break;  
                         cp = cp2 + 1;  
410                  }                  }
411                    profile->permissive = &profile->preference;
412                    if (value >= 0)
413                            profile->preference.permissive_verbose = value;
414                  return 0;                  return 0;
415          }          }
416          for (i = 0; i < CCS_MAX_CONTROL_INDEX; i++) {          if (!strcmp(data, "PREFERENCE::learning")) {
417                  if (strcmp(data, ccs_control_array[i].keyword))                  char *cp2;
418                          continue;                  if (use_default) {
419                  if (sscanf(cp + 1, "%u", &value) != 1) {                          profile->learning = &ccs_default_profile.preference;
420                          int j;                          return 0;
                         for (j = 0; j < 2; j++) {  
                                 if (strcmp(cp + 1, ccs_mode_2[j]))  
                                         continue;  
                                 value = j;  
                                 break;  
                         }  
                         if (j == 4)  
                                 return -EINVAL;  
                 } else if (value > ccs_control_array[i].max_value) {  
                         value = ccs_control_array[i].max_value;  
421                  }                  }
422                  ccs_profile->value[i] = value;                  profile->learning = &profile->preference;
423                    if (value >= 0)
424                            profile->preference.learning_verbose = value;
425                    cp2 = strstr(cp, "max_entry=");
426                    if (cp2)
427                            sscanf(cp2 + 10, "%u",
428                                   &profile->preference.learning_max_entry);
429                    if (strstr(cp, "exec.realpath=yes"))
430                            profile->preference.learning_exec_realpath = true;
431                    else if (strstr(cp, "exec.realpath=no"))
432                            profile->preference.learning_exec_realpath = false;
433                    if (strstr(cp, "exec.argv0=yes"))
434                            profile->preference.learning_exec_argv0 = true;
435                    else if (strstr(cp, "exec.argv0=no"))
436                            profile->preference.learning_exec_argv0 = false;
437                    if (strstr(cp, "symlink.target=yes"))
438                            profile->preference.learning_symlink_target = true;
439                    else if (strstr(cp, "symlink.target=no"))
440                            profile->preference.learning_symlink_target = false;
441                  return 0;                  return 0;
442          }          }
443          return -EINVAL;          if (profile == &ccs_default_profile)
444  }                  return -EINVAL;
445            if (!strcmp(data, "COMMENT")) {
446  static bool ccs_print_mac_mode(struct ccs_io_buffer *head, u8 index)                  const struct ccs_path_info *old_comment = profile->comment;
447  {                  profile->comment = ccs_get_name(cp);
448          const int pos = head->read_avail;                  ccs_put_name(old_comment);
449          int i;                  return 0;
450          int mode;          }
451          const struct ccs_profile *ccs_profile = ccs_profile_ptr[index];          if (!strcmp(data, "CONFIG")) {
452          for (mode = 0; mode < 4; mode++) {                  i = CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX
453                  if (!ccs_io_printf(head, "%u-%s={", index, ccs_keyword_mode[mode]))                          + CCS_MAX_MAC_CATEGORY_INDEX;
454                          goto out;                  config = profile->default_config;
455                  for (i = 0; i < CCS_MAX_MAC_INDEX; i++) {          } else if (ccs_str_starts(&data, "CONFIG::")) {
456                          if (ccs_profile->mac_mode[i] != mode)                  config = 0;
457                    for (i = 0; i < CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX
458                                 + CCS_MAX_MAC_CATEGORY_INDEX; i++) {
459                            if (strcmp(data, ccs_mac_keywords[i]))
460                                  continue;                                  continue;
461                          if (!ccs_io_printf(head, " %s", ccs_mac_keywords[i]))                          config = profile->config[i];
462                                  goto out;                          break;
463                  }                  }
464                  if (!ccs_io_printf(head, " }\n"))                  if (i == CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX
465                          goto out;                      + CCS_MAX_MAC_CATEGORY_INDEX)
466                            return -EINVAL;
467            } else {
468                    return -EINVAL;
469          }          }
470          return true;          if (use_default) {
471   out:                  config = CCS_CONFIG_USE_DEFAULT;
472          head->read_avail = pos;          } else {
473          return false;                  for (mode = 3; mode >= 0; mode--)
474  }                          if (strstr(cp, ccs_mode_4[mode]))
475                                    /*
476  static bool ccs_print_capability_mode(struct ccs_io_buffer *head, u8 index)                                   * Update lower 3 bits in order to distinguish
477  {                                   * 'config' from 'CCS_CONFIG_USE_DEAFULT'.
478          const int pos = head->read_avail;                                   */
479          int i;                                  config = (config & ~7) | mode;
480          int mode;  #ifdef CONFIG_CCSECURITY_AUDIT
481          const struct ccs_profile *ccs_profile = ccs_profile_ptr[index];                  if (config != CCS_CONFIG_USE_DEFAULT) {
482          for (mode = 0; mode < 4; mode++) {                          if (strstr(cp, "grant_log=yes"))
483                  if (!ccs_io_printf(head, "%u-%s={", index, ccs_keyword_capability_mode[mode]))                                  config |= CCS_CONFIG_WANT_GRANT_LOG;
484                          goto out;                          else if (strstr(cp, "grant_log=no"))
485                  for (i = 0; i < CCS_MAX_CAPABILITY_INDEX; i++) {                                  config &= ~CCS_CONFIG_WANT_GRANT_LOG;
486                          if (ccs_profile->mac_capability_mode[i] != mode)                          if (strstr(cp, "reject_log=yes"))
487                                  continue;                                  config |= CCS_CONFIG_WANT_REJECT_LOG;
488                          if (!ccs_io_printf(head, " %s", ccs_capability_list[i]))                          else if (strstr(cp, "reject_log=no"))
489                                  goto out;                                  config &= ~CCS_CONFIG_WANT_REJECT_LOG;
490                  }                  }
491                  if (!ccs_io_printf(head, " }\n"))  #endif
                         goto out;  
492          }          }
493          return true;          if (i < CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX
494   out:              + CCS_MAX_MAC_CATEGORY_INDEX)
495          head->read_avail = pos;                  profile->config[i] = config;
496          return false;          else if (config != CCS_CONFIG_USE_DEFAULT)
497                    profile->default_config = config;
498            return 0;
499  }  }
500    
501  /**  /**
502   * ccs_read_profile - Read profile table.   * ccs_read_profile - Read profile table.
503   *   *
504   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
  *  
  * Returns 0.  
505   */   */
506  static int ccs_read_profile(struct ccs_io_buffer *head)  static void ccs_read_profile(struct ccs_io_buffer *head)
507  {  {
508          static const int ccs_total = CCS_MAX_CONTROL_INDEX + 2;          int index;
         int step;  
509          if (head->read_eof)          if (head->read_eof)
510                  return 0;                  return;
511          for (step = head->read_step; step < CCS_MAX_PROFILES * ccs_total;          if (head->read_bit)
512               step++) {                  goto body;
513                  const u8 index = step / ccs_total;          ccs_io_printf(head, "PROFILE_VERSION=%s\n", "20090903");
514                  u8 type = step % ccs_total;          ccs_io_printf(head, "PREFERENCE::audit={ "
515                  const struct ccs_profile *ccs_profile = ccs_profile_ptr[index];  #ifdef CONFIG_CCSECURITY_AUDIT
516                  head->read_step = step;                        "max_grant_log=%u max_reject_log=%u "
517                  if (!ccs_profile)  #endif
518                          continue;                        "task_info=%s path_info=%s }\n",
519                  if (!type) { /* Print profile' comment tag. */  #ifdef CONFIG_CCSECURITY_AUDIT
520                          bool done;                        ccs_default_profile.preference.audit_max_grant_log,
521                          /***** CRITICAL SECTION START *****/                        ccs_default_profile.preference.audit_max_reject_log,
522                          spin_lock(&ccs_profile_comment_lock);  #endif
523                          done = ccs_io_printf(head, "%u-COMMENT=%s\n",                        ccs_yesno(ccs_default_profile.preference.
524                                               index, ccs_profile->comment ?                                  audit_task_info),
525                                               ccs_profile->comment->name : "");                        ccs_yesno(ccs_default_profile.preference.
526                          spin_unlock(&ccs_profile_comment_lock);                                  audit_path_info));
527                          /***** CRITICAL SECTION END *****/          ccs_io_printf(head, "PREFERENCE::learning={ verbose=%s max_entry=%u "
528                          if (!done)                        "exec.realpath=%s exec.argv0=%s symlink.target=%s }\n",
529                                  break;                        ccs_yesno(ccs_default_profile.preference.
530                          continue;                                  learning_verbose),
531                  } else if (type == 1) {                        ccs_default_profile.preference.learning_max_entry,
532                          if (!ccs_print_mac_mode(head, index))                        ccs_yesno(ccs_default_profile.preference.
533                                  break;                                  learning_exec_realpath),
534                          continue;                        ccs_yesno(ccs_default_profile.preference.
535                  } else if (type == 2) {                                  learning_exec_argv0),
536                          if (!ccs_print_capability_mode(head, index))                        ccs_yesno(ccs_default_profile.preference.
537                                  break;                                  learning_symlink_target));
538            ccs_io_printf(head, "PREFERENCE::permissive={ verbose=%s }\n",
539                          ccs_yesno(ccs_default_profile.preference.
540                                    permissive_verbose));
541            ccs_io_printf(head, "PREFERENCE::enforcing={ verbose=%s penalty=%u "
542                          "}\n",
543                          ccs_yesno(ccs_default_profile.preference.
544                                    enforcing_verbose),
545                          ccs_default_profile.preference.enforcing_penalty);
546            head->read_bit = 1;
547     body:
548            for (index = head->read_step; index < CCS_MAX_PROFILES; index++) {
549                    bool done;
550                    u8 config;
551                    int i;
552                    int pos;
553                    const struct ccs_profile *profile = ccs_profile_ptr[index];
554                    const struct ccs_path_info *comment;
555                    head->read_step = index;
556                    if (!profile)
557                          continue;                          continue;
558                    pos = head->read_avail;
559                    comment = profile->comment;
560                    done = ccs_io_printf(head, "%u-COMMENT=%s\n", index,
561                                         comment ? comment->name : "");
562                    if (!done)
563                            goto out;
564                    config = profile->default_config;
565    #ifdef CONFIG_CCSECURITY_AUDIT
566                    if (!ccs_io_printf(head, "%u-CONFIG={ mode=%s grant_log=%s "
567                                       "reject_log=%s }\n", index,
568                                       ccs_mode_4[config & 3],
569                                       ccs_yesno(config &
570                                                 CCS_CONFIG_WANT_GRANT_LOG),
571                                       ccs_yesno(config &
572                                                 CCS_CONFIG_WANT_REJECT_LOG)))
573                            goto out;
574    #else
575                    if (!ccs_io_printf(head, "%u-CONFIG={ mode=%s }\n", index,
576                                       ccs_mode_4[config & 3]))
577                            goto out;
578    #endif
579                    for (i = 0; i < CCS_MAX_MAC_INDEX + CCS_MAX_CAPABILITY_INDEX
580                                 + CCS_MAX_MAC_CATEGORY_INDEX; i++) {
581    #ifdef CONFIG_CCSECURITY_AUDIT
582                            const char *g;
583                            const char *r;
584    #endif
585                            config = profile->config[i];
586                            if (config == CCS_CONFIG_USE_DEFAULT)
587                                    continue;
588    #ifdef CONFIG_CCSECURITY_AUDIT
589                            g = ccs_yesno(config & CCS_CONFIG_WANT_GRANT_LOG);
590                            r = ccs_yesno(config & CCS_CONFIG_WANT_REJECT_LOG);
591                            if (!ccs_io_printf(head, "%u-CONFIG::%s={ mode=%s "
592                                               "grant_log=%s reject_log=%s }\n",
593                                               index, ccs_mac_keywords[i],
594                                               ccs_mode_4[config & 3], g, r))
595                                    goto out;
596    #else
597                            if (!ccs_io_printf(head, "%u-CONFIG::%s={ mode=%s }\n",
598                                               index, ccs_mac_keywords[i],
599                                               ccs_mode_4[config & 3]))
600                                    goto out;
601    #endif
602                  }                  }
603                  type -= 3;                  if (profile->audit != &ccs_default_profile.preference &&
604                  {                      !ccs_io_printf(head, "%u-PREFERENCE::audit={ "
605                          const unsigned int value = ccs_profile->value[type];  #ifdef CONFIG_CCSECURITY_AUDIT
606                          const char *keyword = ccs_control_array[type].keyword;                                     "max_grant_log=%u max_reject_log=%u "
607                          if (ccs_control_array[type].max_value == 1) {  #endif
608                                  if (!ccs_io_printf(head, "%u-%s=%s\n", index,                                     "task_info=%s path_info=%s }\n", index,
609                                                     keyword, ccs_mode_2[value]))  #ifdef CONFIG_CCSECURITY_AUDIT
610                                          break;                                     profile->preference.audit_max_grant_log,
611                          } else {                                     profile->preference.audit_max_reject_log,
612                                  if (!ccs_io_printf(head, "%u-%s=%u\n", index,  #endif
613                                                     keyword, value))                                     ccs_yesno(profile->preference.
614                                          break;                                               audit_task_info),
615                          }                                     ccs_yesno(profile->preference.
616                  }                                               audit_path_info)))
617                            goto out;
618                    if (profile->learning != &ccs_default_profile.preference &&
619                        !ccs_io_printf(head, "%u-PREFERENCE::learning={ "
620                                       "verbose=%s max_entry=%u exec.realpath=%s "
621                                       "exec.argv0=%s symlink.target=%s }\n",
622                                       index,
623                                       ccs_yesno(profile->preference.
624                                                 learning_verbose),
625                                       profile->preference.learning_max_entry,
626                                       ccs_yesno(profile->preference.
627                                                 learning_exec_realpath),
628                                       ccs_yesno(profile->preference.
629                                                 learning_exec_argv0),
630                                       ccs_yesno(profile->preference.
631                                                 learning_symlink_target)))
632                            goto out;
633                    if (profile->permissive != &ccs_default_profile.preference &&
634                        !ccs_io_printf(head, "%u-PREFERENCE::permissive={ "
635                                       "verbose=%s }\n", index,
636                                       ccs_yesno(profile->preference.
637                                                 permissive_verbose)))
638                            goto out;
639                    if (profile->enforcing != &ccs_default_profile.preference &&
640                        !ccs_io_printf(head, "%u-PREFERENCE::enforcing={ "
641                                       "verbose=%s penalty=%u }\n", index,
642                                       ccs_yesno(profile->preference.
643                                                 enforcing_verbose),
644                                       profile->preference.enforcing_penalty))
645                            goto out;
646                    continue;
647     out:
648                    head->read_avail = pos;
649                    break;
650          }          }
651          if (step == CCS_MAX_PROFILES * ccs_total)          if (index == CCS_MAX_PROFILES)
652                  head->read_eof = true;                  head->read_eof = true;
         return 0;  
653  }  }
654    
655  /* The list for "struct ccs_policy_manager_entry". */  /* The list for "struct ccs_policy_manager_entry". */
# Line 444  static int ccs_write_manager_policy(stru Line 724  static int ccs_write_manager_policy(stru
724   *   *
725   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
726   *   *
  * Returns 0.  
  *  
727   * Caller holds ccs_read_lock().   * Caller holds ccs_read_lock().
728   */   */
729  static int ccs_read_manager_policy(struct ccs_io_buffer *head)  static void ccs_read_manager_policy(struct ccs_io_buffer *head)
730  {  {
731          struct list_head *pos;          struct list_head *pos;
         ccs_check_read_lock();  
732          if (head->read_eof)          if (head->read_eof)
733                  return 0;                  return;
734          list_for_each_cookie(pos, head->read_var2, &ccs_policy_manager_list) {          list_for_each_cookie(pos, head->read_var2, &ccs_policy_manager_list) {
735                  struct ccs_policy_manager_entry *ptr;                  struct ccs_policy_manager_entry *ptr;
736                  ptr = list_entry(pos, struct ccs_policy_manager_entry, list);                  ptr = list_entry(pos, struct ccs_policy_manager_entry, list);
737                  if (ptr->is_deleted)                  if (ptr->is_deleted)
738                          continue;                          continue;
739                  if (!ccs_io_printf(head, "%s\n", ptr->manager->name))                  if (!ccs_io_printf(head, "%s\n", ptr->manager->name))
740                          return 0;                          return;
741          }          }
742          head->read_eof = true;          head->read_eof = true;
         return 0;  
743  }  }
744    
745  /**  /**
# Line 482  static bool ccs_is_policy_manager(void) Line 758  static bool ccs_is_policy_manager(void)
758          const struct ccs_path_info *domainname          const struct ccs_path_info *domainname
759                  = ccs_current_domain()->domainname;                  = ccs_current_domain()->domainname;
760          bool found = false;          bool found = false;
         ccs_check_read_lock();  
761          if (!ccs_policy_loaded)          if (!ccs_policy_loaded)
762                  return true;                  return true;
763          if (task->ccs_flags & CCS_TASK_IS_POLICY_MANAGER)          if (task->ccs_flags & CCS_TASK_IS_POLICY_MANAGER)
# Line 563  static bool ccs_is_select_one(struct ccs Line 838  static bool ccs_is_select_one(struct ccs
838  {  {
839          unsigned int pid;          unsigned int pid;
840          struct ccs_domain_info *domain = NULL;          struct ccs_domain_info *domain = NULL;
841          ccs_check_read_lock();          bool global_pid = false;
842          if (!strcmp(data, "allow_execute")) {          if (!strcmp(data, "allow_execute")) {
843                  head->read_execute_only = true;                  head->read_execute_only = true;
844                  return true;                  return true;
845          }          }
846          if (sscanf(data, "pid=%u", &pid) == 1) {          if (sscanf(data, "pid=%u", &pid) == 1 ||
847                (global_pid = true, sscanf(data, "global-pid=%u", &pid) == 1)) {
848                  struct task_struct *p;                  struct task_struct *p;
849                  /***** CRITICAL SECTION START *****/                  ccs_tasklist_lock();
850                  read_lock(&tasklist_lock);  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
851                    if (global_pid)
852                            p = find_task_by_pid_ns(pid, &init_pid_ns);
853                    else
854                            p = find_task_by_vpid(pid);
855    #else
856                  p = find_task_by_pid(pid);                  p = find_task_by_pid(pid);
857    #endif
858                  if (p)                  if (p)
859                          domain = ccs_task_domain(p);                          domain = ccs_task_domain(p);
860                  read_unlock(&tasklist_lock);                  ccs_tasklist_unlock();
                 /***** CRITICAL SECTION END *****/  
861          } else if (!strncmp(data, "domain=", 7)) {          } else if (!strncmp(data, "domain=", 7)) {
862                  if (ccs_is_domain_def(data + 7))                  if (ccs_is_domain_def(data + 7))
863                          domain = ccs_find_domain(data + 7);                          domain = ccs_find_domain(data + 7);
# Line 622  static int ccs_write_domain_policy2(char Line 903  static int ccs_write_domain_policy2(char
903                  return ccs_write_env_policy(data, domain, cond, is_delete);                  return ccs_write_env_policy(data, domain, cond, is_delete);
904          if (ccs_str_starts(&data, CCS_KEYWORD_ALLOW_MOUNT))          if (ccs_str_starts(&data, CCS_KEYWORD_ALLOW_MOUNT))
905                  return ccs_write_mount_policy(data, domain, cond, is_delete);                  return ccs_write_mount_policy(data, domain, cond, is_delete);
         if (ccs_str_starts(&data, CCS_KEYWORD_ALLOW_UNMOUNT))  
                 return ccs_write_umount_policy(data, domain, cond, is_delete);  
         if (ccs_str_starts(&data, CCS_KEYWORD_ALLOW_CHROOT))  
                 return ccs_write_chroot_policy(data, domain, cond, is_delete);  
         if (ccs_str_starts(&data, CCS_KEYWORD_ALLOW_PIVOT_ROOT))  
                 return ccs_write_pivot_root_policy(data, domain, cond,  
                                                    is_delete);  
906          return ccs_write_file_policy(data, domain, cond, is_delete);          return ccs_write_file_policy(data, domain, cond, is_delete);
907  }  }
908    
# Line 674  static int ccs_write_domain_policy(struc Line 948  static int ccs_write_domain_policy(struc
948    
949          if (sscanf(data, CCS_KEYWORD_USE_PROFILE "%u", &profile) == 1          if (sscanf(data, CCS_KEYWORD_USE_PROFILE "%u", &profile) == 1
950              && profile < CCS_MAX_PROFILES) {              && profile < CCS_MAX_PROFILES) {
951                  if (ccs_profile_ptr[profile] || !ccs_policy_loaded)                  if (!ccs_policy_loaded || ccs_profile_ptr[(u8) profile])
952                          domain->profile = (u8) profile;                          domain->profile = (u8) profile;
953                  return 0;                  return 0;
954          }          }
# Line 686  static int ccs_write_domain_policy(struc Line 960  static int ccs_write_domain_policy(struc
960                  domain->ignore_global_allow_env = !is_delete;                  domain->ignore_global_allow_env = !is_delete;
961                  return 0;                  return 0;
962          }          }
963            if (!strcmp(data, CCS_KEYWORD_QUOTA_EXCEEDED)) {
964                    domain->quota_warned = !is_delete;
965                    return 0;
966            }
967            if (!strcmp(data, CCS_KEYWORD_TRANSITION_FAILED)) {
968                    domain->domain_transition_failed = !is_delete;
969                    return 0;
970            }
971          cp = ccs_find_condition_part(data);          cp = ccs_find_condition_part(data);
972          if (cp) {          if (cp) {
973                  cond = ccs_get_condition(cp);                  cond = ccs_get_condition(cp);
# Line 698  static int ccs_write_domain_policy(struc Line 980  static int ccs_write_domain_policy(struc
980          return error;          return error;
981  }  }
982    
983    /**
984     * ccs_print_name_union - Print a ccs_name_union.
985     *
986     * @head: Pointer to "struct ccs_io_buffer".
987     * @ptr:  Pointer to "struct ccs_name_union".
988     *
989     * Returns true on success, false otherwise.
990     */
991  static bool ccs_print_name_union(struct ccs_io_buffer *head,  static bool ccs_print_name_union(struct ccs_io_buffer *head,
992                                   const struct ccs_name_union *ptr)                                   const struct ccs_name_union *ptr)
993  {  {
# Line 710  static bool ccs_print_name_union(struct Line 1000  static bool ccs_print_name_union(struct
1000          return ccs_io_printf(head, " %s", ptr->filename->name);          return ccs_io_printf(head, " %s", ptr->filename->name);
1001  }  }
1002    
1003    /**
1004     * ccs_print_name_union_quoted - Print a ccs_name_union with double quotes.
1005     *
1006     * @head: Pointer to "struct ccs_io_buffer".
1007     * @ptr:  Pointer to "struct ccs_name_union".
1008     *
1009     * Returns true on success, false otherwise.
1010     */
1011  static bool ccs_print_name_union_quoted(struct ccs_io_buffer *head,  static bool ccs_print_name_union_quoted(struct ccs_io_buffer *head,
1012                                          const struct ccs_name_union *ptr)                                          const struct ccs_name_union *ptr)
1013  {  {
# Line 719  static bool ccs_print_name_union_quoted( Line 1017  static bool ccs_print_name_union_quoted(
1017          return ccs_io_printf(head, "\"%s\"", ptr->filename->name);          return ccs_io_printf(head, "\"%s\"", ptr->filename->name);
1018  }  }
1019    
1020    /**
1021     * ccs_print_number_union_common - Print a ccs_number_union.
1022     *
1023     * @head:       Pointer to "struct ccs_io_buffer".
1024     * @ptr:        Pointer to "struct ccs_number_union".
1025     * @need_space: True if a space character is needed.
1026     *
1027     * Returns true on success, false otherwise.
1028     */
1029  static bool ccs_print_number_union_common(struct ccs_io_buffer *head,  static bool ccs_print_number_union_common(struct ccs_io_buffer *head,
1030                                            const struct ccs_number_union *ptr,                                            const struct ccs_number_union *ptr,
1031                                            const bool need_space)                                            const bool need_space)
# Line 762  static bool ccs_print_number_union_commo Line 1069  static bool ccs_print_number_union_commo
1069          }          }
1070  }  }
1071    
1072    /**
1073     * ccs_print_number_union - Print a ccs_number_union.
1074     *
1075     * @head:       Pointer to "struct ccs_io_buffer".
1076     * @ptr:        Pointer to "struct ccs_number_union".
1077     *
1078     * Returns true on success, false otherwise.
1079     */
1080  bool ccs_print_number_union(struct ccs_io_buffer *head,  bool ccs_print_number_union(struct ccs_io_buffer *head,
1081                              const struct ccs_number_union *ptr)                              const struct ccs_number_union *ptr)
1082  {  {
1083          return ccs_print_number_union_common(head, ptr, true);          return ccs_print_number_union_common(head, ptr, true);
1084  }  }
1085    
1086    /**
1087     * ccs_print_number_union_nospace - Print a ccs_number_union without a space character.
1088     *
1089     * @head:       Pointer to "struct ccs_io_buffer".
1090     * @ptr:        Pointer to "struct ccs_number_union".
1091     *
1092     * Returns true on success, false otherwise.
1093     */
1094  static bool ccs_print_number_union_nospace(struct ccs_io_buffer *head,  static bool ccs_print_number_union_nospace(struct ccs_io_buffer *head,
1095                                             const struct ccs_number_union *ptr)                                             const struct ccs_number_union *ptr)
1096  {  {
# Line 886  static bool ccs_print_condition(struct c Line 1209  static bool ccs_print_condition(struct c
1209  }  }
1210    
1211  /**  /**
1212   * ccs_print_path_acl - Print a single path ACL entry.   * ccs_print_path_acl - Print a path ACL entry.
1213   *   *
1214   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
1215   * @ptr:  Pointer to "struct ccs_path_acl".   * @ptr:  Pointer to "struct ccs_path_acl".
# Line 895  static bool ccs_print_condition(struct c Line 1218  static bool ccs_print_condition(struct c
1218   * Returns true on success, false otherwise.   * Returns true on success, false otherwise.
1219   */   */
1220  static bool ccs_print_path_acl(struct ccs_io_buffer *head,  static bool ccs_print_path_acl(struct ccs_io_buffer *head,
1221                                        struct ccs_path_acl *ptr,                                 struct ccs_path_acl *ptr,
1222                                        const struct ccs_condition *cond)                                 const struct ccs_condition *cond)
1223  {  {
1224          int pos;          int pos;
1225          u8 bit;          u8 bit;
1226          const u16 perm = ptr->perm;          const u16 perm = ptr->perm;
1227          for (bit = head->read_bit; bit < CCS_MAX_PATH_OPERATION; bit++) {          for (bit = head->read_bit; bit < CCS_MAX_PATH_OPERATION; bit++) {
                 const char *msg;  
1228                  if (!(perm & (1 << bit)))                  if (!(perm & (1 << bit)))
1229                          continue;                          continue;
1230                  if (head->read_execute_only && bit != CCS_TYPE_EXECUTE)                  if (head->read_execute_only && bit != CCS_TYPE_EXECUTE)
# Line 911  static bool ccs_print_path_acl(struct cc Line 1233  static bool ccs_print_path_acl(struct cc
1233                  if ((bit == CCS_TYPE_READ || bit == CCS_TYPE_WRITE)                  if ((bit == CCS_TYPE_READ || bit == CCS_TYPE_WRITE)
1234                      && (perm & (1 << CCS_TYPE_READ_WRITE)))                      && (perm & (1 << CCS_TYPE_READ_WRITE)))
1235                          continue;                          continue;
                 msg = ccs_path2keyword(bit);  
1236                  pos = head->read_avail;                  pos = head->read_avail;
1237                  if (!ccs_io_printf(head, "allow_%s", msg) ||                  if (!ccs_io_printf(head, "allow_%s", ccs_path2keyword(bit)) ||
1238                      !ccs_print_name_union(head, &ptr->name) ||                      !ccs_print_name_union(head, &ptr->name) ||
1239                      !ccs_print_condition(head, cond)) {                      !ccs_print_condition(head, cond)) {
1240                          head->read_bit = bit;                          head->read_bit = bit;
# Line 926  static bool ccs_print_path_acl(struct cc Line 1247  static bool ccs_print_path_acl(struct cc
1247  }  }
1248    
1249  /**  /**
1250   * ccs_print_path_number_number_acl - Print a path_number_number ACL entry.   * ccs_print_path_number3_acl - Print a path_number3 ACL entry.
1251   *   *
1252   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
1253   * @ptr:  Pointer to "struct ccs_path_number_number_acl".   * @ptr:  Pointer to "struct ccs_path_number3_acl".
1254   * @cond: Pointer to "struct ccs_condition". May be NULL.   * @cond: Pointer to "struct ccs_condition". May be NULL.
1255   *   *
1256   * Returns true on success, false otherwise.   * Returns true on success, false otherwise.
1257   */   */
1258  static bool ccs_print_path_number_number_acl(struct ccs_io_buffer *head,  static bool ccs_print_path_number3_acl(struct ccs_io_buffer *head,
1259                                  struct ccs_path_number_number_acl *ptr,                                         struct ccs_path_number3_acl *ptr,
1260                                  const struct ccs_condition *cond)                                         const struct ccs_condition *cond)
1261  {  {
1262          int pos;          int pos;
1263          u8 bit;          u8 bit;
1264          const u16 perm = ptr->perm;          const u16 perm = ptr->perm;
1265          for (bit = head->read_bit; bit < CCS_MAX_PATH_NUMBER_NUMBER_OPERATION; bit++) {          for (bit = head->read_bit; bit < CCS_MAX_PATH_NUMBER3_OPERATION;
1266                  const char *msg;               bit++) {
1267                  if (!(perm & (1 << bit)))                  if (!(perm & (1 << bit)))
1268                          continue;                          continue;
                 msg = ccs_path_number_number2keyword(bit);  
1269                  pos = head->read_avail;                  pos = head->read_avail;
1270                  if (!ccs_io_printf(head, "allow_%s", msg) ||                  if (!ccs_io_printf(head, "allow_%s",
1271                                       ccs_path_number32keyword(bit)) ||
1272                      !ccs_print_name_union(head, &ptr->name) ||                      !ccs_print_name_union(head, &ptr->name) ||
1273                        !ccs_print_number_union(head, &ptr->mode) ||
1274                      !ccs_print_number_union(head, &ptr->major) ||                      !ccs_print_number_union(head, &ptr->major) ||
1275                      !ccs_print_number_union(head, &ptr->minor) ||                      !ccs_print_number_union(head, &ptr->minor) ||
1276                      !ccs_print_condition(head, cond)) {                      !ccs_print_condition(head, cond)) {
# Line 962  static bool ccs_print_path_number_number Line 1284  static bool ccs_print_path_number_number
1284  }  }
1285    
1286  /**  /**
1287   * ccs_print_path_path_acl - Print a double path ACL entry.   * ccs_print_path2_acl - Print a path2 ACL entry.
1288   *   *
1289   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
1290   * @ptr:  Pointer to "struct ccs_path_path_acl".   * @ptr:  Pointer to "struct ccs_path2_acl".
1291   * @cond: Pointer to "struct ccs_condition". May be NULL.   * @cond: Pointer to "struct ccs_condition". May be NULL.
1292   *   *
1293   * Returns true on success, false otherwise.   * Returns true on success, false otherwise.
1294   */   */
1295  static bool ccs_print_path_path_acl(struct ccs_io_buffer *head,  static bool ccs_print_path2_acl(struct ccs_io_buffer *head,
1296                                        struct ccs_path_path_acl *ptr,                                  struct ccs_path2_acl *ptr,
1297                                        const struct ccs_condition *cond)                                  const struct ccs_condition *cond)
1298  {  {
1299          int pos;          int pos;
1300          u8 bit;          u8 bit;
1301          const u8 perm = ptr->perm;          const u8 perm = ptr->perm;
1302          for (bit = head->read_bit; bit < CCS_MAX_PATH_PATH_OPERATION; bit++) {          for (bit = head->read_bit; bit < CCS_MAX_PATH2_OPERATION; bit++) {
                 const char *msg;  
1303                  if (!(perm & (1 << bit)))                  if (!(perm & (1 << bit)))
1304                          continue;                          continue;
                 msg = ccs_path_path2keyword(bit);  
1305                  pos = head->read_avail;                  pos = head->read_avail;
1306                  if (!ccs_io_printf(head, "allow_%s", msg) ||                  if (!ccs_io_printf(head, "allow_%s",
1307                                       ccs_path22keyword(bit)) ||
1308                      !ccs_print_name_union(head, &ptr->name1) ||                      !ccs_print_name_union(head, &ptr->name1) ||
1309                      !ccs_print_name_union(head, &ptr->name2) ||                      !ccs_print_name_union(head, &ptr->name2) ||
1310                      !ccs_print_condition(head, cond)) {                      !ccs_print_condition(head, cond)) {
# Line 997  static bool ccs_print_path_path_acl(stru Line 1318  static bool ccs_print_path_path_acl(stru
1318  }  }
1319    
1320  /**  /**
1321   * ccs_print_path_number_acl - Print an ioctl/chmod/chown/chgrp ACL entry.   * ccs_print_path_number_acl - Print a path_number ACL entry.
1322   *   *
1323   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
1324   * @ptr:  Pointer to "struct ccs_path_number_acl".   * @ptr:  Pointer to "struct ccs_path_number_acl".
# Line 1012  static bool ccs_print_path_number_acl(st Line 1333  static bool ccs_print_path_number_acl(st
1333          int pos;          int pos;
1334          u8 bit;          u8 bit;
1335          const u8 perm = ptr->perm;          const u8 perm = ptr->perm;
1336          for (bit = head->read_bit; bit < CCS_MAX_PATH_NUMBER_OPERATION; bit++) {          for (bit = head->read_bit; bit < CCS_MAX_PATH_NUMBER_OPERATION;
1337                  const char *msg;               bit++) {
1338                  if (!(perm & (1 << bit)))                  if (!(perm & (1 << bit)))
1339                          continue;                          continue;
                 msg = ccs_path_number2keyword(bit);  
1340                  pos = head->read_avail;                  pos = head->read_avail;
1341                  if (!ccs_io_printf(head, "allow_%s", msg) ||                  if (!ccs_io_printf(head, "allow_%s",
1342                                       ccs_path_number2keyword(bit)) ||
1343                      !ccs_print_name_union(head, &ptr->name) ||                      !ccs_print_name_union(head, &ptr->name) ||
1344                      !ccs_print_number_union(head, &ptr->number) ||                      !ccs_print_number_union(head, &ptr->number) ||
1345                      !ccs_print_condition(head, cond)) {                      !ccs_print_condition(head, cond)) {
# Line 1135  static bool ccs_print_network_acl(struct Line 1456  static bool ccs_print_network_acl(struct
1456                                    struct ccs_ip_network_acl *ptr,                                    struct ccs_ip_network_acl *ptr,
1457                                    const struct ccs_condition *cond)                                    const struct ccs_condition *cond)
1458  {  {
1459          const int pos = head->read_avail;          int pos;
1460          if (!ccs_io_printf(head, CCS_KEYWORD_ALLOW_NETWORK "%s ",          u8 bit;
1461                             ccs_net2keyword(ptr->operation_type)))          const u16 perm = ptr->perm;
1462                  goto out;          for (bit = head->read_bit; bit < CCS_MAX_NETWORK_OPERATION; bit++) {
1463          switch (ptr->record_type) {                  if (!(perm & (1 << bit)))
1464          case CCS_IP_RECORD_TYPE_ADDRESS_GROUP:                          continue;
1465                  if (!ccs_io_printf(head, "@%s",                  pos = head->read_avail;
1466                                     ptr->address.group->group_name->name))                  if (!ccs_io_printf(head, CCS_KEYWORD_ALLOW_NETWORK "%s ",
1467                          goto out;                                     ccs_net2keyword(bit)))
                 break;  
         case CCS_IP_RECORD_TYPE_IPv4:  
                 if (!ccs_print_ipv4_entry(head, ptr))  
1468                          goto out;                          goto out;
1469                  break;                  switch (ptr->address_type) {
1470          case CCS_IP_RECORD_TYPE_IPv6:                  case CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP:
1471                  if (!ccs_print_ipv6_entry(head, ptr))                          if (!ccs_io_printf(head, "@%s", ptr->address.group->
1472                                               group_name->name))
1473                                    goto out;
1474                            break;
1475                    case CCS_IP_ADDRESS_TYPE_IPv4:
1476                            if (!ccs_print_ipv4_entry(head, ptr))
1477                                    goto out;
1478                            break;
1479                    case CCS_IP_ADDRESS_TYPE_IPv6:
1480                            if (!ccs_print_ipv6_entry(head, ptr))
1481                                    goto out;
1482                            break;
1483                    }
1484                    if (!ccs_print_number_union(head, &ptr->port) ||
1485                        !ccs_print_condition(head, cond))
1486                          goto out;                          goto out;
                 break;  
1487          }          }
1488          if (!ccs_print_number_union(head, &ptr->port) ||          head->read_bit = 0;
             !ccs_print_condition(head, cond))  
                 goto out;  
1489          return true;          return true;
1490   out:   out:
1491            head->read_bit = bit;
1492          head->read_avail = pos;          head->read_avail = pos;
1493          return false;          return false;
1494  }  }
# Line 1230  static bool ccs_print_mount_acl(struct c Line 1560  static bool ccs_print_mount_acl(struct c
1560  }  }
1561    
1562  /**  /**
  * ccs_print_umount_acl - Print a mount ACL entry.  
  *  
  * @head: Pointer to "struct ccs_io_buffer".  
  * @ptr:  Pointer to "struct ccs_umount_acl".  
  * @cond: Pointer to "struct ccs_condition". May be NULL.  
  *  
  * Returns true on success, false otherwise.  
  */  
 static bool ccs_print_umount_acl(struct ccs_io_buffer *head,  
                                  struct ccs_umount_acl *ptr,  
                                  const struct ccs_condition *cond)  
 {  
         const int pos = head->read_avail;  
         if (!ccs_io_printf(head, CCS_KEYWORD_ALLOW_UNMOUNT) ||  
             !ccs_print_name_union(head, &ptr->dir) ||  
             !ccs_print_condition(head, cond)) {  
                 head->read_avail = pos;  
                 return false;  
         }  
         return true;  
 }  
   
 /**  
  * ccs_print_chroot_acl - Print a chroot ACL entry.  
  *  
  * @head: Pointer to "struct ccs_io_buffer".  
  * @ptr:  Pointer to "struct ccs_chroot_acl".  
  * @cond: Pointer to "struct ccs_condition". May be NULL.  
  *  
  * Returns true on success, false otherwise.  
  */  
 static bool ccs_print_chroot_acl(struct ccs_io_buffer *head,  
                                  struct ccs_chroot_acl *ptr,  
                                  const struct ccs_condition *cond)  
 {  
         const int pos = head->read_avail;  
         if (!ccs_io_printf(head, CCS_KEYWORD_ALLOW_CHROOT) ||  
             !ccs_print_name_union(head, &ptr->dir) ||  
             !ccs_print_condition(head, cond)) {  
                 head->read_avail = pos;  
                 return false;  
         }  
         return true;  
 }  
   
 /**  
  * ccs_print_pivot_root_acl - Print a pivot_root ACL entry.  
  *  
  * @head: Pointer to "struct ccs_io_buffer".  
  * @ptr:  Pointer to "struct ccs_pivot_root_acl".  
  * @cond: Pointer to "struct ccs_condition". May be NULL.  
  *  
  * Returns true on success, false otherwise.  
  */  
 static bool ccs_print_pivot_root_acl(struct ccs_io_buffer *head,  
                                      struct ccs_pivot_root_acl *ptr,  
                                      const struct ccs_condition *cond)  
 {  
         const int pos = head->read_avail;  
         if (!ccs_io_printf(head, CCS_KEYWORD_ALLOW_PIVOT_ROOT) ||  
             !ccs_print_name_union(head, &ptr->new_root) ||  
             !ccs_print_name_union(head, &ptr->old_root) ||  
             !ccs_print_condition(head, cond)) {  
                 head->read_avail = pos;  
                 return false;  
         }  
         return true;  
 }  
   
 /**  
1563   * ccs_print_entry - Print an ACL entry.   * ccs_print_entry - Print an ACL entry.
1564   *   *
1565   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
# Line 1316  static bool ccs_print_entry(struct ccs_i Line 1576  static bool ccs_print_entry(struct ccs_i
1576                  return true;                  return true;
1577          if (acl_type == CCS_TYPE_PATH_ACL) {          if (acl_type == CCS_TYPE_PATH_ACL) {
1578                  struct ccs_path_acl *acl                  struct ccs_path_acl *acl
1579                          = container_of(ptr, struct ccs_path_acl,                          = container_of(ptr, struct ccs_path_acl, head);
                                        head);  
1580                  return ccs_print_path_acl(head, acl, cond);                  return ccs_print_path_acl(head, acl, cond);
1581          }          }
1582          if (acl_type == CCS_TYPE_EXECUTE_HANDLER) {          if (acl_type == CCS_TYPE_EXECUTE_HANDLER) {
# Line 1336  static bool ccs_print_entry(struct ccs_i Line 1595  static bool ccs_print_entry(struct ccs_i
1595          }          }
1596          if (head->read_execute_only)          if (head->read_execute_only)
1597                  return true;                  return true;
1598          if (acl_type == CCS_TYPE_PATH_NUMBER_NUMBER_ACL) {          if (acl_type == CCS_TYPE_PATH_NUMBER3_ACL) {
1599                  struct ccs_path_number_number_acl *acl                  struct ccs_path_number3_acl *acl
1600                          = container_of(ptr, struct ccs_path_number_number_acl, head);                          = container_of(ptr, struct ccs_path_number3_acl, head);
1601                  return ccs_print_path_number_number_acl(head, acl, cond);                  return ccs_print_path_number3_acl(head, acl, cond);
1602          }          }
1603          if (acl_type == CCS_TYPE_PATH_PATH_ACL) {          if (acl_type == CCS_TYPE_PATH2_ACL) {
1604                  struct ccs_path_path_acl *acl                  struct ccs_path2_acl *acl
1605                          = container_of(ptr, struct ccs_path_path_acl,                          = container_of(ptr, struct ccs_path2_acl, head);
1606                                         head);                  return ccs_print_path2_acl(head, acl, cond);
                 return ccs_print_path_path_acl(head, acl, cond);  
1607          }          }
1608          if (acl_type == CCS_TYPE_PATH_NUMBER_ACL) {          if (acl_type == CCS_TYPE_PATH_NUMBER_ACL) {
1609                  struct ccs_path_number_acl *acl                  struct ccs_path_number_acl *acl
1610                          = container_of(ptr, struct ccs_path_number_acl,                          = container_of(ptr, struct ccs_path_number_acl, head);
                                        head);  
1611                  return ccs_print_path_number_acl(head, acl, cond);                  return ccs_print_path_number_acl(head, acl, cond);
1612          }          }
1613          if (acl_type == CCS_TYPE_ENV_ACL) {          if (acl_type == CCS_TYPE_ENV_ACL) {
# Line 1360  static bool ccs_print_entry(struct ccs_i Line 1617  static bool ccs_print_entry(struct ccs_i
1617          }          }
1618          if (acl_type == CCS_TYPE_CAPABILITY_ACL) {          if (acl_type == CCS_TYPE_CAPABILITY_ACL) {
1619                  struct ccs_capability_acl *acl                  struct ccs_capability_acl *acl
1620                          = container_of(ptr, struct ccs_capability_acl,                          = container_of(ptr, struct ccs_capability_acl, head);
                                        head);  
1621                  return ccs_print_capability_acl(head, acl, cond);                  return ccs_print_capability_acl(head, acl, cond);
1622          }          }
1623          if (acl_type == CCS_TYPE_IP_NETWORK_ACL) {          if (acl_type == CCS_TYPE_IP_NETWORK_ACL) {
1624                  struct ccs_ip_network_acl *acl                  struct ccs_ip_network_acl *acl
1625                          = container_of(ptr, struct ccs_ip_network_acl,                          = container_of(ptr, struct ccs_ip_network_acl, head);
                                        head);  
1626                  return ccs_print_network_acl(head, acl, cond);                  return ccs_print_network_acl(head, acl, cond);
1627          }          }
1628          if (acl_type == CCS_TYPE_SIGNAL_ACL) {          if (acl_type == CCS_TYPE_SIGNAL_ACL) {
# Line 1380  static bool ccs_print_entry(struct ccs_i Line 1635  static bool ccs_print_entry(struct ccs_i
1635                          = container_of(ptr, struct ccs_mount_acl, head);                          = container_of(ptr, struct ccs_mount_acl, head);
1636                  return ccs_print_mount_acl(head, acl, cond);                  return ccs_print_mount_acl(head, acl, cond);
1637          }          }
         if (acl_type == CCS_TYPE_UMOUNT_ACL) {  
                 struct ccs_umount_acl *acl  
                         = container_of(ptr, struct ccs_umount_acl, head);  
                 return ccs_print_umount_acl(head, acl, cond);  
         }  
         if (acl_type == CCS_TYPE_CHROOT_ACL) {  
                 struct ccs_chroot_acl *acl  
                         = container_of(ptr, struct ccs_chroot_acl, head);  
                 return ccs_print_chroot_acl(head, acl, cond);  
         }  
         if (acl_type == CCS_TYPE_PIVOT_ROOT_ACL) {  
                 struct ccs_pivot_root_acl *acl  
                         = container_of(ptr, struct ccs_pivot_root_acl,  
                                        head);  
                 return ccs_print_pivot_root_acl(head, acl, cond);  
         }  
1638          BUG(); /* This must not happen. */          BUG(); /* This must not happen. */
1639          return false;          return false;
1640  }  }
# Line 1405  static bool ccs_print_entry(struct ccs_i Line 1644  static bool ccs_print_entry(struct ccs_i
1644   *   *
1645   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
1646   *   *
  * Returns 0.  
  *  
1647   * Caller holds ccs_read_lock().   * Caller holds ccs_read_lock().
1648   */   */
1649  static int ccs_read_domain_policy(struct ccs_io_buffer *head)  static void ccs_read_domain_policy(struct ccs_io_buffer *head)
1650  {  {
1651          struct list_head *dpos;          struct list_head *dpos;
1652          struct list_head *apos;          struct list_head *apos;
         ccs_check_read_lock();  
1653          if (head->read_eof)          if (head->read_eof)
1654                  return 0;                  return;
1655          if (head->read_step == 0)          if (head->read_step == 0)
1656                  head->read_step = 1;                  head->read_step = 1;
1657          list_for_each_cookie(dpos, head->read_var1, &ccs_domain_list) {          list_for_each_cookie(dpos, head->read_var1, &ccs_domain_list) {
# Line 1431  static int ccs_read_domain_policy(struct Line 1667  static int ccs_read_domain_policy(struct
1667                          continue;                          continue;
1668                  /* Print domainname and flags. */                  /* Print domainname and flags. */
1669                  if (domain->quota_warned)                  if (domain->quota_warned)
1670                          quota_exceeded = "quota_exceeded\n";                          quota_exceeded = CCS_KEYWORD_QUOTA_EXCEEDED "\n";
1671                  if (domain->domain_transition_failed)                  if (domain->domain_transition_failed)
1672                          transition_failed = "transition_failed\n";                          transition_failed = CCS_KEYWORD_TRANSITION_FAILED "\n";
1673                  if (domain->ignore_global_allow_read)                  if (domain->ignore_global_allow_read)
1674                          ignore_global_allow_read                          ignore_global_allow_read
1675                                  = CCS_KEYWORD_IGNORE_GLOBAL_ALLOW_READ "\n";                                  = CCS_KEYWORD_IGNORE_GLOBAL_ALLOW_READ "\n";
# Line 1446  static int ccs_read_domain_policy(struct Line 1682  static int ccs_read_domain_policy(struct
1682                                     transition_failed,                                     transition_failed,
1683                                     ignore_global_allow_read,                                     ignore_global_allow_read,
1684                                     ignore_global_allow_env))                                     ignore_global_allow_env))
1685                          return 0;                          return;
1686                  head->read_step = 2;                  head->read_step = 2;
1687   acl_loop:   acl_loop:
1688                  if (head->read_step == 3)                  if (head->read_step == 3)
# Line 1457  static int ccs_read_domain_policy(struct Line 1693  static int ccs_read_domain_policy(struct
1693                          struct ccs_acl_info *ptr                          struct ccs_acl_info *ptr
1694                                  = list_entry(apos, struct ccs_acl_info, list);                                  = list_entry(apos, struct ccs_acl_info, list);
1695                          if (!ccs_print_entry(head, ptr))                          if (!ccs_print_entry(head, ptr))
1696                                  return 0;                                  return;
1697                  }                  }
1698                  head->read_step = 3;                  head->read_step = 3;
1699   tail_mark:   tail_mark:
1700                  if (!ccs_io_printf(head, "\n"))                  if (!ccs_io_printf(head, "\n"))
1701                          return 0;                          return;
1702                  head->read_step = 1;                  head->read_step = 1;
1703                  if (head->read_single_domain)                  if (head->read_single_domain)
1704                          break;                          break;
1705          }          }
1706          head->read_eof = true;          head->read_eof = true;
         return 0;  
1707  }  }
1708    
1709  /**  /**
# Line 1481  static int ccs_read_domain_policy(struct Line 1716  static int ccs_read_domain_policy(struct
1716   * This is equivalent to doing   * This is equivalent to doing
1717   *   *
1718   *     ( echo "select " $domainname; echo "use_profile " $profile ) |   *     ( echo "select " $domainname; echo "use_profile " $profile ) |
1719   *     /usr/lib/ccs/loadpolicy -d   *     /usr/sbin/ccs-loadpolicy -d
1720   *   *
1721   * Caller holds ccs_read_lock().   * Caller holds ccs_read_lock().
1722   */   */
# Line 1491  static int ccs_write_domain_profile(stru Line 1726  static int ccs_write_domain_profile(stru
1726          char *cp = strchr(data, ' ');          char *cp = strchr(data, ' ');
1727          struct ccs_domain_info *domain;          struct ccs_domain_info *domain;
1728          unsigned int profile;          unsigned int profile;
         ccs_check_read_lock();  
1729          if (!cp)          if (!cp)
1730                  return -EINVAL;                  return -EINVAL;
1731          *cp = '\0';          *cp = '\0';
# Line 1499  static int ccs_write_domain_profile(stru Line 1733  static int ccs_write_domain_profile(stru
1733          if (profile >= CCS_MAX_PROFILES)          if (profile >= CCS_MAX_PROFILES)
1734                  return -EINVAL;                  return -EINVAL;
1735          domain = ccs_find_domain(cp + 1);          domain = ccs_find_domain(cp + 1);
1736          if (domain && (ccs_profile_ptr[profile] || !ccs_policy_loaded))          if (domain && (!ccs_policy_loaded || ccs_profile_ptr[(u8) profile]))
1737                  domain->profile = (u8) profile;                  domain->profile = (u8) profile;
1738          return 0;          return 0;
1739  }  }
# Line 1509  static int ccs_write_domain_profile(stru Line 1743  static int ccs_write_domain_profile(stru
1743   *   *
1744   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
1745   *   *
  * Returns list of profile number and domainname pairs.  
  *  
1746   * This is equivalent to doing   * This is equivalent to doing
1747   *   *
1748   *     grep -A 1 '^<kernel>' /proc/ccs/domain_policy |   *     grep -A 1 '^<kernel>' /proc/ccs/domain_policy |
# Line 1520  static int ccs_write_domain_profile(stru Line 1752  static int ccs_write_domain_profile(stru
1752   *   *
1753   * Caller holds ccs_read_lock().   * Caller holds ccs_read_lock().
1754   */   */
1755  static int ccs_read_domain_profile(struct ccs_io_buffer *head)  static void ccs_read_domain_profile(struct ccs_io_buffer *head)
1756  {  {
1757          struct list_head *pos;          struct list_head *pos;
         ccs_check_read_lock();  
1758          if (head->read_eof)          if (head->read_eof)
1759                  return 0;                  return;
1760          list_for_each_cookie(pos, head->read_var1, &ccs_domain_list) {          list_for_each_cookie(pos, head->read_var1, &ccs_domain_list) {
1761                  struct ccs_domain_info *domain;                  struct ccs_domain_info *domain;
1762                  domain = list_entry(pos, struct ccs_domain_info, list);                  domain = list_entry(pos, struct ccs_domain_info, list);
# Line 1533  static int ccs_read_domain_profile(struc Line 1764  static int ccs_read_domain_profile(struc
1764                          continue;                          continue;
1765                  if (!ccs_io_printf(head, "%u %s\n", domain->profile,                  if (!ccs_io_printf(head, "%u %s\n", domain->profile,
1766                                     domain->domainname->name))                                     domain->domainname->name))
1767                          return 0;                          return;
1768          }          }
1769          head->read_eof = true;          head->read_eof = true;
         return 0;  
1770  }  }
1771    
1772  /**  /**
# Line 1563  static int ccs_write_pid(struct ccs_io_b Line 1793  static int ccs_write_pid(struct ccs_io_b
1793   *   *
1794   * Caller holds ccs_read_lock().   * Caller holds ccs_read_lock().
1795   */   */
1796  static int ccs_read_pid(struct ccs_io_buffer *head)  static void ccs_read_pid(struct ccs_io_buffer *head)
1797  {  {
1798          char *buf = head->write_buf;          char *buf = head->write_buf;
1799          bool task_info = false;          bool task_info = false;
1800            bool global_pid = false;
1801          unsigned int pid;          unsigned int pid;
1802          struct task_struct *p;          struct task_struct *p;
1803          struct ccs_domain_info *domain = NULL;          struct ccs_domain_info *domain = NULL;
1804          u32 ccs_flags = 0;          u32 ccs_flags = 0;
         ccs_check_read_lock();  
1805          /* Accessing write_buf is safe because head->io_sem is held. */          /* Accessing write_buf is safe because head->io_sem is held. */
1806          if (!buf)          if (!buf) {
1807                  goto done; /* Do nothing if open(O_RDONLY). */                  head->read_eof = true;
1808                    return; /* Do nothing if open(O_RDONLY). */
1809            }
1810          if (head->read_avail || head->read_eof)          if (head->read_avail || head->read_eof)
1811                  goto done;                  return;
1812          head->read_eof = true;          head->read_eof = true;
1813          if (ccs_str_starts(&buf, "info "))          if (ccs_str_starts(&buf, "info "))
1814                  task_info = true;                  task_info = true;
1815            if (ccs_str_starts(&buf, "global-pid "))
1816                    global_pid = true;
1817          pid = (unsigned int) simple_strtoul(buf, NULL, 10);          pid = (unsigned int) simple_strtoul(buf, NULL, 10);
1818          /***** CRITICAL SECTION START *****/          ccs_tasklist_lock();
1819          read_lock(&tasklist_lock);  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
1820            if (global_pid)
1821                    p = find_task_by_pid_ns(pid, &init_pid_ns);
1822            else
1823                    p = find_task_by_vpid(pid);
1824    #else
1825          p = find_task_by_pid(pid);          p = find_task_by_pid(pid);
1826    #endif
1827          if (p) {          if (p) {
1828                  domain = ccs_task_domain(p);                  domain = ccs_task_domain(p);
1829                  ccs_flags = p->ccs_flags;                  ccs_flags = p->ccs_flags;
1830          }          }
1831          read_unlock(&tasklist_lock);          ccs_tasklist_unlock();
         /***** CRITICAL SECTION END *****/  
1832          if (!domain)          if (!domain)
1833                  goto done;                  return;
1834          if (!task_info)          if (!task_info)
1835                  ccs_io_printf(head, "%u %u %s", pid, domain->profile,                  ccs_io_printf(head, "%u %u %s", pid, domain->profile,
1836                                domain->domainname->name);                                domain->domainname->name);
1837          else          else
1838                  ccs_io_printf(head, "%u manager=%s execute_handler=%s "                  ccs_io_printf(head, "%u manager=%s execute_handler=%s "
1839                                "state[0]=%u state[1]=%u state[2]=%u", pid,                                "state[0]=%u state[1]=%u state[2]=%u", pid,
1840                                ccs_flags & CCS_TASK_IS_POLICY_MANAGER ?                                ccs_yesno(ccs_flags &
1841                                "yes" : "no",                                          CCS_TASK_IS_POLICY_MANAGER),
1842                                ccs_flags & CCS_TASK_IS_EXECUTE_HANDLER ?                                ccs_yesno(ccs_flags &
1843                                "yes" : "no",                                          CCS_TASK_IS_EXECUTE_HANDLER),
1844                                (u8) (ccs_flags >> 24),                                (u8) (ccs_flags >> 24),
1845                                (u8) (ccs_flags >> 16),                                (u8) (ccs_flags >> 16),
1846                                (u8) (ccs_flags >> 8));                                (u8) (ccs_flags >> 8));
  done:  
         return 0;  
1847  }  }
1848    
1849  /**  /**
# Line 1656  static int ccs_write_exception_policy(st Line 1893  static int ccs_write_exception_policy(st
1893   *   *
1894   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
1895   *   *
  * Returns 0 on success, -EINVAL otherwise.  
  *  
1896   * Caller holds ccs_read_lock().   * Caller holds ccs_read_lock().
1897   */   */
1898  static int ccs_read_exception_policy(struct ccs_io_buffer *head)  static void ccs_read_exception_policy(struct ccs_io_buffer *head)
1899  {  {
1900          ccs_check_read_lock();          if (head->read_eof)
1901          if (!head->read_eof) {                  return;
1902                  switch (head->read_step) {          switch (head->read_step) {
1903                  case 0:          case 0:
1904                          head->read_var2 = NULL;                  head->read_var2 = NULL;
1905                          head->read_step = 1;                  head->read_step = 1;
1906                  case 1:          case 1:
1907                          if (!ccs_read_domain_keeper_policy(head))                  if (!ccs_read_domain_keeper_policy(head))
                                 break;  
                         head->read_var2 = NULL;  
                         head->read_step = 2;  
                 case 2:  
                         if (!ccs_read_globally_readable_policy(head))  
                                 break;  
                         head->read_var2 = NULL;  
                         head->read_step = 3;  
                 case 3:  
                         if (!ccs_read_globally_usable_env_policy(head))  
                                 break;  
                         head->read_var2 = NULL;  
                         head->read_step = 4;  
                 case 4:  
                         if (!ccs_read_domain_initializer_policy(head))  
                                 break;  
                         head->read_var2 = NULL;  
                         head->read_step = 6;  
                 case 6:  
                         if (!ccs_read_aggregator_policy(head))  
                                 break;  
                         head->read_var2 = NULL;  
                         head->read_step = 7;  
                 case 7:  
                         if (!ccs_read_file_pattern(head))  
                                 break;  
                         head->read_var2 = NULL;  
                         head->read_step = 8;  
                 case 8:  
                         if (!ccs_read_no_rewrite_policy(head))  
                                 break;  
                         head->read_var2 = NULL;  
                         head->read_step = 9;  
                 case 9:  
                         if (!ccs_read_path_group_policy(head))  
                                 break;  
                         head->read_var1 = NULL;  
                         head->read_var2 = NULL;  
                         head->read_step = 10;  
                 case 10:  
                         if (!ccs_read_number_group_policy(head))  
                                 break;  
                         head->read_var1 = NULL;  
                         head->read_var2 = NULL;  
                         head->read_step = 11;  
                 case 11:  
                         if (!ccs_read_address_group_policy(head))  
                                 break;  
                         head->read_var2 = NULL;  
                         head->read_step = 12;  
                 case 12:  
                         if (!ccs_read_reserved_port_policy(head))  
                                 break;  
                         head->read_eof = true;  
1908                          break;                          break;
1909                  default:                  head->read_var2 = NULL;
1910                          return -EINVAL;                  head->read_step = 2;
1911                  }          case 2:
1912                    if (!ccs_read_globally_readable_policy(head))
1913                            break;
1914                    head->read_var2 = NULL;
1915                    head->read_step = 3;
1916            case 3:
1917                    if (!ccs_read_globally_usable_env_policy(head))
1918                            break;
1919                    head->read_var2 = NULL;
1920                    head->read_step = 4;
1921            case 4:
1922                    if (!ccs_read_domain_initializer_policy(head))
1923                            break;
1924                    head->read_var2 = NULL;
1925                    head->read_step = 6;
1926            case 6:
1927                    if (!ccs_read_aggregator_policy(head))
1928                            break;
1929                    head->read_var2 = NULL;
1930                    head->read_step = 7;
1931            case 7:
1932                    if (!ccs_read_file_pattern(head))
1933                            break;
1934                    head->read_var2 = NULL;
1935                    head->read_step = 8;
1936            case 8:
1937                    if (!ccs_read_no_rewrite_policy(head))
1938                            break;
1939                    head->read_var2 = NULL;
1940                    head->read_step = 9;
1941            case 9:
1942                    if (!ccs_read_path_group_policy(head))
1943                            break;
1944                    head->read_var1 = NULL;
1945                    head->read_var2 = NULL;
1946                    head->read_step = 10;
1947            case 10:
1948                    if (!ccs_read_number_group_policy(head))
1949                            break;
1950                    head->read_var1 = NULL;
1951                    head->read_var2 = NULL;
1952                    head->read_step = 11;
1953            case 11:
1954                    if (!ccs_read_address_group_policy(head))
1955                            break;
1956                    head->read_var2 = NULL;
1957                    head->read_step = 12;
1958            case 12:
1959                    if (!ccs_read_reserved_port_policy(head))
1960                            break;
1961                    head->read_eof = true;
1962          }          }
         return 0;  
1963  }  }
1964    
1965  /**  /**
# Line 1757  static bool ccs_get_argv0(struct ccs_exe Line 1987  static bool ccs_get_argv0(struct ccs_exe
1987                  while (offset < PAGE_SIZE) {                  while (offset < PAGE_SIZE) {
1988                          const char *kaddr = ee->dump.data;                          const char *kaddr = ee->dump.data;
1989                          const unsigned char c = kaddr[offset++];                          const unsigned char c = kaddr[offset++];
1990                          if (c && arg_len < CCS_MAX_PATHNAME_LEN - 10) {                          if (c && arg_len < CCS_EXEC_TMPSIZE - 10) {
1991                                  if (c == '\\') {                                  if (c == '\\') {
1992                                          arg_ptr[arg_len++] = '\\';                                          arg_ptr[arg_len++] = '\\';
1993                                          arg_ptr[arg_len++] = '\\';                                          arg_ptr[arg_len++] = '\\';
                                 } else if (c == '/') {  
                                         arg_len = 0;  
1994                                  } else if (c > ' ' && c < 127) {                                  } else if (c > ' ' && c < 127) {
1995                                          arg_ptr[arg_len++] = c;                                          arg_ptr[arg_len++] = c;
1996                                  } else {                                  } else {
# Line 1787  static bool ccs_get_argv0(struct ccs_exe Line 2015  static bool ccs_get_argv0(struct ccs_exe
2015          return false;          return false;
2016  }  }
2017    
2018    /**
2019     * ccs_get_execute_condition - Get condition part for execute requests.
2020     *
2021     * @ee: Pointer to "struct ccs_execve_entry".
2022     *
2023     * Returns pointer to "struct ccs_condition" on success, NULL otherwise.
2024     */
2025  static struct ccs_condition *ccs_get_execute_condition(struct ccs_execve_entry  static struct ccs_condition *ccs_get_execute_condition(struct ccs_execve_entry
2026                                                         *ee)                                                         *ee)
2027  {  {
# Line 1795  static struct ccs_condition *ccs_get_exe Line 2030  static struct ccs_condition *ccs_get_exe
2030          int len = 256;          int len = 256;
2031          char *realpath = NULL;          char *realpath = NULL;
2032          char *argv0 = NULL;          char *argv0 = NULL;
2033          if (ccs_check_flags(NULL, CCS_AUTOLEARN_EXEC_REALPATH)) {          const struct ccs_profile *profile = ccs_profile(ee->r.domain->profile);
2034            if (profile->learning->learning_exec_realpath) {
2035                  struct file *file = ee->bprm->file;                  struct file *file = ee->bprm->file;
2036  #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)  #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
2037                  struct path path = { file->f_vfsmnt, file->f_dentry };                  struct path path = { file->f_vfsmnt, file->f_dentry };
# Line 1806  static struct ccs_condition *ccs_get_exe Line 2042  static struct ccs_condition *ccs_get_exe
2042                  if (realpath)                  if (realpath)
2043                          len += strlen(realpath) + 17;                          len += strlen(realpath) + 17;
2044          }          }
2045          if (ccs_check_flags(NULL, CCS_AUTOLEARN_EXEC_REALPATH)) {          if (profile->learning->learning_exec_argv0) {
2046                  if (ccs_get_argv0(ee)) {                  if (ccs_get_argv0(ee)) {
2047                          argv0 = ee->tmp;                          argv0 = ee->tmp;
2048                          len += strlen(argv0) + 16;                          len += strlen(argv0) + 16;
2049                  }                  }
2050          }          }
2051          buf = kmalloc(len, GFP_KERNEL);          buf = kmalloc(len, GFP_KERNEL);
2052          if (!buf)          if (!buf) {
2053                    kfree(realpath);
2054                  return NULL;                  return NULL;
2055            }
2056          snprintf(buf, len - 1, "if");          snprintf(buf, len - 1, "if");
2057          if (current->ccs_flags & CCS_TASK_IS_EXECUTE_HANDLER) {          if (current->ccs_flags & CCS_TASK_IS_EXECUTE_HANDLER) {
2058                  const int pos = strlen(buf);                  const int pos = strlen(buf);
# Line 1837  static struct ccs_condition *ccs_get_exe Line 2075  static struct ccs_condition *ccs_get_exe
2075          return cond;          return cond;
2076  }  }
2077    
2078    /**
2079     * ccs_get_symlink_condition - Get condition part for symlink requests.
2080     *
2081     * @r: Pointer to "struct ccs_request_info".
2082     *
2083     * Returns pointer to "struct ccs_condition" on success, NULL otherwise.
2084     */
2085    static struct ccs_condition *ccs_get_symlink_condition(struct ccs_request_info
2086                                                           *r)
2087    {
2088            struct ccs_condition *cond;
2089            char *buf;
2090            int len = 256;
2091            const char *symlink = NULL;
2092            const struct ccs_profile *profile = ccs_profile(r->profile);
2093            if (profile->learning->learning_symlink_target) {
2094                    symlink = r->obj->symlink_target->name;
2095                    len += strlen(symlink) + 18;
2096            }
2097            buf = kmalloc(len, GFP_KERNEL);
2098            if (!buf)
2099                    return NULL;
2100            snprintf(buf, len - 1, "if");
2101            if (current->ccs_flags & CCS_TASK_IS_EXECUTE_HANDLER) {
2102                    const int pos = strlen(buf);
2103                    snprintf(buf + pos, len - pos - 1,
2104                             " task.type=execute_handler");
2105            }
2106            if (symlink) {
2107                    const int pos = strlen(buf);
2108                    snprintf(buf + pos, len - pos - 1, " symlink.target=\"%s\"",
2109                             symlink);
2110            }
2111            cond = ccs_get_condition(buf);
2112            kfree(buf);
2113            return cond;
2114    }
2115    
2116  /* Wait queue for ccs_query_list. */  /* Wait queue for ccs_query_list. */
2117  static DECLARE_WAIT_QUEUE_HEAD(ccs_query_wait);  static DECLARE_WAIT_QUEUE_HEAD(ccs_query_wait);
2118    
# Line 1860  static LIST_HEAD(ccs_query_list); Line 2136  static LIST_HEAD(ccs_query_list);
2136  static atomic_t ccs_query_observers = ATOMIC_INIT(0);  static atomic_t ccs_query_observers = ATOMIC_INIT(0);
2137    
2138  /**  /**
2139   * ccs_check_supervisor - Ask for the supervisor's decision.   * ccs_supervisor - Ask for the supervisor's decision.
2140   *   *
2141   * @r:       Pointer to "struct ccs_request_info".   * @r:       Pointer to "struct ccs_request_info".
2142   * @fmt:     The printf()'s format string, followed by parameters.   * @fmt:     The printf()'s format string, followed by parameters.
# Line 1870  static atomic_t ccs_query_observers = AT Line 2146  static atomic_t ccs_query_observers = AT
2146   * retry the access request which violated the policy in enforcing mode,   * retry the access request which violated the policy in enforcing mode,
2147   * 0 if it is not in enforcing mode, -EPERM otherwise.   * 0 if it is not in enforcing mode, -EPERM otherwise.
2148   */   */
2149  int ccs_check_supervisor(struct ccs_request_info *r, const char *fmt, ...)  int ccs_supervisor(struct ccs_request_info *r, const char *fmt, ...)
2150  {  {
2151          va_list args;          va_list args;
2152          int error = -EPERM;          int error = -EPERM;
# Line 1885  int ccs_check_supervisor(struct ccs_requ Line 2161  int ccs_check_supervisor(struct ccs_requ
2161          switch (r->mode) {          switch (r->mode) {
2162                  char *buffer;                  char *buffer;
2163                  struct ccs_condition *cond;                  struct ccs_condition *cond;
2164          case 1:          case CCS_CONFIG_LEARNING:
2165                  if (!ccs_domain_quota_ok(r))                  if (!ccs_domain_quota_ok(r))
2166                          return 0;                          return 0;
2167                  va_start(args, fmt);                  va_start(args, fmt);
# Line 1900  int ccs_check_supervisor(struct ccs_requ Line 2176  int ccs_check_supervisor(struct ccs_requ
2176                  ccs_normalize_line(buffer);                  ccs_normalize_line(buffer);
2177                  if (r->ee && !strncmp(buffer, "allow_execute ", 14))                  if (r->ee && !strncmp(buffer, "allow_execute ", 14))
2178                          cond = ccs_get_execute_condition(r->ee);                          cond = ccs_get_execute_condition(r->ee);
2179                    else if (r->obj && r->obj->symlink_target)
2180                            cond = ccs_get_symlink_condition(r);
2181                  else if ((current->ccs_flags & CCS_TASK_IS_EXECUTE_HANDLER)) {                  else if ((current->ccs_flags & CCS_TASK_IS_EXECUTE_HANDLER)) {
2182                          char str[] = "if task.type=execute_handler";                          char str[] = "if task.type=execute_handler";
2183                          cond = ccs_get_condition(str);                          cond = ccs_get_condition(str);
# Line 1909  int ccs_check_supervisor(struct ccs_requ Line 2187  int ccs_check_supervisor(struct ccs_requ
2187                  ccs_put_condition(cond);                  ccs_put_condition(cond);
2188                  kfree(buffer);                  kfree(buffer);
2189                  /* fall through */                  /* fall through */
2190          case 2:          case CCS_CONFIG_PERMISSIVE:
2191                  return 0;                  return 0;
2192          }          }
2193          if (!atomic_read(&ccs_query_observers)) {          if (!atomic_read(&ccs_query_observers)) {
2194                  int i;                  int i;
2195                  if (current->ccs_flags & CCS_DONT_SLEEP_ON_ENFORCE_ERROR)                  if (current->ccs_flags & CCS_DONT_SLEEP_ON_ENFORCE_ERROR)
2196                          return -EPERM;                          return -EPERM;
2197                  for (i = 0; i < ccs_check_flags(r->domain, CCS_SLEEP_PERIOD);                  for (i = 0; i < ccs_profile(r->domain->profile)->enforcing->
2198                       i++) {                               enforcing_penalty; i++) {
2199                          set_current_state(TASK_INTERRUPTIBLE);                          set_current_state(TASK_INTERRUPTIBLE);
2200                          schedule_timeout(HZ / 10);                          schedule_timeout(HZ / 10);
2201                  }                  }
# Line 1937  int ccs_check_supervisor(struct ccs_requ Line 2215  int ccs_check_supervisor(struct ccs_requ
2215          if (!ccs_query_entry->query)          if (!ccs_query_entry->query)
2216                  goto out;                  goto out;
2217          INIT_LIST_HEAD(&ccs_query_entry->list);          INIT_LIST_HEAD(&ccs_query_entry->list);
         /***** CRITICAL SECTION START *****/  
2218          spin_lock(&ccs_query_list_lock);          spin_lock(&ccs_query_list_lock);
2219          if (ccs_quota_for_query && ccs_query_memory_size + len +          if (ccs_quota_for_query && ccs_query_memory_size + len +
2220              sizeof(*ccs_query_entry) >= ccs_quota_for_query) {              sizeof(*ccs_query_entry) >= ccs_quota_for_query) {
# Line 1947  int ccs_check_supervisor(struct ccs_requ Line 2224  int ccs_check_supervisor(struct ccs_requ
2224                  ccs_query_entry->serial = ccs_serial++;                  ccs_query_entry->serial = ccs_serial++;
2225          }          }
2226          spin_unlock(&ccs_query_list_lock);          spin_unlock(&ccs_query_list_lock);
         /***** CRITICAL SECTION END *****/  
2227          if (quota_exceeded)          if (quota_exceeded)
2228                  goto out;                  goto out;
2229          pos = snprintf(ccs_query_entry->query, len - 1, "Q%u-%hu\n%s",          pos = snprintf(ccs_query_entry->query, len - 1, "Q%u-%hu\n%s",
# Line 1958  int ccs_check_supervisor(struct ccs_requ Line 2234  int ccs_check_supervisor(struct ccs_requ
2234          vsnprintf(ccs_query_entry->query + pos, len - 1 - pos, fmt, args);          vsnprintf(ccs_query_entry->query + pos, len - 1 - pos, fmt, args);
2235          ccs_query_entry->query_len = strlen(ccs_query_entry->query) + 1;          ccs_query_entry->query_len = strlen(ccs_query_entry->query) + 1;
2236          va_end(args);          va_end(args);
         /***** CRITICAL SECTION START *****/  
2237          spin_lock(&ccs_query_list_lock);          spin_lock(&ccs_query_list_lock);
2238          list_add_tail(&ccs_query_entry->list, &ccs_query_list);          list_add_tail(&ccs_query_entry->list, &ccs_query_list);
2239          spin_unlock(&ccs_query_list_lock);          spin_unlock(&ccs_query_list_lock);
         /***** CRITICAL SECTION END *****/  
2240          /* Give 10 seconds for supervisor's opinion. */          /* Give 10 seconds for supervisor's opinion. */
2241          for (ccs_query_entry->timer = 0;          for (ccs_query_entry->timer = 0;
2242               atomic_read(&ccs_query_observers) && ccs_query_entry->timer < 100;               atomic_read(&ccs_query_observers) && ccs_query_entry->timer < 100;
# Line 1973  int ccs_check_supervisor(struct ccs_requ Line 2247  int ccs_check_supervisor(struct ccs_requ
2247                  if (ccs_query_entry->answer)                  if (ccs_query_entry->answer)
2248                          break;                          break;
2249          }          }
         /***** CRITICAL SECTION START *****/  
2250          spin_lock(&ccs_query_list_lock);          spin_lock(&ccs_query_list_lock);
2251          list_del(&ccs_query_entry->list);          list_del(&ccs_query_entry->list);
2252          ccs_query_memory_size -= len + sizeof(*ccs_query_entry);          ccs_query_memory_size -= len + sizeof(*ccs_query_entry);
2253          spin_unlock(&ccs_query_list_lock);          spin_unlock(&ccs_query_list_lock);
         /***** CRITICAL SECTION END *****/  
2254          switch (ccs_query_entry->answer) {          switch (ccs_query_entry->answer) {
2255          case 3: /* Asked to retry by administrator. */          case 3: /* Asked to retry by administrator. */
2256                  error = 1;                  error = 1;
# Line 2019  static int ccs_poll_query(struct file *f Line 2291  static int ccs_poll_query(struct file *f
2291          bool found = false;          bool found = false;
2292          u8 i;          u8 i;
2293          for (i = 0; i < 2; i++) {          for (i = 0; i < 2; i++) {
                 /***** CRITICAL SECTION START *****/  
2294                  spin_lock(&ccs_query_list_lock);                  spin_lock(&ccs_query_list_lock);
2295                  list_for_each(tmp, &ccs_query_list) {                  list_for_each(tmp, &ccs_query_list) {
2296                          struct ccs_query_entry *ptr                          struct ccs_query_entry *ptr
# Line 2030  static int ccs_poll_query(struct file *f Line 2301  static int ccs_poll_query(struct file *f
2301                          break;                          break;
2302                  }                  }
2303                  spin_unlock(&ccs_query_list_lock);                  spin_unlock(&ccs_query_list_lock);
                 /***** CRITICAL SECTION END *****/  
2304                  if (found)                  if (found)
2305                          return POLLIN | POLLRDNORM;                          return POLLIN | POLLRDNORM;
2306                  if (i)                  if (i)
# Line 2044  static int ccs_poll_query(struct file *f Line 2314  static int ccs_poll_query(struct file *f
2314   * ccs_read_query - Read access requests which violated policy in enforcing mode.   * ccs_read_query - Read access requests which violated policy in enforcing mode.
2315   *   *
2316   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
  *  
  * Returns 0.  
2317   */   */
2318  static int ccs_read_query(struct ccs_io_buffer *head)  static void ccs_read_query(struct ccs_io_buffer *head)
2319  {  {
2320          struct list_head *tmp;          struct list_head *tmp;
2321          int pos = 0;          int pos = 0;
2322          int len = 0;          int len = 0;
2323          char *buf;          char *buf;
2324          if (head->read_avail)          if (head->read_avail)
2325                  return 0;                  return;
2326          if (head->read_buf) {          if (head->read_buf) {
2327                  kfree(head->read_buf);                  kfree(head->read_buf);
2328                  head->read_buf = NULL;                  head->read_buf = NULL;
2329                  head->readbuf_size = 0;                  head->readbuf_size = 0;
2330          }          }
         /***** CRITICAL SECTION START *****/  
2331          spin_lock(&ccs_query_list_lock);          spin_lock(&ccs_query_list_lock);
2332          list_for_each(tmp, &ccs_query_list) {          list_for_each(tmp, &ccs_query_list) {
2333                  struct ccs_query_entry *ptr                  struct ccs_query_entry *ptr
# Line 2073  static int ccs_read_query(struct ccs_io_ Line 2340  static int ccs_read_query(struct ccs_io_
2340                  break;                  break;
2341          }          }
2342          spin_unlock(&ccs_query_list_lock);          spin_unlock(&ccs_query_list_lock);
         /***** CRITICAL SECTION END *****/  
2343          if (!len) {          if (!len) {
2344                  head->read_step = 0;                  head->read_step = 0;
2345                  return 0;                  return;
2346          }          }
2347          buf = kzalloc(len, GFP_KERNEL);          buf = kzalloc(len, GFP_KERNEL);
2348          if (!buf)          if (!buf)
2349                  return 0;                  return;
2350          pos = 0;          pos = 0;
         /***** CRITICAL SECTION START *****/  
2351          spin_lock(&ccs_query_list_lock);          spin_lock(&ccs_query_list_lock);
2352          list_for_each(tmp, &ccs_query_list) {          list_for_each(tmp, &ccs_query_list) {
2353                  struct ccs_query_entry *ptr                  struct ccs_query_entry *ptr
# Line 2100  static int ccs_read_query(struct ccs_io_ Line 2365  static int ccs_read_query(struct ccs_io_
2365                  break;                  break;
2366          }          }
2367          spin_unlock(&ccs_query_list_lock);          spin_unlock(&ccs_query_list_lock);
         /***** CRITICAL SECTION END *****/  
2368          if (buf[0]) {          if (buf[0]) {
2369                  head->read_avail = len;                  head->read_avail = len;
2370                  head->readbuf_size = head->read_avail;                  head->readbuf_size = head->read_avail;
# Line 2109  static int ccs_read_query(struct ccs_io_ Line 2373  static int ccs_read_query(struct ccs_io_
2373          } else {          } else {
2374                  kfree(buf);                  kfree(buf);
2375          }          }
         return 0;  
2376  }  }
2377    
2378  /**  /**
# Line 2125  static int ccs_write_answer(struct ccs_i Line 2388  static int ccs_write_answer(struct ccs_i
2388          struct list_head *tmp;          struct list_head *tmp;
2389          unsigned int serial;          unsigned int serial;
2390          unsigned int answer;          unsigned int answer;
         /***** CRITICAL SECTION START *****/  
2391          spin_lock(&ccs_query_list_lock);          spin_lock(&ccs_query_list_lock);
2392          list_for_each(tmp, &ccs_query_list) {          list_for_each(tmp, &ccs_query_list) {
2393                  struct ccs_query_entry *ptr                  struct ccs_query_entry *ptr
# Line 2133  static int ccs_write_answer(struct ccs_i Line 2395  static int ccs_write_answer(struct ccs_i
2395                  ptr->timer = 0;                  ptr->timer = 0;
2396          }          }
2397          spin_unlock(&ccs_query_list_lock);          spin_unlock(&ccs_query_list_lock);
         /***** CRITICAL SECTION END *****/  
2398          if (sscanf(data, "A%u=%u", &serial, &answer) != 2)          if (sscanf(data, "A%u=%u", &serial, &answer) != 2)
2399                  return -EINVAL;                  return -EINVAL;
         /***** CRITICAL SECTION START *****/  
2400          spin_lock(&ccs_query_list_lock);          spin_lock(&ccs_query_list_lock);
2401          list_for_each(tmp, &ccs_query_list) {          list_for_each(tmp, &ccs_query_list) {
2402                  struct ccs_query_entry *ptr                  struct ccs_query_entry *ptr
# Line 2148  static int ccs_write_answer(struct ccs_i Line 2408  static int ccs_write_answer(struct ccs_i
2408                  break;                  break;
2409          }          }
2410          spin_unlock(&ccs_query_list_lock);          spin_unlock(&ccs_query_list_lock);
         /***** CRITICAL SECTION END *****/  
2411          return 0;          return 0;
2412  }  }
2413    
# Line 2156  static int ccs_write_answer(struct ccs_i Line 2415  static int ccs_write_answer(struct ccs_i
2415   * ccs_read_version: Get version.   * ccs_read_version: Get version.
2416   *   *
2417   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
  *  
  * Returns version information.  
2418   */   */
2419  static int ccs_read_version(struct ccs_io_buffer *head)  static void ccs_read_version(struct ccs_io_buffer *head)
2420  {  {
2421          if (!head->read_eof) {          if (head->read_eof)
2422                  ccs_io_printf(head, "1.7.0-pre");                  return;
2423                  head->read_eof = true;          ccs_io_printf(head, "1.7.1");
2424          }          head->read_eof = true;
         return 0;  
2425  }  }
2426    
2427  /**  /**
2428   * ccs_read_self_domain - Get the current process's domainname.   * ccs_read_self_domain - Get the current process's domainname.
2429   *   *
2430   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
  *  
  * Returns the current process's domainname.  
2431   */   */
2432  static int ccs_read_self_domain(struct ccs_io_buffer *head)  static void ccs_read_self_domain(struct ccs_io_buffer *head)
2433  {  {
2434          if (!head->read_eof) {          if (head->read_eof)
2435                  /*                  return;
2436                   * ccs_current_domain()->domainname != NULL          /*
2437                   * because every process belongs to a domain and           * ccs_current_domain()->domainname != NULL because every process
2438                   * the domain's name cannot be NULL.           * belongs to a domain and the domain's name cannot be NULL.
2439                   */           */
2440                  ccs_io_printf(head, "%s",          ccs_io_printf(head, "%s", ccs_current_domain()->domainname->name);
2441                                ccs_current_domain()->domainname->name);          head->read_eof = true;
                 head->read_eof = true;  
         }  
         return 0;  
2442  }  }
2443    
2444  /**  /**
# Line 2272  int ccs_open_control(const u8 type, stru Line 2523  int ccs_open_control(const u8 type, stru
2523                   */                   */
2524                  head->read = NULL;                  head->read = NULL;
2525                  head->poll = NULL;                  head->poll = NULL;
2526          } else if (type != CCS_QUERY &&          } else if (!head->poll) {
2527                     type != CCS_GRANTLOG && type != CCS_REJECTLOG) {                  /* Don't allocate read_buf for poll() access. */
                 /*  
                  * Don't allocate buffer for reading if the file is one of  
                  * /proc/ccs/grant_log , /proc/ccs/reject_log , /proc/ccs/query.  
                  */  
2528                  if (!head->readbuf_size)                  if (!head->readbuf_size)
2529                          head->readbuf_size = 4096 * 2;                          head->readbuf_size = 4096;
2530                  head->read_buf = kzalloc(head->readbuf_size, GFP_KERNEL);                  head->read_buf = kzalloc(head->readbuf_size, GFP_KERNEL);
2531                  if (!head->read_buf) {                  if (!head->read_buf) {
2532                          kfree(head);                          kfree(head);
# Line 2293  int ccs_open_control(const u8 type, stru Line 2540  int ccs_open_control(const u8 type, stru
2540                   */                   */
2541                  head->write = NULL;                  head->write = NULL;
2542          } else if (head->write) {          } else if (head->write) {
2543                  head->writebuf_size = 4096 * 2;                  head->writebuf_size = 4096;
2544                  head->write_buf = kzalloc(head->writebuf_size, GFP_KERNEL);                  head->write_buf = kzalloc(head->writebuf_size, GFP_KERNEL);
2545                  if (!head->write_buf) {                  if (!head->write_buf) {
2546                          kfree(head->read_buf);                          kfree(head->read_buf);
# Line 2314  int ccs_open_control(const u8 type, stru Line 2561  int ccs_open_control(const u8 type, stru
2561                  ccs_read_control(file, NULL, 0);                  ccs_read_control(file, NULL, 0);
2562          /*          /*
2563           * If the file is /proc/ccs/query , increment the observer counter.           * If the file is /proc/ccs/query , increment the observer counter.
2564           * The obserber counter is used by ccs_check_supervisor() to see if           * The obserber counter is used by ccs_supervisor() to see if
2565           * there is some process monitoring /proc/ccs/query.           * there is some process monitoring /proc/ccs/query.
2566           */           */
2567          else if (type == CCS_QUERY)          else if (type == CCS_QUERY)
# Line 2329  int ccs_open_control(const u8 type, stru Line 2576  int ccs_open_control(const u8 type, stru
2576   * @wait: Pointer to "poll_table".   * @wait: Pointer to "poll_table".
2577   *   *
2578   * Waits for read readiness.   * Waits for read readiness.
2579   * /proc/ccs/query is handled by /usr/lib/ccs/ccs-queryd and   * /proc/ccs/query is handled by /usr/sbin/ccs-queryd and
2580   * /proc/ccs/grant_log and /proc/ccs/reject_log are handled by   * /proc/ccs/grant_log and /proc/ccs/reject_log are handled by
2581   * /usr/lib/ccs/ccs-auditd.   * /usr/sbin/ccs-auditd .
2582   */   */
2583  int ccs_poll_control(struct file *file, poll_table *wait)  int ccs_poll_control(struct file *file, poll_table *wait)
2584  {  {
# Line 2362  int ccs_read_control(struct file *file, Line 2609  int ccs_read_control(struct file *file,
2609                  return -EFAULT;                  return -EFAULT;
2610          if (mutex_lock_interruptible(&head->io_sem))          if (mutex_lock_interruptible(&head->io_sem))
2611                  return -EINTR;                  return -EINTR;
2612          /* Call the policy handler. */          while (1) {
2613          len = head->read(head);                  /* Call the policy handler. */
2614          if (len < 0)                  head->read(head);
2615                  goto out;                  /* Write to buffer. */
2616          /* Write to buffer. */                  len = head->read_avail;
2617          len = head->read_avail;                  if (len || head->poll || head->read_eof)
2618                            break;
2619                    len = head->readbuf_size * 2;
2620                    cp = kzalloc(len, GFP_KERNEL);
2621                    if (!cp) {
2622                            len = -ENOMEM;
2623                            goto out;
2624                    }
2625                    kfree(head->read_buf);
2626                    head->read_buf = cp;
2627                    head->readbuf_size = len;
2628            }
2629          if (len > buffer_len)          if (len > buffer_len)
2630                  len = buffer_len;                  len = buffer_len;
2631          if (!len)          if (!len)
# Line 2416  int ccs_write_control(struct file *file, Line 2674  int ccs_write_control(struct file *file,
2674          while (avail_len > 0) {          while (avail_len > 0) {
2675                  char c;                  char c;
2676                  if (head->write_avail >= head->writebuf_size - 1) {                  if (head->write_avail >= head->writebuf_size - 1) {
2677                          error = -ENOMEM;                          const int len = head->writebuf_size * 2;
2678                          break;                          char *cp = kzalloc(len, GFP_KERNEL);
2679                  } else if (get_user(c, buffer)) {                          if (!cp) {
2680                                    error = -ENOMEM;
2681                                    break;
2682                            }
2683                            memmove(cp, cp0, head->write_avail);
2684                            kfree(cp0);
2685                            head->write_buf = cp;
2686                            cp0 = cp;
2687                            head->writebuf_size = len;
2688                    }
2689                    if (get_user(c, buffer)) {
2690                          error = -EFAULT;                          error = -EFAULT;
2691                          break;                          break;
2692                  }                  }
Legend:
Removed from v.2915  
changed lines
  Added in v.3275
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
サイト情報
ソフトウェアを探す
ソフトウェアを作る
コミュニティ
ヘルプ