2 * security/tomoyo/domain.c
4 * Implementation of the Domain-Based Mandatory Access Control.
6 * Copyright (C) 2005-2009 NTT DATA CORPORATION
8 * Version: 2.2.0 2009/04/01
13 #include <linux/binfmts.h>
14 #include <linux/slab.h>
16 /* Variables definitions.*/
18 /* The initial domain. */
19 struct tomoyo_domain_info tomoyo_kernel_domain
;
22 * tomoyo_domain_list is used for holding list of domains.
23 * The ->acl_info_list of "struct tomoyo_domain_info" is used for holding
24 * permissions (e.g. "allow_read /lib/libc-2.5.so") given to each domain.
26 * An entry is added by
28 * # ( echo "<kernel>"; echo "allow_execute /sbin/init" ) > \
29 * /sys/kernel/security/tomoyo/domain_policy
33 * # ( echo "<kernel>"; echo "delete allow_execute /sbin/init" ) > \
34 * /sys/kernel/security/tomoyo/domain_policy
36 * and all entries are retrieved by
38 * # cat /sys/kernel/security/tomoyo/domain_policy
40 * A domain is added by
42 * # echo "<kernel>" > /sys/kernel/security/tomoyo/domain_policy
46 * # echo "delete <kernel>" > /sys/kernel/security/tomoyo/domain_policy
48 * and all domains are retrieved by
50 * # grep '^<kernel>' /sys/kernel/security/tomoyo/domain_policy
52 * Normally, a domainname is monotonically getting longer because a domainname
53 * which the process will belong to if an execve() operation succeeds is
54 * defined as a concatenation of "current domainname" + "pathname passed to
56 * See tomoyo_domain_initializer_list and tomoyo_domain_keeper_list for
59 LIST_HEAD(tomoyo_domain_list
);
62 * tomoyo_get_last_name - Get last component of a domainname.
64 * @domain: Pointer to "struct tomoyo_domain_info".
66 * Returns the last component of the domainname.
68 const char *tomoyo_get_last_name(const struct tomoyo_domain_info
*domain
)
70 const char *cp0
= domain
->domainname
->name
;
71 const char *cp1
= strrchr(cp0
, ' ');
79 * tomoyo_domain_initializer_list is used for holding list of programs which
80 * triggers reinitialization of domainname. Normally, a domainname is
81 * monotonically getting longer. But sometimes, we restart daemon programs.
82 * It would be convenient for us that "a daemon started upon system boot" and
83 * "the daemon restarted from console" belong to the same domain. Thus, TOMOYO
84 * provides a way to shorten domainnames.
86 * An entry is added by
88 * # echo 'initialize_domain /usr/sbin/httpd' > \
89 * /sys/kernel/security/tomoyo/exception_policy
93 * # echo 'delete initialize_domain /usr/sbin/httpd' > \
94 * /sys/kernel/security/tomoyo/exception_policy
96 * and all entries are retrieved by
98 * # grep ^initialize_domain /sys/kernel/security/tomoyo/exception_policy
100 * In the example above, /usr/sbin/httpd will belong to
101 * "<kernel> /usr/sbin/httpd" domain.
103 * You may specify a domainname using "from" keyword.
104 * "initialize_domain /usr/sbin/httpd from <kernel> /etc/rc.d/init.d/httpd"
105 * will cause "/usr/sbin/httpd" executed from "<kernel> /etc/rc.d/init.d/httpd"
106 * domain to belong to "<kernel> /usr/sbin/httpd" domain.
108 * You may add "no_" prefix to "initialize_domain".
109 * "initialize_domain /usr/sbin/httpd" and
110 * "no_initialize_domain /usr/sbin/httpd from <kernel> /etc/rc.d/init.d/httpd"
111 * will cause "/usr/sbin/httpd" to belong to "<kernel> /usr/sbin/httpd" domain
112 * unless executed from "<kernel> /etc/rc.d/init.d/httpd" domain.
114 LIST_HEAD(tomoyo_domain_initializer_list
);
117 * tomoyo_update_domain_initializer_entry - Update "struct tomoyo_domain_initializer_entry" list.
119 * @domainname: The name of domain. May be NULL.
120 * @program: The name of program.
121 * @is_not: True if it is "no_initialize_domain" entry.
122 * @is_delete: True if it is a delete request.
124 * Returns 0 on success, negative value otherwise.
126 * Caller holds tomoyo_read_lock().
128 static int tomoyo_update_domain_initializer_entry(const char *domainname
,
131 const bool is_delete
)
133 struct tomoyo_domain_initializer_entry
*entry
= NULL
;
134 struct tomoyo_domain_initializer_entry
*ptr
;
135 const struct tomoyo_path_info
*saved_program
= NULL
;
136 const struct tomoyo_path_info
*saved_domainname
= NULL
;
137 int error
= is_delete
? -ENOENT
: -ENOMEM
;
138 bool is_last_name
= false;
140 if (!tomoyo_is_correct_path(program
, 1, -1, -1))
141 return -EINVAL
; /* No patterns allowed. */
143 if (!tomoyo_is_domain_def(domainname
) &&
144 tomoyo_is_correct_path(domainname
, 1, -1, -1))
146 else if (!tomoyo_is_correct_domain(domainname
))
148 saved_domainname
= tomoyo_get_name(domainname
);
149 if (!saved_domainname
)
152 saved_program
= tomoyo_get_name(program
);
156 entry
= kmalloc(sizeof(*entry
), GFP_KERNEL
);
157 mutex_lock(&tomoyo_policy_lock
);
158 list_for_each_entry_rcu(ptr
, &tomoyo_domain_initializer_list
, list
) {
159 if (ptr
->is_not
!= is_not
||
160 ptr
->domainname
!= saved_domainname
||
161 ptr
->program
!= saved_program
)
163 ptr
->is_deleted
= is_delete
;
167 if (!is_delete
&& error
&& tomoyo_memory_ok(entry
)) {
168 entry
->domainname
= saved_domainname
;
169 saved_domainname
= NULL
;
170 entry
->program
= saved_program
;
171 saved_program
= NULL
;
172 entry
->is_not
= is_not
;
173 entry
->is_last_name
= is_last_name
;
174 list_add_tail_rcu(&entry
->list
,
175 &tomoyo_domain_initializer_list
);
179 mutex_unlock(&tomoyo_policy_lock
);
181 tomoyo_put_name(saved_domainname
);
182 tomoyo_put_name(saved_program
);
188 * tomoyo_read_domain_initializer_policy - Read "struct tomoyo_domain_initializer_entry" list.
190 * @head: Pointer to "struct tomoyo_io_buffer".
192 * Returns true on success, false otherwise.
194 * Caller holds tomoyo_read_lock().
196 bool tomoyo_read_domain_initializer_policy(struct tomoyo_io_buffer
*head
)
198 struct list_head
*pos
;
201 list_for_each_cookie(pos
, head
->read_var2
,
202 &tomoyo_domain_initializer_list
) {
204 const char *from
= "";
205 const char *domain
= "";
206 struct tomoyo_domain_initializer_entry
*ptr
;
207 ptr
= list_entry(pos
, struct tomoyo_domain_initializer_entry
,
211 no
= ptr
->is_not
? "no_" : "";
212 if (ptr
->domainname
) {
214 domain
= ptr
->domainname
->name
;
216 done
= tomoyo_io_printf(head
,
217 "%s" TOMOYO_KEYWORD_INITIALIZE_DOMAIN
218 "%s%s%s\n", no
, ptr
->program
->name
,
227 * tomoyo_write_domain_initializer_policy - Write "struct tomoyo_domain_initializer_entry" list.
229 * @data: String to parse.
230 * @is_not: True if it is "no_initialize_domain" entry.
231 * @is_delete: True if it is a delete request.
233 * Returns 0 on success, negative value otherwise.
235 * Caller holds tomoyo_read_lock().
237 int tomoyo_write_domain_initializer_policy(char *data
, const bool is_not
,
238 const bool is_delete
)
240 char *cp
= strstr(data
, " from ");
244 return tomoyo_update_domain_initializer_entry(cp
+ 6, data
,
248 return tomoyo_update_domain_initializer_entry(NULL
, data
, is_not
,
253 * tomoyo_is_domain_initializer - Check whether the given program causes domainname reinitialization.
255 * @domainname: The name of domain.
256 * @program: The name of program.
257 * @last_name: The last component of @domainname.
259 * Returns true if executing @program reinitializes domain transition,
262 * Caller holds tomoyo_read_lock().
264 static bool tomoyo_is_domain_initializer(const struct tomoyo_path_info
*
266 const struct tomoyo_path_info
*program
,
267 const struct tomoyo_path_info
*
270 struct tomoyo_domain_initializer_entry
*ptr
;
273 list_for_each_entry_rcu(ptr
, &tomoyo_domain_initializer_list
, list
) {
276 if (ptr
->domainname
) {
277 if (!ptr
->is_last_name
) {
278 if (ptr
->domainname
!= domainname
)
281 if (tomoyo_pathcmp(ptr
->domainname
, last_name
))
285 if (tomoyo_pathcmp(ptr
->program
, program
))
297 * tomoyo_domain_keeper_list is used for holding list of domainnames which
298 * suppresses domain transition. Normally, a domainname is monotonically
299 * getting longer. But sometimes, we want to suppress domain transition.
300 * It would be convenient for us that programs executed from a login session
301 * belong to the same domain. Thus, TOMOYO provides a way to suppress domain
304 * An entry is added by
306 * # echo 'keep_domain <kernel> /usr/sbin/sshd /bin/bash' > \
307 * /sys/kernel/security/tomoyo/exception_policy
311 * # echo 'delete keep_domain <kernel> /usr/sbin/sshd /bin/bash' > \
312 * /sys/kernel/security/tomoyo/exception_policy
314 * and all entries are retrieved by
316 * # grep ^keep_domain /sys/kernel/security/tomoyo/exception_policy
318 * In the example above, any process which belongs to
319 * "<kernel> /usr/sbin/sshd /bin/bash" domain will remain in that domain,
320 * unless explicitly specified by "initialize_domain" or "no_keep_domain".
322 * You may specify a program using "from" keyword.
323 * "keep_domain /bin/pwd from <kernel> /usr/sbin/sshd /bin/bash"
324 * will cause "/bin/pwd" executed from "<kernel> /usr/sbin/sshd /bin/bash"
325 * domain to remain in "<kernel> /usr/sbin/sshd /bin/bash" domain.
327 * You may add "no_" prefix to "keep_domain".
328 * "keep_domain <kernel> /usr/sbin/sshd /bin/bash" and
329 * "no_keep_domain /usr/bin/passwd from <kernel> /usr/sbin/sshd /bin/bash" will
330 * cause "/usr/bin/passwd" to belong to
331 * "<kernel> /usr/sbin/sshd /bin/bash /usr/bin/passwd" domain, unless
332 * explicitly specified by "initialize_domain".
334 LIST_HEAD(tomoyo_domain_keeper_list
);
337 * tomoyo_update_domain_keeper_entry - Update "struct tomoyo_domain_keeper_entry" list.
339 * @domainname: The name of domain.
340 * @program: The name of program. May be NULL.
341 * @is_not: True if it is "no_keep_domain" entry.
342 * @is_delete: True if it is a delete request.
344 * Returns 0 on success, negative value otherwise.
346 * Caller holds tomoyo_read_lock().
348 static int tomoyo_update_domain_keeper_entry(const char *domainname
,
351 const bool is_delete
)
353 struct tomoyo_domain_keeper_entry
*entry
= NULL
;
354 struct tomoyo_domain_keeper_entry
*ptr
;
355 const struct tomoyo_path_info
*saved_domainname
= NULL
;
356 const struct tomoyo_path_info
*saved_program
= NULL
;
357 int error
= is_delete
? -ENOENT
: -ENOMEM
;
358 bool is_last_name
= false;
360 if (!tomoyo_is_domain_def(domainname
) &&
361 tomoyo_is_correct_path(domainname
, 1, -1, -1))
363 else if (!tomoyo_is_correct_domain(domainname
))
366 if (!tomoyo_is_correct_path(program
, 1, -1, -1))
368 saved_program
= tomoyo_get_name(program
);
372 saved_domainname
= tomoyo_get_name(domainname
);
373 if (!saved_domainname
)
376 entry
= kmalloc(sizeof(*entry
), GFP_KERNEL
);
377 mutex_lock(&tomoyo_policy_lock
);
378 list_for_each_entry_rcu(ptr
, &tomoyo_domain_keeper_list
, list
) {
379 if (ptr
->is_not
!= is_not
||
380 ptr
->domainname
!= saved_domainname
||
381 ptr
->program
!= saved_program
)
383 ptr
->is_deleted
= is_delete
;
387 if (!is_delete
&& error
&& tomoyo_memory_ok(entry
)) {
388 entry
->domainname
= saved_domainname
;
389 saved_domainname
= NULL
;
390 entry
->program
= saved_program
;
391 saved_program
= NULL
;
392 entry
->is_not
= is_not
;
393 entry
->is_last_name
= is_last_name
;
394 list_add_tail_rcu(&entry
->list
, &tomoyo_domain_keeper_list
);
398 mutex_unlock(&tomoyo_policy_lock
);
400 tomoyo_put_name(saved_domainname
);
401 tomoyo_put_name(saved_program
);
407 * tomoyo_write_domain_keeper_policy - Write "struct tomoyo_domain_keeper_entry" list.
409 * @data: String to parse.
410 * @is_not: True if it is "no_keep_domain" entry.
411 * @is_delete: True if it is a delete request.
413 * Caller holds tomoyo_read_lock().
415 int tomoyo_write_domain_keeper_policy(char *data
, const bool is_not
,
416 const bool is_delete
)
418 char *cp
= strstr(data
, " from ");
422 return tomoyo_update_domain_keeper_entry(cp
+ 6, data
, is_not
,
425 return tomoyo_update_domain_keeper_entry(data
, NULL
, is_not
, is_delete
);
429 * tomoyo_read_domain_keeper_policy - Read "struct tomoyo_domain_keeper_entry" list.
431 * @head: Pointer to "struct tomoyo_io_buffer".
433 * Returns true on success, false otherwise.
435 * Caller holds tomoyo_read_lock().
437 bool tomoyo_read_domain_keeper_policy(struct tomoyo_io_buffer
*head
)
439 struct list_head
*pos
;
442 list_for_each_cookie(pos
, head
->read_var2
,
443 &tomoyo_domain_keeper_list
) {
444 struct tomoyo_domain_keeper_entry
*ptr
;
446 const char *from
= "";
447 const char *program
= "";
449 ptr
= list_entry(pos
, struct tomoyo_domain_keeper_entry
, list
);
452 no
= ptr
->is_not
? "no_" : "";
455 program
= ptr
->program
->name
;
457 done
= tomoyo_io_printf(head
,
458 "%s" TOMOYO_KEYWORD_KEEP_DOMAIN
459 "%s%s%s\n", no
, program
, from
,
460 ptr
->domainname
->name
);
468 * tomoyo_is_domain_keeper - Check whether the given program causes domain transition suppression.
470 * @domainname: The name of domain.
471 * @program: The name of program.
472 * @last_name: The last component of @domainname.
474 * Returns true if executing @program supresses domain transition,
477 * Caller holds tomoyo_read_lock().
479 static bool tomoyo_is_domain_keeper(const struct tomoyo_path_info
*domainname
,
480 const struct tomoyo_path_info
*program
,
481 const struct tomoyo_path_info
*last_name
)
483 struct tomoyo_domain_keeper_entry
*ptr
;
486 list_for_each_entry_rcu(ptr
, &tomoyo_domain_keeper_list
, list
) {
489 if (!ptr
->is_last_name
) {
490 if (ptr
->domainname
!= domainname
)
493 if (tomoyo_pathcmp(ptr
->domainname
, last_name
))
496 if (ptr
->program
&& tomoyo_pathcmp(ptr
->program
, program
))
508 * tomoyo_alias_list is used for holding list of symlink's pathnames which are
509 * allowed to be passed to an execve() request. Normally, the domainname which
510 * the current process will belong to after execve() succeeds is calculated
511 * using dereferenced pathnames. But some programs behave differently depending
512 * on the name passed to argv[0]. For busybox, calculating domainname using
513 * dereferenced pathnames will cause all programs in the busybox to belong to
514 * the same domain. Thus, TOMOYO provides a way to allow use of symlink's
515 * pathname for checking execve()'s permission and calculating domainname which
516 * the current process will belong to after execve() succeeds.
518 * An entry is added by
520 * # echo 'alias /bin/busybox /bin/cat' > \
521 * /sys/kernel/security/tomoyo/exception_policy
525 * # echo 'delete alias /bin/busybox /bin/cat' > \
526 * /sys/kernel/security/tomoyo/exception_policy
528 * and all entries are retrieved by
530 * # grep ^alias /sys/kernel/security/tomoyo/exception_policy
532 * In the example above, if /bin/cat is a symlink to /bin/busybox and execution
533 * of /bin/cat is requested, permission is checked for /bin/cat rather than
534 * /bin/busybox and domainname which the current process will belong to after
535 * execve() succeeds is calculated using /bin/cat rather than /bin/busybox .
537 LIST_HEAD(tomoyo_alias_list
);
540 * tomoyo_update_alias_entry - Update "struct tomoyo_alias_entry" list.
542 * @original_name: The original program's real name.
543 * @aliased_name: The symbolic program's symbolic link's name.
544 * @is_delete: True if it is a delete request.
546 * Returns 0 on success, negative value otherwise.
548 * Caller holds tomoyo_read_lock().
550 static int tomoyo_update_alias_entry(const char *original_name
,
551 const char *aliased_name
,
552 const bool is_delete
)
554 struct tomoyo_alias_entry
*entry
= NULL
;
555 struct tomoyo_alias_entry
*ptr
;
556 const struct tomoyo_path_info
*saved_original_name
;
557 const struct tomoyo_path_info
*saved_aliased_name
;
558 int error
= is_delete
? -ENOENT
: -ENOMEM
;
560 if (!tomoyo_is_correct_path(original_name
, 1, -1, -1) ||
561 !tomoyo_is_correct_path(aliased_name
, 1, -1, -1))
562 return -EINVAL
; /* No patterns allowed. */
563 saved_original_name
= tomoyo_get_name(original_name
);
564 saved_aliased_name
= tomoyo_get_name(aliased_name
);
565 if (!saved_original_name
|| !saved_aliased_name
)
568 entry
= kmalloc(sizeof(*entry
), GFP_KERNEL
);
569 mutex_lock(&tomoyo_policy_lock
);
570 list_for_each_entry_rcu(ptr
, &tomoyo_alias_list
, list
) {
571 if (ptr
->original_name
!= saved_original_name
||
572 ptr
->aliased_name
!= saved_aliased_name
)
574 ptr
->is_deleted
= is_delete
;
578 if (!is_delete
&& error
&& tomoyo_memory_ok(entry
)) {
579 entry
->original_name
= saved_original_name
;
580 saved_original_name
= NULL
;
581 entry
->aliased_name
= saved_aliased_name
;
582 saved_aliased_name
= NULL
;
583 list_add_tail_rcu(&entry
->list
, &tomoyo_alias_list
);
587 mutex_unlock(&tomoyo_policy_lock
);
589 tomoyo_put_name(saved_original_name
);
590 tomoyo_put_name(saved_aliased_name
);
596 * tomoyo_read_alias_policy - Read "struct tomoyo_alias_entry" list.
598 * @head: Pointer to "struct tomoyo_io_buffer".
600 * Returns true on success, false otherwise.
602 * Caller holds tomoyo_read_lock().
604 bool tomoyo_read_alias_policy(struct tomoyo_io_buffer
*head
)
606 struct list_head
*pos
;
609 list_for_each_cookie(pos
, head
->read_var2
, &tomoyo_alias_list
) {
610 struct tomoyo_alias_entry
*ptr
;
612 ptr
= list_entry(pos
, struct tomoyo_alias_entry
, list
);
615 done
= tomoyo_io_printf(head
, TOMOYO_KEYWORD_ALIAS
"%s %s\n",
616 ptr
->original_name
->name
,
617 ptr
->aliased_name
->name
);
625 * tomoyo_write_alias_policy - Write "struct tomoyo_alias_entry" list.
627 * @data: String to parse.
628 * @is_delete: True if it is a delete request.
630 * Returns 0 on success, negative value otherwise.
632 * Caller holds tomoyo_read_lock().
634 int tomoyo_write_alias_policy(char *data
, const bool is_delete
)
636 char *cp
= strchr(data
, ' ');
641 return tomoyo_update_alias_entry(data
, cp
, is_delete
);
645 * tomoyo_find_or_assign_new_domain - Create a domain.
647 * @domainname: The name of domain.
648 * @profile: Profile number to assign if the domain was newly created.
650 * Returns pointer to "struct tomoyo_domain_info" on success, NULL otherwise.
652 * Caller holds tomoyo_read_lock().
654 struct tomoyo_domain_info
*tomoyo_find_or_assign_new_domain(const char *
658 struct tomoyo_domain_info
*entry
;
659 struct tomoyo_domain_info
*domain
;
660 const struct tomoyo_path_info
*saved_domainname
;
663 if (!tomoyo_is_correct_domain(domainname
))
665 saved_domainname
= tomoyo_get_name(domainname
);
666 if (!saved_domainname
)
668 entry
= kzalloc(sizeof(*entry
), GFP_KERNEL
);
669 mutex_lock(&tomoyo_policy_lock
);
670 list_for_each_entry_rcu(domain
, &tomoyo_domain_list
, list
) {
671 if (domain
->is_deleted
||
672 tomoyo_pathcmp(saved_domainname
, domain
->domainname
))
677 if (!found
&& tomoyo_memory_ok(entry
)) {
678 INIT_LIST_HEAD(&entry
->acl_info_list
);
679 entry
->domainname
= saved_domainname
;
680 saved_domainname
= NULL
;
681 entry
->profile
= profile
;
682 list_add_tail_rcu(&entry
->list
, &tomoyo_domain_list
);
687 mutex_unlock(&tomoyo_policy_lock
);
688 tomoyo_put_name(saved_domainname
);
690 return found
? domain
: NULL
;
694 * tomoyo_find_next_domain - Find a domain.
696 * @bprm: Pointer to "struct linux_binprm".
698 * Returns 0 on success, negative value otherwise.
700 * Caller holds tomoyo_read_lock().
702 int tomoyo_find_next_domain(struct linux_binprm
*bprm
)
705 * This function assumes that the size of buffer returned by
706 * tomoyo_realpath() = TOMOYO_MAX_PATHNAME_LEN.
708 struct tomoyo_page_buffer
*tmp
= kzalloc(sizeof(*tmp
), GFP_KERNEL
);
709 struct tomoyo_domain_info
*old_domain
= tomoyo_domain();
710 struct tomoyo_domain_info
*domain
= NULL
;
711 const char *old_domain_name
= old_domain
->domainname
->name
;
712 const char *original_name
= bprm
->filename
;
713 char *new_domain_name
= NULL
;
714 char *real_program_name
= NULL
;
715 char *symlink_program_name
= NULL
;
716 const u8 mode
= tomoyo_check_flags(old_domain
, TOMOYO_MAC_FOR_FILE
);
717 const bool is_enforce
= (mode
== 3);
718 int retval
= -ENOMEM
;
719 struct tomoyo_path_info r
; /* real name */
720 struct tomoyo_path_info s
; /* symlink name */
721 struct tomoyo_path_info l
; /* last name */
722 static bool initialized
;
729 * Built-in initializers. This is needed because policies are
730 * not loaded until starting /sbin/init.
732 tomoyo_update_domain_initializer_entry(NULL
, "/sbin/hotplug",
734 tomoyo_update_domain_initializer_entry(NULL
, "/sbin/modprobe",
739 /* Get tomoyo_realpath of program. */
741 /* I hope tomoyo_realpath() won't fail with -ENOMEM. */
742 real_program_name
= tomoyo_realpath(original_name
);
743 if (!real_program_name
)
745 /* Get tomoyo_realpath of symbolic link. */
746 symlink_program_name
= tomoyo_realpath_nofollow(original_name
);
747 if (!symlink_program_name
)
750 r
.name
= real_program_name
;
751 tomoyo_fill_path_info(&r
);
752 s
.name
= symlink_program_name
;
753 tomoyo_fill_path_info(&s
);
754 l
.name
= tomoyo_get_last_name(old_domain
);
755 tomoyo_fill_path_info(&l
);
757 /* Check 'alias' directive. */
758 if (tomoyo_pathcmp(&r
, &s
)) {
759 struct tomoyo_alias_entry
*ptr
;
760 /* Is this program allowed to be called via symbolic links? */
761 list_for_each_entry_rcu(ptr
, &tomoyo_alias_list
, list
) {
762 if (ptr
->is_deleted
||
763 tomoyo_pathcmp(&r
, ptr
->original_name
) ||
764 tomoyo_pathcmp(&s
, ptr
->aliased_name
))
766 memset(real_program_name
, 0, TOMOYO_MAX_PATHNAME_LEN
);
767 strncpy(real_program_name
, ptr
->aliased_name
->name
,
768 TOMOYO_MAX_PATHNAME_LEN
- 1);
769 tomoyo_fill_path_info(&r
);
774 /* Check execute permission. */
775 retval
= tomoyo_check_exec_perm(old_domain
, &r
);
779 new_domain_name
= tmp
->buffer
;
780 if (tomoyo_is_domain_initializer(old_domain
->domainname
, &r
, &l
)) {
781 /* Transit to the child of tomoyo_kernel_domain domain. */
782 snprintf(new_domain_name
, TOMOYO_MAX_PATHNAME_LEN
+ 1,
783 TOMOYO_ROOT_NAME
" " "%s", real_program_name
);
784 } else if (old_domain
== &tomoyo_kernel_domain
&&
785 !tomoyo_policy_loaded
) {
787 * Needn't to transit from kernel domain before starting
788 * /sbin/init. But transit from kernel domain if executing
789 * initializers because they might start before /sbin/init.
792 } else if (tomoyo_is_domain_keeper(old_domain
->domainname
, &r
, &l
)) {
793 /* Keep current domain. */
796 /* Normal domain transition. */
797 snprintf(new_domain_name
, TOMOYO_MAX_PATHNAME_LEN
+ 1,
798 "%s %s", old_domain_name
, real_program_name
);
800 if (domain
|| strlen(new_domain_name
) >= TOMOYO_MAX_PATHNAME_LEN
)
802 domain
= tomoyo_find_domain(new_domain_name
);
807 domain
= tomoyo_find_or_assign_new_domain(new_domain_name
,
808 old_domain
->profile
);
812 printk(KERN_WARNING
"TOMOYO-ERROR: Domain '%s' not defined.\n",
817 old_domain
->transition_failed
= true;
821 /* Update reference count on "struct tomoyo_domain_info". */
822 atomic_inc(&domain
->users
);
823 bprm
->cred
->security
= domain
;
824 kfree(real_program_name
);
825 kfree(symlink_program_name
);