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

TOMOYO

Subversion リポジトリの参照

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

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

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

branches/ccs-patch/security/ccsecurity/domain.c revision 2930 by kumaneko, Fri Aug 21 01:55:58 2009 UTC trunk/1.7.x/ccs-patch/security/ccsecurity/domain.c revision 2951 by kumaneko, Tue Aug 25 04:26:20 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.0-pre   2009/08/24
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 36  struct ccs_domain_info ccs_kernel_domain Line 36  struct ccs_domain_info ccs_kernel_domain
36  LIST_HEAD(ccs_domain_list);  LIST_HEAD(ccs_domain_list);
37    
38  /**  /**
  * ccs_get_last_name - Get last component of a domainname.  
  *  
  * @domain: Pointer to "struct ccs_domain_info".  
  *  
  * Returns the last component of the domainname.  
  */  
 const char *ccs_get_last_name(const struct ccs_domain_info *domain)  
 {  
         const char *cp0 = domain->domainname->name;  
         const char *cp1 = strrchr(cp0, ' ');  
         if (cp1)  
                 return cp1 + 1;  
         return cp0;  
 }  
   
 /**  
39   * ccs_audit_execute_handler_log - Audit execute_handler log.   * ccs_audit_execute_handler_log - Audit execute_handler log.
40   *   *
41   * @ee:         Pointer to "struct ccs_execve_entry".   * @ee:         Pointer to "struct ccs_execve_entry".
# Line 64  static int ccs_audit_execute_handler_log Line 48  static int ccs_audit_execute_handler_log
48  {  {
49          struct ccs_request_info *r = &ee->r;          struct ccs_request_info *r = &ee->r;
50          const char *handler = ee->handler->name;          const char *handler = ee->handler->name;
51          r->mode = ccs_flags(r->domain, CCS_MAC_EXECUTE);          r->mode = ccs_get_mode(r->profile, CCS_MAC_FILE_EXECUTE);
52          return ccs_write_audit_log(true, r, "%s %s\n",          return ccs_write_audit_log(true, r, "%s %s\n",
53                                     is_default ? CCS_KEYWORD_EXECUTE_HANDLER :                                     is_default ? CCS_KEYWORD_EXECUTE_HANDLER :
54                                     CCS_KEYWORD_DENIED_EXECUTE_HANDLER, handler);                                     CCS_KEYWORD_DENIED_EXECUTE_HANDLER, handler);
# Line 81  static int ccs_audit_domain_creation_log Line 65  static int ccs_audit_domain_creation_log
65  {  {
66          int error;          int error;
67          struct ccs_request_info r;          struct ccs_request_info r;
68          ccs_init_request_info(&r, domain, CCS_MAC_EXECUTE);          ccs_init_request_info(&r, domain, CCS_MAC_FILE_EXECUTE);
69          error = ccs_write_audit_log(false, &r, "use_profile %u\n", r.profile);          error = ccs_write_audit_log(false, &r, "use_profile %u\n", r.profile);
70          return error;          return error;
71  }  }
# Line 160  bool ccs_read_domain_initializer_policy( Line 144  bool ccs_read_domain_initializer_policy(
144  {  {
145          struct list_head *pos;          struct list_head *pos;
146          bool done = true;          bool done = true;
         ccs_assert_read_lock();  
147          list_for_each_cookie(pos, head->read_var2,          list_for_each_cookie(pos, head->read_var2,
148                               &ccs_domain_initializer_list) {                               &ccs_domain_initializer_list) {
149                  const char *no;                  const char *no;
# Line 168  bool ccs_read_domain_initializer_policy( Line 151  bool ccs_read_domain_initializer_policy(
151                  const char *domain = "";                  const char *domain = "";
152                  struct ccs_domain_initializer_entry *ptr;                  struct ccs_domain_initializer_entry *ptr;
153                  ptr = list_entry(pos, struct ccs_domain_initializer_entry,                  ptr = list_entry(pos, struct ccs_domain_initializer_entry,
154                                    list);                                   list);
155                  if (ptr->is_deleted)                  if (ptr->is_deleted)
156                          continue;                          continue;
157                  no = ptr->is_not ? "no_" : "";                  no = ptr->is_not ? "no_" : "";
# Line 176  bool ccs_read_domain_initializer_policy( Line 159  bool ccs_read_domain_initializer_policy(
159                          from = " from ";                          from = " from ";
160                          domain = ptr->domainname->name;                          domain = ptr->domainname->name;
161                  }                  }
162                  done = ccs_io_printf(head,                  done = ccs_io_printf(head, "%s" CCS_KEYWORD_INITIALIZE_DOMAIN
163                                       "%s" CCS_KEYWORD_INITIALIZE_DOMAIN "%s%s%s\n",                                       "%s%s%s\n", no, ptr->program->name, from,
164                                       no, ptr->program->name, from, domain);                                       domain);
165                  if (!done)                  if (!done)
166                          break;                          break;
167          }          }
# Line 225  static bool ccs_is_domain_initializer(co Line 208  static bool ccs_is_domain_initializer(co
208  {  {
209          struct ccs_domain_initializer_entry *ptr;          struct ccs_domain_initializer_entry *ptr;
210          bool flag = false;          bool flag = false;
         ccs_assert_read_lock();  
211          list_for_each_entry_rcu(ptr, &ccs_domain_initializer_list, list) {          list_for_each_entry_rcu(ptr, &ccs_domain_initializer_list, list) {
212                  if (ptr->is_deleted)                  if (ptr->is_deleted)
213                          continue;                          continue;
# Line 343  bool ccs_read_domain_keeper_policy(struc Line 325  bool ccs_read_domain_keeper_policy(struc
325  {  {
326          struct list_head *pos;          struct list_head *pos;
327          bool done = true;          bool done = true;
         ccs_assert_read_lock();  
328          list_for_each_cookie(pos, head->read_var2,          list_for_each_cookie(pos, head->read_var2,
329                               &ccs_domain_keeper_list) {                               &ccs_domain_keeper_list) {
330                  struct ccs_domain_keeper_entry *ptr;                  struct ccs_domain_keeper_entry *ptr;
# Line 385  static bool ccs_is_domain_keeper(const s Line 366  static bool ccs_is_domain_keeper(const s
366  {  {
367          struct ccs_domain_keeper_entry *ptr;          struct ccs_domain_keeper_entry *ptr;
368          bool flag = false;          bool flag = false;
         ccs_assert_read_lock();  
369          list_for_each_entry_rcu(ptr, &ccs_domain_keeper_list, list) {          list_for_each_entry_rcu(ptr, &ccs_domain_keeper_list, list) {
370                  if (ptr->is_deleted)                  if (ptr->is_deleted)
371                          continue;                          continue;
# Line 471  bool ccs_read_aggregator_policy(struct c Line 451  bool ccs_read_aggregator_policy(struct c
451  {  {
452          struct list_head *pos;          struct list_head *pos;
453          bool done = true;          bool done = true;
         ccs_assert_read_lock();  
454          list_for_each_cookie(pos, head->read_var2, &ccs_aggregator_list) {          list_for_each_cookie(pos, head->read_var2, &ccs_aggregator_list) {
455                  struct ccs_aggregator_entry *ptr;                  struct ccs_aggregator_entry *ptr;
456                  ptr = list_entry(pos, struct ccs_aggregator_entry, list);                  ptr = list_entry(pos, struct ccs_aggregator_entry, list);
# Line 595  static int ccs_find_next_domain(struct c Line 574  static int ccs_find_next_domain(struct c
574          struct ccs_domain_info *domain = NULL;          struct ccs_domain_info *domain = NULL;
575          const char *old_domain_name = r->domain->domainname->name;          const char *old_domain_name = r->domain->domainname->name;
576          struct linux_binprm *bprm = ee->bprm;          struct linux_binprm *bprm = ee->bprm;
         const u8 mode = r->mode;  
         const bool is_enforce = (mode == 3);  
577          const u32 ccs_flags = current->ccs_flags;          const u32 ccs_flags = current->ccs_flags;
578          char *new_domain_name = NULL;          struct ccs_path_info rn = { }; /* real name */
         struct ccs_path_info rn; /* real name */  
