2 * security/tomoyo/condition.c
4 * Copyright (C) 2005-2011 NTT DATA CORPORATION
8 #include <linux/slab.h>
10 /* List of "struct tomoyo_condition". */
11 LIST_HEAD(tomoyo_condition_list);
14 * tomoyo_argv - Check argv[] in "struct linux_binbrm".
16 * @index: Index number of @arg_ptr.
17 * @arg_ptr: Contents of argv[@index].
18 * @argc: Length of @argv.
19 * @argv: Pointer to "struct tomoyo_argv".
20 * @checked: Set to true if @argv[@index] was found.
22 * Returns true on success, false otherwise.
24 static bool tomoyo_argv(const unsigned int index, const char *arg_ptr,
25 const int argc, const struct tomoyo_argv *argv,
29 struct tomoyo_path_info arg;
31 for (i = 0; i < argc; argv++, checked++, i++) {
33 if (index != argv->index)
36 tomoyo_fill_path_info(&arg);
37 result = tomoyo_path_matches_pattern(&arg, argv->value);
47 * tomoyo_envp - Check envp[] in "struct linux_binbrm".
49 * @env_name: The name of environment variable.
50 * @env_value: The value of environment variable.
51 * @envc: Length of @envp.
52 * @envp: Pointer to "struct tomoyo_envp".
53 * @checked: Set to true if @envp[@env_name] was found.
55 * Returns true on success, false otherwise.
57 static bool tomoyo_envp(const char *env_name, const char *env_value,
58 const int envc, const struct tomoyo_envp *envp,
62 struct tomoyo_path_info name;
63 struct tomoyo_path_info value;
65 tomoyo_fill_path_info(&name);
66 value.name = env_value;
67 tomoyo_fill_path_info(&value);
68 for (i = 0; i < envc; envp++, checked++, i++) {
70 if (!tomoyo_path_matches_pattern(&name, envp->name))
74 result = tomoyo_path_matches_pattern(&value,
90 * tomoyo_scan_bprm - Scan "struct linux_binprm".
92 * @ee: Pointer to "struct tomoyo_execve".
93 * @argc: Length of @argc.
94 * @argv: Pointer to "struct tomoyo_argv".
95 * @envc: Length of @envp.
96 * @envp: Poiner to "struct tomoyo_envp".
98 * Returns true on success, false otherwise.
100 static bool tomoyo_scan_bprm(struct tomoyo_execve *ee,
101 const u16 argc, const struct tomoyo_argv *argv,
102 const u16 envc, const struct tomoyo_envp *envp)
104 struct linux_binprm *bprm = ee->bprm;
105 struct tomoyo_page_dump *dump = &ee->dump;
106 char *arg_ptr = ee->tmp;
108 unsigned long pos = bprm->p;
109 int offset = pos % PAGE_SIZE;
110 int argv_count = bprm->argc;
111 int envp_count = bprm->envc;
113 u8 local_checked[32];
115 if (argc + envc <= sizeof(local_checked)) {
116 checked = local_checked;
117 memset(local_checked, 0, sizeof(local_checked));
119 checked = kzalloc(argc + envc, GFP_NOFS);
123 while (argv_count || envp_count) {
124 if (!tomoyo_dump_page(bprm, pos, dump)) {
128 pos += PAGE_SIZE - offset;
129 while (offset < PAGE_SIZE) {
131 const char *kaddr = dump->data;
132 const unsigned char c = kaddr[offset++];
133 if (c && arg_len < TOMOYO_EXEC_TMPSIZE - 10) {
135 arg_ptr[arg_len++] = '\\';
136 arg_ptr[arg_len++] = '\\';
137 } else if (c > ' ' && c < 127) {
138 arg_ptr[arg_len++] = c;
140 arg_ptr[arg_len++] = '\\';
141 arg_ptr[arg_len++] = (c >> 6) + '0';
143 ((c >> 3) & 7) + '0';
144 arg_ptr[arg_len++] = (c & 7) + '0';
147 arg_ptr[arg_len] = '\0';
153 if (!tomoyo_argv(bprm->argc - argv_count,
160 } else if (envp_count) {
161 char *cp = strchr(arg_ptr, '=');
164 if (!tomoyo_envp(arg_ptr, cp + 1,
184 /* Check not-yet-checked entries. */
185 for (i = 0; i < argc; i++) {
189 * Return true only if all unchecked indexes in
190 * bprm->argv[] are not matched.
197 for (i = 0; i < envc; envp++, i++) {
198 if (checked[argc + i])
201 * Return true only if all unchecked environ variables
202 * in bprm->envp[] are either undefined or not matched.
204 if ((!envp->value && !envp->is_not) ||
205 (envp->value && envp->is_not))
211 if (checked != local_checked)
217 * tomoyo_scan_exec_realpath - Check "exec.realpath" parameter of "struct tomoyo_condition".
219 * @file: Pointer to "struct file".
220 * @ptr: Pointer to "struct tomoyo_name_union".
221 * @match: True if "exec.realpath=", false if "exec.realpath!=".
223 * Returns true on success, false otherwise.
225 static bool tomoyo_scan_exec_realpath(struct file *file,
226 const struct tomoyo_name_union *ptr,
230 struct tomoyo_path_info exe;
233 exe.name = tomoyo_realpath_from_path(&file->f_path);
236 tomoyo_fill_path_info(&exe);
237 result = tomoyo_compare_name_union(&exe, ptr);
239 return result == match;
243 * tomoyo_get_dqword - tomoyo_get_name() for a quoted string.
245 * @start: String to save.
247 * Returns pointer to "struct tomoyo_path_info" on success, NULL otherwise.
249 static const struct tomoyo_path_info *tomoyo_get_dqword(char *start)
251 char *cp = start + strlen(start) - 1;
252 if (cp == start || *start++ != '"' || *cp != '"')
255 if (*start && !tomoyo_correct_word(start))
257 return tomoyo_get_name(start);
261 * tomoyo_parse_name_union_quoted - Parse a quoted word.
263 * @param: Pointer to "struct tomoyo_acl_param".
264 * @ptr: Pointer to "struct tomoyo_name_union".
266 * Returns true on success, false otherwise.
268 static bool tomoyo_parse_name_union_quoted(struct tomoyo_acl_param *param,
269 struct tomoyo_name_union *ptr)
271 char *filename = param->data;
272 if (*filename == '@')
273 return tomoyo_parse_name_union(param, ptr);
274 ptr->filename = tomoyo_get_dqword(filename);
275 return ptr->filename != NULL;
279 * tomoyo_parse_argv - Parse an argv[] condition part.
281 * @left: Lefthand value.
282 * @right: Righthand value.
283 * @argv: Pointer to "struct tomoyo_argv".
285 * Returns true on success, false otherwise.
287 static bool tomoyo_parse_argv(char *left, char *right,
288 struct tomoyo_argv *argv)
290 if (tomoyo_parse_ulong(&argv->index, &left) !=
291 TOMOYO_VALUE_TYPE_DECIMAL || *left++ != ']' || *left)
293 argv->value = tomoyo_get_dqword(right);
294 return argv->value != NULL;
298 * tomoyo_parse_envp - Parse an envp[] condition part.
300 * @left: Lefthand value.
301 * @right: Righthand value.
302 * @envp: Pointer to "struct tomoyo_envp".
304 * Returns true on success, false otherwise.
306 static bool tomoyo_parse_envp(char *left, char *right,
307 struct tomoyo_envp *envp)
309 const struct tomoyo_path_info *name;
310 const struct tomoyo_path_info *value;
311 char *cp = left + strlen(left) - 1;
312 if (*cp-- != ']' || *cp != '"')
315 if (!tomoyo_correct_word(left))
317 name = tomoyo_get_name(left);
320 if (!strcmp(right, "NULL")) {
323 value = tomoyo_get_dqword(right);
325 tomoyo_put_name(name);
337 * tomoyo_same_condition - Check for duplicated "struct tomoyo_condition" entry.
339 * @a: Pointer to "struct tomoyo_condition".
340 * @b: Pointer to "struct tomoyo_condition".
342 * Returns true if @a == @b, false otherwise.
344 static inline bool tomoyo_same_condition(const struct tomoyo_condition *a,
345 const struct tomoyo_condition *b)
347 return a->size == b->size && a->condc == b->condc &&
348 a->numbers_count == b->numbers_count &&
349 a->names_count == b->names_count &&
350 a->argc == b->argc && a->envc == b->envc &&
351 !memcmp(a + 1, b + 1, a->size - sizeof(*a));
355 * tomoyo_condition_type - Get condition type.
357 * @word: Keyword string.
359 * Returns one of values in "enum tomoyo_conditions_index" on success,
360 * TOMOYO_MAX_CONDITION_KEYWORD otherwise.
362 static u8 tomoyo_condition_type(const char *word)
365 for (i = 0; i < TOMOYO_MAX_CONDITION_KEYWORD; i++) {
366 if (!strcmp(word, tomoyo_condition_keyword[i]))
372 /* Define this to enable debug mode. */
373 /* #define DEBUG_CONDITION */
375 #ifdef DEBUG_CONDITION
376 #define dprintk printk
378 #define dprintk(...) do { } while (0)
382 * tomoyo_commit_condition - Commit "struct tomoyo_condition".
384 * @entry: Pointer to "struct tomoyo_condition".
386 * Returns pointer to "struct tomoyo_condition" on success, NULL otherwise.
388 * This function merges duplicated entries. This function returns NULL if
389 * @entry is not duplicated but memory quota for policy has exceeded.
391 static struct tomoyo_condition *tomoyo_commit_condition
392 (struct tomoyo_condition *entry)
394 struct tomoyo_condition *ptr;
396 if (mutex_lock_interruptible(&tomoyo_policy_lock)) {
397 dprintk(KERN_WARNING "%u: %s failed\n", __LINE__, __func__);
402 list_for_each_entry_rcu(ptr, &tomoyo_condition_list, head.list) {
403 if (!tomoyo_same_condition(ptr, entry))
405 /* Same entry found. Share this entry. */
406 atomic_inc(&ptr->head.users);
411 if (tomoyo_memory_ok(entry)) {
412 atomic_set(&entry->head.users, 1);
413 list_add_rcu(&entry->head.list,
414 &tomoyo_condition_list);
420 mutex_unlock(&tomoyo_policy_lock);
423 tomoyo_del_condition(&entry->head.list);
431 * tomoyo_get_condition - Parse condition part.
433 * @param: Pointer to "struct tomoyo_acl_param".
435 * Returns pointer to "struct tomoyo_condition" on success, NULL otherwise.
437 struct tomoyo_condition *tomoyo_get_condition(struct tomoyo_acl_param *param)
439 struct tomoyo_condition *entry = NULL;
440 struct tomoyo_condition_element *condp = NULL;
441 struct tomoyo_number_union *numbers_p = NULL;
442 struct tomoyo_name_union *names_p = NULL;
443 struct tomoyo_argv *argv = NULL;
444 struct tomoyo_envp *envp = NULL;
445 struct tomoyo_condition e = { };
446 char * const start_of_string = param->data;
447 char * const end_of_string = start_of_string + strlen(start_of_string);
450 pos = start_of_string;
454 char *left_word = pos;
461 * Since left-hand condition does not allow use of "path_group"
462 * or "number_group" and environment variable's names do not
463 * accept '=', it is guaranteed that the original line consists
464 * of one or more repetition of $left$operator$right blocks
465 * where "$left is free from '=' and ' '" and "$operator is
466 * either '=' or '!='" and "$right is free from ' '".
467 * Therefore, we can reconstruct the original line at the end
468 * of dry run even if we overwrite $operator with '\0'.
470 cp = strchr(pos, ' ');
472 *cp = '\0'; /* Will restore later. */
477 right_word = strchr(left_word, '=');
478 if (!right_word || right_word == left_word)
480 is_not = *(right_word - 1) == '!';
482 *(right_word++ - 1) = '\0'; /* Will restore later. */
483 else if (*(right_word + 1) != '=')
484 *right_word++ = '\0'; /* Will restore later. */
487 dprintk(KERN_WARNING "%u: <%s>%s=<%s>\n", __LINE__, left_word,
488 is_not ? "!" : "", right_word);
489 if (!strncmp(left_word, "exec.argv[", 10)) {
496 left = TOMOYO_ARGV_ENTRY;
497 argv->is_not = is_not;
498 if (!tomoyo_parse_argv(left_word + 10,
504 if (!strncmp(left_word, "exec.envp[\"", 11)) {
511 left = TOMOYO_ENVP_ENTRY;
512 envp->is_not = is_not;
513 if (!tomoyo_parse_envp(left_word + 11,
519 left = tomoyo_condition_type(left_word);
520 dprintk(KERN_WARNING "%u: <%s> left=%u\n", __LINE__, left_word,
522 if (left == TOMOYO_MAX_CONDITION_KEYWORD) {
527 left = TOMOYO_NUMBER_UNION;
528 param->data = left_word;
529 if (*left_word == '@' ||
530 !tomoyo_parse_number_union(param,
539 if (left == TOMOYO_EXEC_REALPATH ||
540 left == TOMOYO_SYMLINK_TARGET) {
545 right = TOMOYO_NAME_UNION;
546 param->data = right_word;
547 if (!tomoyo_parse_name_union_quoted(param,
553 right = tomoyo_condition_type(right_word);
554 if (right == TOMOYO_MAX_CONDITION_KEYWORD) {
559 right = TOMOYO_NUMBER_UNION;
560 param->data = right_word;
561 if (!tomoyo_parse_number_union(param,
568 dprintk(KERN_WARNING "%u: dry_run left=%u right=%u "
569 "match=%u\n", __LINE__, left, right, !is_not);
573 condp->right = right;
574 condp->equals = !is_not;
575 dprintk(KERN_WARNING "%u: left=%u right=%u match=%u\n",
576 __LINE__, condp->left, condp->right,
580 dprintk(KERN_INFO "%u: cond=%u numbers=%u names=%u ac=%u ec=%u\n",
581 __LINE__, e.condc, e.numbers_count, e.names_count, e.argc,
584 BUG_ON(e.names_count | e.numbers_count | e.argc | e.envc |
586 return tomoyo_commit_condition(entry);
588 e.size = sizeof(*entry)
589 + e.condc * sizeof(struct tomoyo_condition_element)
590 + e.numbers_count * sizeof(struct tomoyo_number_union)
591 + e.names_count * sizeof(struct tomoyo_name_union)
592 + e.argc * sizeof(struct tomoyo_argv)
593 + e.envc * sizeof(struct tomoyo_envp);
594 entry = kzalloc(e.size, GFP_NOFS);
598 condp = (struct tomoyo_condition_element *) (entry + 1);
599 numbers_p = (struct tomoyo_number_union *) (condp + e.condc);
600 names_p = (struct tomoyo_name_union *) (numbers_p + e.numbers_count);
601 argv = (struct tomoyo_argv *) (names_p + e.names_count);
602 envp = (struct tomoyo_envp *) (argv + e.argc);
605 for (pos = start_of_string; pos < end_of_string; pos++) {
608 if (flag) /* Restore " ". */
610 else if (*(pos + 1) == '=') /* Restore "!=". */
612 else /* Restore "=". */
619 dprintk(KERN_WARNING "%u: %s failed\n", __LINE__, __func__);
621 tomoyo_del_condition(&entry->head.list);
628 * tomoyo_get_attributes - Revalidate "struct inode".
630 * @obj: Pointer to "struct tomoyo_obj_info".
634 void tomoyo_get_attributes(struct tomoyo_obj_info *obj)
637 struct dentry *dentry = NULL;
639 for (i = 0; i < TOMOYO_MAX_PATH_STAT; i++) {
643 dentry = obj->path1.dentry;
648 dentry = obj->path2.dentry;
655 dentry = dget_parent(dentry);
658 inode = dentry->d_inode;
660 struct tomoyo_mini_stat *stat = &obj->stat[i];
661 stat->uid = inode->i_uid;
662 stat->gid = inode->i_gid;
663 stat->ino = inode->i_ino;
664 stat->mode = inode->i_mode;
665 stat->dev = inode->i_sb->s_dev;
666 stat->rdev = inode->i_rdev;
667 obj->stat_valid[i] = true;
669 if (i & 1) /* i == TOMOYO_PATH1_PARENT ||
670 i == TOMOYO_PATH2_PARENT */
676 * tomoyo_condition - Check condition part.
678 * @r: Pointer to "struct tomoyo_request_info".
679 * @cond: Pointer to "struct tomoyo_condition". Maybe NULL.
681 * Returns true on success, false otherwise.
683 * Caller holds tomoyo_read_lock().
685 bool tomoyo_condition(struct tomoyo_request_info *r,
686 const struct tomoyo_condition *cond)
689 unsigned long min_v[2] = { 0, 0 };
690 unsigned long max_v[2] = { 0, 0 };
691 const struct tomoyo_condition_element *condp;
692 const struct tomoyo_number_union *numbers_p;
693 const struct tomoyo_name_union *names_p;
694 const struct tomoyo_argv *argv;
695 const struct tomoyo_envp *envp;
696 struct tomoyo_obj_info *obj;
700 struct linux_binprm *bprm = NULL;
709 if (!bprm && (argc || envc))
711 condp = (struct tomoyo_condition_element *) (cond + 1);
712 numbers_p = (const struct tomoyo_number_union *) (condp + condc);
713 names_p = (const struct tomoyo_name_union *)
714 (numbers_p + cond->numbers_count);
715 argv = (const struct tomoyo_argv *) (names_p + cond->names_count);
716 envp = (const struct tomoyo_envp *) (argv + argc);
717 for (i = 0; i < condc; i++) {
718 const bool match = condp->equals;
719 const u8 left = condp->left;
720 const u8 right = condp->right;
721 bool is_bitop[2] = { false, false };
724 /* Check argv[] and envp[] later. */
725 if (left == TOMOYO_ARGV_ENTRY || left == TOMOYO_ENVP_ENTRY)
727 /* Check string expressions. */
728 if (right == TOMOYO_NAME_UNION) {
729 const struct tomoyo_name_union *ptr = names_p++;
731 struct tomoyo_path_info *symlink;
732 struct tomoyo_execve *ee;
734 case TOMOYO_SYMLINK_TARGET:
735 symlink = obj ? obj->symlink_target : NULL;
737 !tomoyo_compare_name_union(symlink, ptr)
741 case TOMOYO_EXEC_REALPATH:
743 file = ee ? ee->bprm->file : NULL;
744 if (!tomoyo_scan_exec_realpath(file, ptr,
751 /* Check numeric or bit-op expressions. */
752 for (j = 0; j < 2; j++) {
753 const u8 index = j ? right : left;
754 unsigned long value = 0;
756 case TOMOYO_TASK_UID:
757 value = current_uid();
759 case TOMOYO_TASK_EUID:
760 value = current_euid();
762 case TOMOYO_TASK_SUID:
763 value = current_suid();
765 case TOMOYO_TASK_FSUID:
766 value = current_fsuid();
768 case TOMOYO_TASK_GID:
769 value = current_gid();
771 case TOMOYO_TASK_EGID:
772 value = current_egid();
774 case TOMOYO_TASK_SGID:
775 value = current_sgid();
777 case TOMOYO_TASK_FSGID:
778 value = current_fsgid();
780 case TOMOYO_TASK_PID:
781 value = tomoyo_sys_getpid();
783 case TOMOYO_TASK_PPID:
784 value = tomoyo_sys_getppid();
786 case TOMOYO_TYPE_IS_SOCKET:
789 case TOMOYO_TYPE_IS_SYMLINK:
792 case TOMOYO_TYPE_IS_FILE:
795 case TOMOYO_TYPE_IS_BLOCK_DEV:
798 case TOMOYO_TYPE_IS_DIRECTORY:
801 case TOMOYO_TYPE_IS_CHAR_DEV:
804 case TOMOYO_TYPE_IS_FIFO:
807 case TOMOYO_MODE_SETUID:
810 case TOMOYO_MODE_SETGID:
813 case TOMOYO_MODE_STICKY:
816 case TOMOYO_MODE_OWNER_READ:
819 case TOMOYO_MODE_OWNER_WRITE:
822 case TOMOYO_MODE_OWNER_EXECUTE:
825 case TOMOYO_MODE_GROUP_READ:
828 case TOMOYO_MODE_GROUP_WRITE:
831 case TOMOYO_MODE_GROUP_EXECUTE:
834 case TOMOYO_MODE_OTHERS_READ:
837 case TOMOYO_MODE_OTHERS_WRITE:
840 case TOMOYO_MODE_OTHERS_EXECUTE:
843 case TOMOYO_EXEC_ARGC:
848 case TOMOYO_EXEC_ENVC:
853 case TOMOYO_NUMBER_UNION:
854 /* Fetch values later. */
859 if (!obj->validate_done) {
860 tomoyo_get_attributes(obj);
861 obj->validate_done = true;
865 struct tomoyo_mini_stat *stat;
867 case TOMOYO_PATH1_UID:
868 case TOMOYO_PATH1_GID:
869 case TOMOYO_PATH1_INO:
870 case TOMOYO_PATH1_MAJOR:
871 case TOMOYO_PATH1_MINOR:
872 case TOMOYO_PATH1_TYPE:
873 case TOMOYO_PATH1_DEV_MAJOR:
874 case TOMOYO_PATH1_DEV_MINOR:
875 case TOMOYO_PATH1_PERM:
876 stat_index = TOMOYO_PATH1;
878 case TOMOYO_PATH2_UID:
879 case TOMOYO_PATH2_GID:
880 case TOMOYO_PATH2_INO:
881 case TOMOYO_PATH2_MAJOR:
882 case TOMOYO_PATH2_MINOR:
883 case TOMOYO_PATH2_TYPE:
884 case TOMOYO_PATH2_DEV_MAJOR:
885 case TOMOYO_PATH2_DEV_MINOR:
886 case TOMOYO_PATH2_PERM:
887 stat_index = TOMOYO_PATH2;
889 case TOMOYO_PATH1_PARENT_UID:
890 case TOMOYO_PATH1_PARENT_GID:
891 case TOMOYO_PATH1_PARENT_INO:
892 case TOMOYO_PATH1_PARENT_PERM:
896 case TOMOYO_PATH2_PARENT_UID:
897 case TOMOYO_PATH2_PARENT_GID:
898 case TOMOYO_PATH2_PARENT_INO:
899 case TOMOYO_PATH2_PARENT_PERM:
906 if (!obj->stat_valid[stat_index])
908 stat = &obj->stat[stat_index];
910 case TOMOYO_PATH1_UID:
911 case TOMOYO_PATH2_UID:
912 case TOMOYO_PATH1_PARENT_UID:
913 case TOMOYO_PATH2_PARENT_UID:
916 case TOMOYO_PATH1_GID:
917 case TOMOYO_PATH2_GID:
918 case TOMOYO_PATH1_PARENT_GID:
919 case TOMOYO_PATH2_PARENT_GID:
922 case TOMOYO_PATH1_INO:
923 case TOMOYO_PATH2_INO:
924 case TOMOYO_PATH1_PARENT_INO:
925 case TOMOYO_PATH2_PARENT_INO:
928 case TOMOYO_PATH1_MAJOR:
929 case TOMOYO_PATH2_MAJOR:
930 value = MAJOR(stat->dev);
932 case TOMOYO_PATH1_MINOR:
933 case TOMOYO_PATH2_MINOR:
934 value = MINOR(stat->dev);
936 case TOMOYO_PATH1_TYPE:
937 case TOMOYO_PATH2_TYPE:
938 value = stat->mode & S_IFMT;
940 case TOMOYO_PATH1_DEV_MAJOR:
941 case TOMOYO_PATH2_DEV_MAJOR:
942 value = MAJOR(stat->rdev);
944 case TOMOYO_PATH1_DEV_MINOR:
945 case TOMOYO_PATH2_DEV_MINOR:
946 value = MINOR(stat->rdev);
948 case TOMOYO_PATH1_PERM:
949 case TOMOYO_PATH2_PERM:
950 case TOMOYO_PATH1_PARENT_PERM:
951 case TOMOYO_PATH2_PARENT_PERM:
952 value = stat->mode & S_IALLUGO;
961 case TOMOYO_MODE_SETUID:
962 case TOMOYO_MODE_SETGID:
963 case TOMOYO_MODE_STICKY:
964 case TOMOYO_MODE_OWNER_READ:
965 case TOMOYO_MODE_OWNER_WRITE:
966 case TOMOYO_MODE_OWNER_EXECUTE:
967 case TOMOYO_MODE_GROUP_READ:
968 case TOMOYO_MODE_GROUP_WRITE:
969 case TOMOYO_MODE_GROUP_EXECUTE:
970 case TOMOYO_MODE_OTHERS_READ:
971 case TOMOYO_MODE_OTHERS_WRITE:
972 case TOMOYO_MODE_OTHERS_EXECUTE:
976 if (left == TOMOYO_NUMBER_UNION) {
977 /* Fetch values now. */
978 const struct tomoyo_number_union *ptr = numbers_p++;
979 min_v[0] = ptr->values[0];
980 max_v[0] = ptr->values[1];
982 if (right == TOMOYO_NUMBER_UNION) {
983 /* Fetch values now. */
984 const struct tomoyo_number_union *ptr = numbers_p++;
986 if (tomoyo_number_matches_group(min_v[0],
992 if ((min_v[0] <= ptr->values[1] &&
993 max_v[0] >= ptr->values[0]) == match)
999 * Bit operation is valid only when counterpart value
1000 * represents permission.
1002 if (is_bitop[0] && is_bitop[1]) {
1004 } else if (is_bitop[0]) {
1006 case TOMOYO_PATH1_PERM:
1007 case TOMOYO_PATH1_PARENT_PERM:
1008 case TOMOYO_PATH2_PERM:
1009 case TOMOYO_PATH2_PARENT_PERM:
1010 if (!(max_v[0] & max_v[1]) == !match)
1014 } else if (is_bitop[1]) {
1016 case TOMOYO_PATH1_PERM:
1017 case TOMOYO_PATH1_PARENT_PERM:
1018 case TOMOYO_PATH2_PERM:
1019 case TOMOYO_PATH2_PARENT_PERM:
1020 if (!(max_v[0] & max_v[1]) == !match)
1025 /* Normal value range comparison. */
1026 if ((min_v[0] <= max_v[1] && max_v[0] >= min_v[1]) == match)
1031 /* Check argv[] and envp[] now. */
1032 if (r->ee && (argc || envc))
1033 return tomoyo_scan_bprm(r->ee, argc, argv, envc, envp);