579          struct ccs_path_info ln; /* last name */          struct ccs_path_info ln; /* last name */
580          int retval;          int retval;
581          ccs_assert_read_lock();          bool need_kfree = false;
582            ln.name = ccs_last_word(old_domain_name);
583            ccs_fill_path_info(&ln);
584   retry:   retry:
585          current->ccs_flags = ccs_flags;          current->ccs_flags = ccs_flags;
586          r->cond = NULL;          r->cond = NULL;
587            if (need_kfree) {
588                    kfree(rn.name);
589                    need_kfree = false;
590            }
591    
592          /* Get symlink's pathname of program. */          /* Get symlink's pathname of program. */
593          retval = ccs_symlink_path(bprm->filename, ee);          retval = ccs_symlink_path(bprm->filename, &rn);
594          if (retval < 0)          if (retval < 0)
595                  goto out;                  goto out;
596            need_kfree = true;
         rn.name = ee->program_path;  
         ccs_fill_path_info(&rn);  
         ln.name = ccs_get_last_name(r->domain);  
         ccs_fill_path_info(&ln);  
597    
598          if (handler) {          if (handler) {
599                  if (ccs_pathcmp(&rn, handler)) {                  if (ccs_pathcmp(&rn, handler)) {
# Line 627  static int ccs_find_next_domain(struct c Line 606  static int ccs_find_next_domain(struct c
606                          }                          }
607                          goto out;                          goto out;
608                  }                  }
609                  goto calculate_domain;          } else {
         }  
   
         /* Check 'aggregator' directive. */  
         {  
610                  struct ccs_aggregator_entry *ptr;                  struct ccs_aggregator_entry *ptr;
611                  /* Is this program allowed to be aggregated? */                  /* Check 'aggregator' directive. */
612                  list_for_each_entry_rcu(ptr, &ccs_aggregator_list, list) {                  list_for_each_entry_rcu(ptr, &ccs_aggregator_list, list) {
613                          if (ptr->is_deleted ||                          if (ptr->is_deleted ||
614                              !ccs_path_matches_pattern(&rn, ptr->original_name))                              !ccs_path_matches_pattern(&rn, ptr->original_name))
615                                  continue;                                  continue;
616                          strncpy(ee->program_path, ptr->aggregated_name->name,                          kfree(rn.name);
617                                  CCS_MAX_PATHNAME_LEN - 1);                          need_kfree = false;
618                          ccs_fill_path_info(&rn);                          /* This is OK because it is read only. */
619                            rn = *ptr->aggregated_name;
620                          break;                          break;
621                  }                  }
         }  
622    
623          /* Check execute permission. */                  /* Check execute permission. */
624          r->mode = mode;                  retval = ccs_exec_perm(r, &rn);
625          retval = ccs_exec_perm(r, &rn);                  if (retval == 1)
626          if (retval == 1)                          goto retry;
627                  goto retry;                  if (retval < 0)
628          if (retval < 0)                          goto out;
629                  goto out;          }
630    
631   calculate_domain:          /* Calculate domain to transit to. */
         new_domain_name = ee->tmp;  
632          if (ccs_is_domain_initializer(r->domain->domainname, &rn, &ln)) {          if (ccs_is_domain_initializer(r->domain->domainname, &rn, &ln)) {
633                  /* Transit to the child of ccs_kernel_domain domain. */                  /* Transit to the child of ccs_kernel_domain domain. */
634                  snprintf(new_domain_name, CCS_EXEC_TMPSIZE - 1,                  snprintf(ee->tmp, CCS_EXEC_TMPSIZE - 1, ROOT_NAME " " "%s",
635                           ROOT_NAME " " "%s", ee->program_path);                           rn.name);
636          } else if (r->domain == &ccs_kernel_domain && !ccs_policy_loaded) {          } else if (r->domain == &ccs_kernel_domain && !ccs_policy_loaded) {
637                  /*                  /*
638                   * Needn't to transit from kernel domain before starting                   * Needn't to transit from kernel domain before starting
# Line 671  static int ccs_find_next_domain(struct c Line 645  static int ccs_find_next_domain(struct c
645                  domain = r->domain;                  domain = r->domain;
646          } else {          } else {
647                  /* Normal domain transition. */                  /* Normal domain transition. */
648                  snprintf(new_domain_name, CCS_EXEC_TMPSIZE - 1,                  snprintf(ee->tmp, CCS_EXEC_TMPSIZE - 1, "%s %s",
649                           "%s %s", old_domain_name, ee->program_path);                           old_domain_name, rn.name);
650          }          }
651          if (domain || strlen(new_domain_name) >= CCS_MAX_PATHNAME_LEN)          if (domain || strlen(ee->tmp) >= CCS_EXEC_TMPSIZE - 10)
652                  goto done;                  goto done;
653          domain = ccs_find_domain(new_domain_name);          domain = ccs_find_domain(ee->tmp);
654          if (domain)          if (domain)
655                  goto done;                  goto done;
656          if (is_enforce) {          if (r->mode == CCS_MAC_MODE_ENFORCING) {
657                  int error = ccs_supervisor(r,                  int error = ccs_supervisor(r, "# wants to create domain\n"
658                                                   "# wants to create domain\n"                                             "%s\n", ee->tmp);
                                                  "%s\n", new_domain_name);  
659                  if (error == 1)                  if (error == 1)
660                          goto retry;                          goto retry;
661                  if (error < 0)                  if (error < 0)
662                          goto done;                          goto done;
663          }          }
664          domain = ccs_find_or_assign_new_domain(new_domain_name, r->profile);          domain = ccs_find_or_assign_new_domain(ee->tmp, r->profile);
665          if (domain)          if (domain)
666                  ccs_audit_domain_creation_log(r->domain);                  ccs_audit_domain_creation_log(r->domain);
667   done:   done:
668          if (!domain) {          if (!domain) {
669                  printk(KERN_WARNING "ERROR: Domain '%s' not defined.\n",                  printk(KERN_WARNING "ERROR: Domain '%s' not defined.\n",
670                         new_domain_name);                         ee->tmp);
671                  if (is_enforce)                  if (r->mode == CCS_MAC_MODE_ENFORCING)
672                          retval = -EPERM;                          retval = -EPERM;
673                  else {                  else {
674                          retval = 0;                          retval = 0;
# Line 707  static int ccs_find_next_domain(struct c Line 680  static int ccs_find_next_domain(struct c
680   out:   out:
681          if (domain)          if (domain)
682                  r->domain = domain;                  r->domain = domain;
683            if (need_kfree)
684                    kfree(rn.name);
685          return retval;          return retval;
686  }  }
687    
# Line 748  static int ccs_environ(struct ccs_execve Line 723  static int ccs_environ(struct ccs_execve
723                  while (offset < PAGE_SIZE) {                  while (offset < PAGE_SIZE) {
724                          const char *kaddr = ee->dump.data;                          const char *kaddr = ee->dump.data;
725                          const unsigned char c = kaddr[offset++];                          const unsigned char c = kaddr[offset++];
726                          if (c && arg_len < CCS_MAX_PATHNAME_LEN - 10) {                          if (c && arg_len < CCS_EXEC_TMPSIZE - 10) {
727                                  if (c == '=') {                                  if (c == '=') {
728                                          arg_ptr[arg_len++] = '\0';                                          arg_ptr[arg_len++] = '\0';
729                                  } else if (c == '\\') {                                  } else if (c == '\\') {
# Line 900  static struct ccs_execve_entry *ccs_allo Line 875  static struct ccs_execve_entry *ccs_allo
875          struct ccs_execve_entry *ee = kzalloc(sizeof(*ee), GFP_KERNEL);          struct ccs_execve_entry *ee = kzalloc(sizeof(*ee), GFP_KERNEL);
876          if (!ee)          if (!ee)
877                  return NULL;                  return NULL;
         ee->program_path = kzalloc(CCS_MAX_PATHNAME_LEN, GFP_KERNEL);  
878          ee->tmp = kzalloc(CCS_EXEC_TMPSIZE, GFP_KERNEL);          ee->tmp = kzalloc(CCS_EXEC_TMPSIZE, GFP_KERNEL);
879          if (!ee->program_path || !ee->tmp) {          if (!ee->tmp) {
                 kfree(ee->program_path);  
                 kfree(ee->tmp);  
880                  kfree(ee);                  kfree(ee);
881                  return NULL;                  return NULL;
882          }          }
# Line 950  static void ccs_free_execve_entry(struct Line 922  static void ccs_free_execve_entry(struct
922          spin_lock(&ccs_execve_list_lock);          spin_lock(&ccs_execve_list_lock);
923          list_del(&ee->list);          list_del(&ee->list);
924          spin_unlock(&ccs_execve_list_lock);          spin_unlock(&ccs_execve_list_lock);
925          kfree(ee->program_path);          kfree(ee->handler_path);
926          kfree(ee->tmp);          kfree(ee->tmp);
927          kfree(ee->dump.data);          kfree(ee->dump.data);
928          ccs_read_unlock(ee->reader_idx);          ccs_read_unlock(ee->reader_idx);
# Line 1076  static int ccs_try_alt_exec(struct ccs_e Line 1048  static int ccs_try_alt_exec(struct ccs_e
1048                          kfree(exe);                          kfree(exe);
1049                  } else {                  } else {
1050                          exe = ee->tmp;                          exe = ee->tmp;
1051                          strncpy(ee->tmp, "<unknown>", CCS_EXEC_TMPSIZE - 1);                          snprintf(ee->tmp, CCS_EXEC_TMPSIZE - 1, "<unknown>");
1052                          retval = copy_strings_kernel(1, &exe, bprm);                          retval = copy_strings_kernel(1, &exe, bprm);
1053                  }                  }
1054                  if (retval < 0)                  if (retval < 0)
# Line 1087  static int ccs_try_alt_exec(struct ccs_e Line 1059  static int ccs_try_alt_exec(struct ccs_e
1059          /* Set argv[1] */          /* Set argv[1] */
1060          {          {
1061                  char *cp = ee->tmp;                  char *cp = ee->tmp;
1062                  strncpy(ee->tmp, ccs_current_domain()->domainname->name,                  snprintf(ee->tmp, CCS_EXEC_TMPSIZE - 1, "%s",
1063                          CCS_EXEC_TMPSIZE - 1);                           ccs_current_domain()->domainname->name);
1064                  retval = copy_strings_kernel(1, &cp, bprm);                  retval = copy_strings_kernel(1, &cp, bprm);
1065                  if (retval < 0)                  if (retval < 0)
1066                          goto out;                          goto out;
# Line 1098  static int ccs_try_alt_exec(struct ccs_e Line 1070  static int ccs_try_alt_exec(struct ccs_e
1070          /* Set argv[0] */          /* Set argv[0] */
1071          {          {
1072                  int depth = ccs_get_root_depth();                  int depth = ccs_get_root_depth();
1073                  char *cp = ee->program_path;                  int len = ee->handler->total_len + 1;
1074                  strncpy(cp, ee->handler->name, CCS_MAX_PATHNAME_LEN - 1);                  char *cp = kmalloc(len, GFP_KERNEL);
1075                    if (!cp) {
1076                            retval = ENOMEM;
1077                            goto out;
1078                    }
1079                    ee->handler_path = cp;
1080                    memmove(cp, ee->handler->name, len);
1081                  ccs_unescape(cp);                  ccs_unescape(cp);
1082                  retval = -ENOENT;                  retval = -ENOENT;
1083                  if (!*cp || *cp != '/')                  if (!*cp || *cp != '/')
# Line 1111  static int ccs_try_alt_exec(struct ccs_e Line 1089  static int ccs_try_alt_exec(struct ccs_e
1089                                  goto out;                                  goto out;
1090                          depth--;                          depth--;
1091                  }                  }
1092                  memmove(ee->program_path, cp, strlen(cp) + 1);                  memmove(ee->handler_path, cp, strlen(cp) + 1);
1093                  cp = ee->program_path;                  cp = ee->handler_path;
1094                  retval = copy_strings_kernel(1, &cp, bprm);                  retval = copy_strings_kernel(1, &cp, bprm);
1095                  if (retval < 0)                  if (retval < 0)
1096                          goto out;                          goto out;
# Line 1125  static int ccs_try_alt_exec(struct ccs_e Line 1103  static int ccs_try_alt_exec(struct ccs_e
1103  #endif  #endif
1104    
1105          /* OK, now restart the process with execute handler program's dentry. */          /* OK, now restart the process with execute handler program's dentry. */
1106          filp = open_exec(ee->program_path);          filp = open_exec(ee->handler_path);
1107          if (IS_ERR(filp)) {          if (IS_ERR(filp)) {
1108                  retval = PTR_ERR(filp);                  retval = PTR_ERR(filp);
1109                  goto out;                  goto out;
1110          }          }
1111          bprm->file = filp;          bprm->file = filp;
1112          bprm->filename = ee->program_path;          bprm->filename = ee->handler_path;
1113  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0)  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0)
1114          bprm->interp = bprm->filename;          bprm->interp = bprm->filename;
1115  #endif  #endif
1116          retval = prepare_binprm(bprm);          retval = prepare_binprm(bprm);
1117          if (retval < 0)          if (retval < 0)
1118                  goto out;                  goto out;
1119          {          task->ccs_flags |= CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
1120                  /*          retval = ccs_find_next_domain(ee);
1121                   * Backup ee->program_path because ccs_find_next_domain() will          task->ccs_flags &= ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
                  * overwrite ee->program_path and ee->tmp.  
                  */  
                 const int len = strlen(ee->program_path) + 1;  
                 char *cp = kzalloc(len, GFP_KERNEL);  
                 if (!cp) {  
                         retval = -ENOMEM;  
                         goto out;  
                 }  
                 memmove(cp, ee->program_path, len);  
                 bprm->filename = cp;  
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0)  
                 bprm->interp = bprm->filename;  
 #endif  
                 task->ccs_flags |= CCS_DONT_SLEEP_ON_ENFORCE_ERROR;  
                 retval = ccs_find_next_domain(ee);  
                 task->ccs_flags &= ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;  
                 /* Restore ee->program_path for search_binary_handler(). */  
                 memmove(ee->program_path, cp, len);  
                 bprm->filename = ee->program_path;  
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0)  
                 bprm->interp = bprm->filename;  
 #endif  
                 kfree(cp);  
         }  
1122   out:   out:
1123          return retval;          return retval;
1124  }  }
# Line 1186  static bool ccs_find_execute_handler(str Line 1140  static bool ccs_find_execute_handler(str
1140          const struct ccs_domain_info *domain = ccs_current_domain();          const struct ccs_domain_info *domain = ccs_current_domain();
1141          struct ccs_acl_info *ptr;          struct ccs_acl_info *ptr;
1142          bool found = false;          bool found = false;
         ccs_assert_read_lock();  
1143          /*          /*
1144           * Don't use execute handler if the current process is           * Don't use execute handler if the current process is
1145           * marked as execute handler to avoid infinite execute handler loop.           * marked as execute handler to avoid infinite execute handler loop.
# Line 1289  int ccs_start_execve(struct linux_binprm Line 1242  int ccs_start_execve(struct linux_binprm
1242                  ccs_load_policy(bprm->filename);                  ccs_load_policy(bprm->filename);
1243          if (!ee)          if (!ee)
1244                  return -ENOMEM;                  return -ENOMEM;
1245          ccs_init_request_info(&ee->r, NULL, CCS_MAC_EXECUTE);          ccs_init_request_info(&ee->r, NULL, CCS_MAC_FILE_EXECUTE);
1246          ee->r.ee = ee;          ee->r.ee = ee;
1247          ee->bprm = bprm;          ee->bprm = bprm;
1248          ee->r.obj = &ee->obj;          ee->r.obj = &ee->obj;
# Line 1314  int ccs_start_execve(struct linux_binprm Line 1267  int ccs_start_execve(struct linux_binprm
1267   ok:   ok:
1268          if (retval < 0)          if (retval < 0)
1269                  goto out;                  goto out;
1270          ee->r.mode = ccs_flags(ee->r.domain, CCS_MAC_ENVIRON);          ee->r.mode = ccs_get_mode(ee->r.profile, CCS_MAC_ENVIRON);
1271          retval = ccs_environ(ee);          retval = ccs_environ(ee);
1272          if (retval < 0)          if (retval < 0)
1273                  goto out;                  goto out;
# Line 1337  void ccs_finish_execve(int retval) Line 1290  void ccs_finish_execve(int retval)
1290  {  {
1291          struct task_struct *task = current;          struct task_struct *task = current;
1292          struct ccs_execve_entry *ee = ccs_find_execve_entry();          struct ccs_execve_entry *ee = ccs_find_execve_entry();
         ccs_assert_read_lock();  
1293          task->ccs_flags &= ~CCS_CHECK_READ_FOR_OPEN_EXEC;          task->ccs_flags &= ~CCS_CHECK_READ_FOR_OPEN_EXEC;
1294          if (!ee)          if (!ee)
1295                  return;                  return;
Legend:
Removed from v.2930  
changed lines
  Added in v.2951
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
サイト情報
ソフトウェアを探す
ソフトウェアを作る
コミュニティ
ヘルプ