microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

TOMOYO: Use shorter names. 

Use shorter name to reduce newlines needed for 80 columns limit.

Signed-off-by: Tetsuo Handa <penguin-kernel@I-love.SAKURA.ne.jp>
Signed-off-by: James Morris <jmorris@namei.org>
This commit is contained in:
Tetsuo Handa 2010-02-16 08:03:30 +09:00 коммит произвёл James Morris
Родитель 084da356f6
Коммит 7ef612331f
5 изменённых файлов: 250 добавлений и 299 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

74
security/tomoyo/common.c
Просмотреть файл

@ -841,25 +841,22 @@ bool tomoyo_domain_quota_is_ok(struct tomoyo_domain_info * const domain)
return true;
list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
switch (ptr->type) {
struct tomoyo_single_path_acl_record *acl;
struct tomoyo_path_acl *acl;
u32 perm;
u8 i;
case TOMOYO_TYPE_SINGLE_PATH_ACL:
acl = container_of(ptr,
struct tomoyo_single_path_acl_record,
head);
case TOMOYO_TYPE_PATH_ACL:
acl = container_of(ptr, struct tomoyo_path_acl, head);
perm = acl->perm | (((u32) acl->perm_high) << 16);
for (i = 0; i < TOMOYO_MAX_SINGLE_PATH_OPERATION; i++)
for (i = 0; i < TOMOYO_MAX_PATH_OPERATION; i++)
if (perm & (1 << i))
count++;
if (perm & (1 << TOMOYO_TYPE_READ_WRITE_ACL))
if (perm & (1 << TOMOYO_TYPE_READ_WRITE))
count -= 2;
break;
case TOMOYO_TYPE_DOUBLE_PATH_ACL:
perm = container_of(ptr,
struct tomoyo_double_path_acl_record,
head)->perm;
for (i = 0; i < TOMOYO_MAX_DOUBLE_PATH_OPERATION; i++)
case TOMOYO_TYPE_PATH2_ACL:
perm = container_of(ptr, struct tomoyo_path2_acl, head)
->perm;
for (i = 0; i < TOMOYO_MAX_PATH2_OPERATION; i++)
if (perm & (1 << i))
count++;
break;
@ -1366,16 +1363,15 @@ static int tomoyo_write_domain_policy(struct tomoyo_io_buffer *head)
}
/**
* tomoyo_print_single_path_acl - Print a single path ACL entry.
* tomoyo_print_path_acl - Print a single path ACL entry.
*
* @head: Pointer to "struct tomoyo_io_buffer".
* @ptr: Pointer to "struct tomoyo_single_path_acl_record".
* @ptr: Pointer to "struct tomoyo_path_acl".
*
* Returns true on success, false otherwise.
*/
static bool tomoyo_print_single_path_acl(struct tomoyo_io_buffer *head,
struct tomoyo_single_path_acl_record *
ptr)
static bool tomoyo_print_path_acl(struct tomoyo_io_buffer *head,
struct tomoyo_path_acl *ptr)
{
int pos;
u8 bit;
@ -1384,17 +1380,15 @@ static bool tomoyo_print_single_path_acl(struct tomoyo_io_buffer *head,
const u32 perm = ptr->perm | (((u32) ptr->perm_high) << 16);
filename = ptr->filename->name;
for (bit = head->read_bit; bit < TOMOYO_MAX_SINGLE_PATH_OPERATION;
bit++) {
for (bit = head->read_bit; bit < TOMOYO_MAX_PATH_OPERATION; bit++) {
const char *msg;
if (!(perm & (1 << bit)))
continue;
/* Print "read/write" instead of "read" and "write". */
if ((bit == TOMOYO_TYPE_READ_ACL ||
bit == TOMOYO_TYPE_WRITE_ACL)
&& (perm & (1 << TOMOYO_TYPE_READ_WRITE_ACL)))
if ((bit == TOMOYO_TYPE_READ || bit == TOMOYO_TYPE_WRITE)
&& (perm & (1 << TOMOYO_TYPE_READ_WRITE)))
continue;
msg = tomoyo_sp2keyword(bit);
msg = tomoyo_path2keyword(bit);
pos = head->read_avail;
if (!tomoyo_io_printf(head, "allow_%s %s%s\n", msg,
atmark, filename))
@ -1409,16 +1403,15 @@ static bool tomoyo_print_single_path_acl(struct tomoyo_io_buffer *head,
}
/**
* tomoyo_print_double_path_acl - Print a double path ACL entry.
* tomoyo_print_path2_acl - Print a double path ACL entry.
*
* @head: Pointer to "struct tomoyo_io_buffer".
* @ptr: Pointer to "struct tomoyo_double_path_acl_record".
* @ptr: Pointer to "struct tomoyo_path2_acl".
*
* Returns true on success, false otherwise.
*/
static bool tomoyo_print_double_path_acl(struct tomoyo_io_buffer *head,
struct tomoyo_double_path_acl_record *
ptr)
static bool tomoyo_print_path2_acl(struct tomoyo_io_buffer *head,
struct tomoyo_path2_acl *ptr)
{
int pos;
const char *atmark1 = "";
@ -1430,12 +1423,11 @@ static bool tomoyo_print_double_path_acl(struct tomoyo_io_buffer *head,
filename1 = ptr->filename1->name;
filename2 = ptr->filename2->name;
for (bit = head->read_bit; bit < TOMOYO_MAX_DOUBLE_PATH_OPERATION;
bit++) {
for (bit = head->read_bit; bit < TOMOYO_MAX_PATH2_OPERATION; bit++) {
const char *msg;
if (!(perm & (1 << bit)))
continue;
msg = tomoyo_dp2keyword(bit);
msg = tomoyo_path22keyword(bit);
pos = head->read_avail;
if (!tomoyo_io_printf(head, "allow_%s %s%s %s%s\n", msg,
atmark1, filename1, atmark2, filename2))
@ -1462,19 +1454,15 @@ static bool tomoyo_print_entry(struct tomoyo_io_buffer *head,
{
const u8 acl_type = ptr->type;
if (acl_type == TOMOYO_TYPE_SINGLE_PATH_ACL) {
struct tomoyo_single_path_acl_record *acl
= container_of(ptr,
struct tomoyo_single_path_acl_record,
head);
return tomoyo_print_single_path_acl(head, acl);
if (acl_type == TOMOYO_TYPE_PATH_ACL) {
struct tomoyo_path_acl *acl
= container_of(ptr, struct tomoyo_path_acl, head);
return tomoyo_print_path_acl(head, acl);
}
if (acl_type == TOMOYO_TYPE_DOUBLE_PATH_ACL) {
struct tomoyo_double_path_acl_record *acl
= container_of(ptr,
struct tomoyo_double_path_acl_record,
head);
return tomoyo_print_double_path_acl(head, acl);
if (acl_type == TOMOYO_TYPE_PATH2_ACL) {
struct tomoyo_path2_acl *acl
= container_of(ptr, struct tomoyo_path2_acl, head);
return tomoyo_print_path2_acl(head, acl);
}
BUG(); /* This must not happen. */
return false;

90
security/tomoyo/common.h
Просмотреть файл

@ -71,8 +71,8 @@ enum tomoyo_mac_index {
/* Index numbers for Access Controls. */
enum tomoyo_acl_entry_type_index {
TOMOYO_TYPE_SINGLE_PATH_ACL,
TOMOYO_TYPE_DOUBLE_PATH_ACL,
TOMOYO_TYPE_PATH_ACL,
TOMOYO_TYPE_PATH2_ACL,
};
/* Index numbers for File Controls. */
@ -87,36 +87,36 @@ enum tomoyo_acl_entry_type_index {
*/
enum tomoyo_path_acl_index {
TOMOYO_TYPE_READ_WRITE_ACL,
TOMOYO_TYPE_EXECUTE_ACL,
TOMOYO_TYPE_READ_ACL,
TOMOYO_TYPE_WRITE_ACL,
TOMOYO_TYPE_CREATE_ACL,
TOMOYO_TYPE_UNLINK_ACL,
TOMOYO_TYPE_MKDIR_ACL,
TOMOYO_TYPE_RMDIR_ACL,
TOMOYO_TYPE_MKFIFO_ACL,
TOMOYO_TYPE_MKSOCK_ACL,
TOMOYO_TYPE_MKBLOCK_ACL,
TOMOYO_TYPE_MKCHAR_ACL,
TOMOYO_TYPE_TRUNCATE_ACL,
TOMOYO_TYPE_SYMLINK_ACL,
TOMOYO_TYPE_REWRITE_ACL,
TOMOYO_TYPE_IOCTL_ACL,
TOMOYO_TYPE_CHMOD_ACL,
TOMOYO_TYPE_CHOWN_ACL,
TOMOYO_TYPE_CHGRP_ACL,
TOMOYO_TYPE_CHROOT_ACL,
TOMOYO_TYPE_MOUNT_ACL,
TOMOYO_TYPE_UMOUNT_ACL,
TOMOYO_MAX_SINGLE_PATH_OPERATION
TOMOYO_TYPE_READ_WRITE,
TOMOYO_TYPE_EXECUTE,
TOMOYO_TYPE_READ,
TOMOYO_TYPE_WRITE,
TOMOYO_TYPE_CREATE,
TOMOYO_TYPE_UNLINK,
TOMOYO_TYPE_MKDIR,
TOMOYO_TYPE_RMDIR,
TOMOYO_TYPE_MKFIFO,
TOMOYO_TYPE_MKSOCK,
TOMOYO_TYPE_MKBLOCK,
TOMOYO_TYPE_MKCHAR,
TOMOYO_TYPE_TRUNCATE,
TOMOYO_TYPE_SYMLINK,
TOMOYO_TYPE_REWRITE,
TOMOYO_TYPE_IOCTL,
TOMOYO_TYPE_CHMOD,
TOMOYO_TYPE_CHOWN,
TOMOYO_TYPE_CHGRP,
TOMOYO_TYPE_CHROOT,
TOMOYO_TYPE_MOUNT,
TOMOYO_TYPE_UMOUNT,
TOMOYO_MAX_PATH_OPERATION
};
enum tomoyo_path2_acl_index {
TOMOYO_TYPE_LINK_ACL,
TOMOYO_TYPE_RENAME_ACL,
TOMOYO_TYPE_PIVOT_ROOT_ACL,
TOMOYO_MAX_DOUBLE_PATH_OPERATION
TOMOYO_TYPE_LINK,
TOMOYO_TYPE_RENAME,
TOMOYO_TYPE_PIVOT_ROOT,
TOMOYO_MAX_PATH2_OPERATION
};
enum tomoyo_securityfs_interface_index {
@ -210,12 +210,11 @@ struct tomoyo_path_info_with_data {
* (1) "list" which is linked to the ->acl_info_list of
* "struct tomoyo_domain_info"
* (2) "type" which tells type of the entry (either
* "struct tomoyo_single_path_acl_record" or
* "struct tomoyo_double_path_acl_record").
* "struct tomoyo_path_acl" or "struct tomoyo_path2_acl").
*
* Packing "struct tomoyo_acl_info" allows
* "struct tomoyo_single_path_acl_record" to embed "u8" + "u16" and
* "struct tomoyo_double_path_acl_record" to embed "u8"
* "struct tomoyo_path_acl" to embed "u8" + "u16" and
* "struct tomoyo_path2_acl" to embed "u8"
* without enlarging their structure size.
*/
struct tomoyo_acl_info {
@ -269,7 +268,7 @@ struct tomoyo_domain_info {
};
/*
* tomoyo_single_path_acl_record is a structure which is used for holding an
* tomoyo_path_acl is a structure which is used for holding an
* entry with one pathname operation (e.g. open(), mkdir()).
* It has following fields.
*
@ -284,8 +283,8 @@ struct tomoyo_domain_info {
* "allow_chmod", "allow_chown", "allow_chgrp", "allow_chroot", "allow_mount"
* and "allow_unmount".
*/
struct tomoyo_single_path_acl_record {
struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_SINGLE_PATH_ACL */
struct tomoyo_path_acl {
struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH_ACL */
u8 perm_high;
u16 perm;
/* Pointer to single pathname. */
@ -293,7 +292,7 @@ struct tomoyo_single_path_acl_record {
};
/*
* tomoyo_double_path_acl_record is a structure which is used for holding an
* tomoyo_path2_acl is a structure which is used for holding an
* entry with two pathnames operation (i.e. link(), rename() and pivot_root()).
* It has following fields.
*
@ -305,8 +304,8 @@ struct tomoyo_single_path_acl_record {
* Directives held by this structure are "allow_rename", "allow_link" and
* "allow_pivot_root".
*/
struct tomoyo_double_path_acl_record {
struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_DOUBLE_PATH_ACL */
struct tomoyo_path2_acl {
struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH2_ACL */
u8 perm;
/* Pointer to single pathname. */
const struct tomoyo_path_info *filename1;
@ -550,13 +549,13 @@ bool tomoyo_read_no_rewrite_policy(struct tomoyo_io_buffer *head);
/* Write domain policy violation warning message to console? */
bool tomoyo_verbose_mode(const struct tomoyo_domain_info *domain);
/* Convert double path operation to operation name. */
const char *tomoyo_dp2keyword(const u8 operation);
const char *tomoyo_path22keyword(const u8 operation);
/* Get the last component of the given domainname. */
const char *tomoyo_get_last_name(const struct tomoyo_domain_info *domain);
/* Get warning message. */
const char *tomoyo_get_msg(const bool is_enforce);
/* Convert single path operation to operation name. */
const char *tomoyo_sp2keyword(const u8 operation);
const char *tomoyo_path2keyword(const u8 operation);
/* Create "alias" entry in exception policy. */
int tomoyo_write_alias_policy(char *data, const bool is_delete);
/*
@ -638,11 +637,10 @@ int tomoyo_check_exec_perm(struct tomoyo_domain_info *domain,
const struct tomoyo_path_info *filename);
int tomoyo_check_open_permission(struct tomoyo_domain_info *domain,
struct path *path, const int flag);
int tomoyo_check_1path_perm(struct tomoyo_domain_info *domain,
const u8 operation, struct path *path);
int tomoyo_check_2path_perm(struct tomoyo_domain_info *domain,
const u8 operation, struct path *path1,
struct path *path2);
int tomoyo_path_perm(struct tomoyo_domain_info *domain, const u8 operation,
struct path *path);
int tomoyo_path2_perm(struct tomoyo_domain_info *domain, const u8 operation,
struct path *path1, struct path *path2);
int tomoyo_check_rewrite_permission(struct tomoyo_domain_info *domain,
struct file *filp);
int tomoyo_find_next_domain(struct linux_binprm *bprm);

295
security/tomoyo/file.c
Просмотреть файл

@ -12,62 +12,62 @@
#include "common.h"
/* Keyword array for single path operations. */
static const char *tomoyo_sp_keyword[TOMOYO_MAX_SINGLE_PATH_OPERATION] = {
[TOMOYO_TYPE_READ_WRITE_ACL] = "read/write",
[TOMOYO_TYPE_EXECUTE_ACL] = "execute",
[TOMOYO_TYPE_READ_ACL] = "read",
[TOMOYO_TYPE_WRITE_ACL] = "write",
[TOMOYO_TYPE_CREATE_ACL] = "create",
[TOMOYO_TYPE_UNLINK_ACL] = "unlink",
[TOMOYO_TYPE_MKDIR_ACL] = "mkdir",
[TOMOYO_TYPE_RMDIR_ACL] = "rmdir",
[TOMOYO_TYPE_MKFIFO_ACL] = "mkfifo",
[TOMOYO_TYPE_MKSOCK_ACL] = "mksock",
[TOMOYO_TYPE_MKBLOCK_ACL] = "mkblock",
[TOMOYO_TYPE_MKCHAR_ACL] = "mkchar",
[TOMOYO_TYPE_TRUNCATE_ACL] = "truncate",
[TOMOYO_TYPE_SYMLINK_ACL] = "symlink",
[TOMOYO_TYPE_REWRITE_ACL] = "rewrite",
[TOMOYO_TYPE_IOCTL_ACL] = "ioctl",
[TOMOYO_TYPE_CHMOD_ACL] = "chmod",
[TOMOYO_TYPE_CHOWN_ACL] = "chown",
[TOMOYO_TYPE_CHGRP_ACL] = "chgrp",
[TOMOYO_TYPE_CHROOT_ACL] = "chroot",
[TOMOYO_TYPE_MOUNT_ACL] = "mount",
[TOMOYO_TYPE_UMOUNT_ACL] = "unmount",
static const char *tomoyo_path_keyword[TOMOYO_MAX_PATH_OPERATION] = {
[TOMOYO_TYPE_READ_WRITE] = "read/write",
[TOMOYO_TYPE_EXECUTE] = "execute",
[TOMOYO_TYPE_READ] = "read",
[TOMOYO_TYPE_WRITE] = "write",
[TOMOYO_TYPE_CREATE] = "create",
[TOMOYO_TYPE_UNLINK] = "unlink",
[TOMOYO_TYPE_MKDIR] = "mkdir",
[TOMOYO_TYPE_RMDIR] = "rmdir",
[TOMOYO_TYPE_MKFIFO] = "mkfifo",
[TOMOYO_TYPE_MKSOCK] = "mksock",
[TOMOYO_TYPE_MKBLOCK] = "mkblock",
[TOMOYO_TYPE_MKCHAR] = "mkchar",
[TOMOYO_TYPE_TRUNCATE] = "truncate",
[TOMOYO_TYPE_SYMLINK] = "symlink",
[TOMOYO_TYPE_REWRITE] = "rewrite",
[TOMOYO_TYPE_IOCTL] = "ioctl",
[TOMOYO_TYPE_CHMOD] = "chmod",
[TOMOYO_TYPE_CHOWN] = "chown",
[TOMOYO_TYPE_CHGRP] = "chgrp",
[TOMOYO_TYPE_CHROOT] = "chroot",
[TOMOYO_TYPE_MOUNT] = "mount",
[TOMOYO_TYPE_UMOUNT] = "unmount",
};
/* Keyword array for double path operations. */
static const char *tomoyo_dp_keyword[TOMOYO_MAX_DOUBLE_PATH_OPERATION] = {
[TOMOYO_TYPE_LINK_ACL] = "link",
[TOMOYO_TYPE_RENAME_ACL] = "rename",
[TOMOYO_TYPE_PIVOT_ROOT_ACL] = "pivot_root",
static const char *tomoyo_path2_keyword[TOMOYO_MAX_PATH2_OPERATION] = {
[TOMOYO_TYPE_LINK] = "link",
[TOMOYO_TYPE_RENAME] = "rename",
[TOMOYO_TYPE_PIVOT_ROOT] = "pivot_root",
};
/**
* tomoyo_sp2keyword - Get the name of single path operation.
* tomoyo_path2keyword - Get the name of single path operation.
*
* @operation: Type of operation.
*
* Returns the name of single path operation.
*/
const char *tomoyo_sp2keyword(const u8 operation)
const char *tomoyo_path2keyword(const u8 operation)
{
return (operation < TOMOYO_MAX_SINGLE_PATH_OPERATION)
? tomoyo_sp_keyword[operation] : NULL;
return (operation < TOMOYO_MAX_PATH_OPERATION)
? tomoyo_path_keyword[operation] : NULL;
}
/**
* tomoyo_dp2keyword - Get the name of double path operation.
* tomoyo_path22keyword - Get the name of double path operation.
*
* @operation: Type of operation.
*
* Returns the name of double path operation.
*/
const char *tomoyo_dp2keyword(const u8 operation)
const char *tomoyo_path22keyword(const u8 operation)
{
return (operation < TOMOYO_MAX_DOUBLE_PATH_OPERATION)
? tomoyo_dp_keyword[operation] : NULL;
return (operation < TOMOYO_MAX_PATH2_OPERATION)
? tomoyo_path2_keyword[operation] : NULL;
}
/**
@ -115,13 +115,13 @@ static struct tomoyo_path_info *tomoyo_get_path(struct path *path)
return NULL;
}
static int tomoyo_update_double_path_acl(const u8 type, const char *filename1,
const char *filename2,
struct tomoyo_domain_info *
const domain, const bool is_delete);
static int tomoyo_update_single_path_acl(const u8 type, const char *filename,
struct tomoyo_domain_info *
const domain, const bool is_delete);
static int tomoyo_update_path2_acl(const u8 type, const char *filename1,
const char *filename2,
struct tomoyo_domain_info *const domain,
const bool is_delete);
static int tomoyo_update_path_acl(const u8 type, const char *filename,
struct tomoyo_domain_info *const domain,
const bool is_delete);
/*
* tomoyo_globally_readable_list is used for holding list of pathnames which
@ -597,19 +597,19 @@ static int tomoyo_update_file_acl(const char *filename, u8 perm,
*/
return 0;
if (perm & 4)
tomoyo_update_single_path_acl(TOMOYO_TYPE_READ_ACL, filename,
domain, is_delete);
tomoyo_update_path_acl(TOMOYO_TYPE_READ, filename, domain,
is_delete);
if (perm & 2)
tomoyo_update_single_path_acl(TOMOYO_TYPE_WRITE_ACL, filename,
domain, is_delete);
tomoyo_update_path_acl(TOMOYO_TYPE_WRITE, filename, domain,
is_delete);
if (perm & 1)
tomoyo_update_single_path_acl(TOMOYO_TYPE_EXECUTE_ACL,
filename, domain, is_delete);
tomoyo_update_path_acl(TOMOYO_TYPE_EXECUTE, filename, domain,
is_delete);
return 0;
}
/**
* tomoyo_check_single_path_acl2 - Check permission for single path operation.
* tomoyo_path_acl2 - Check permission for single path operation.
*
* @domain: Pointer to "struct tomoyo_domain_info".
* @filename: Filename to check.
@ -620,22 +620,18 @@ static int tomoyo_update_file_acl(const char *filename, u8 perm,
*
* Caller holds tomoyo_read_lock().
*/
static int tomoyo_check_single_path_acl2(const struct tomoyo_domain_info *
domain,
const struct tomoyo_path_info *
filename,
const u32 perm,
const bool may_use_pattern)
static int tomoyo_path_acl2(const struct tomoyo_domain_info *domain,
const struct tomoyo_path_info *filename,
const u32 perm, const bool may_use_pattern)
{
struct tomoyo_acl_info *ptr;
int error = -EPERM;
list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
struct tomoyo_single_path_acl_record *acl;
if (ptr->type != TOMOYO_TYPE_SINGLE_PATH_ACL)
struct tomoyo_path_acl *acl;
if (ptr->type != TOMOYO_TYPE_PATH_ACL)
continue;
acl = container_of(ptr, struct tomoyo_single_path_acl_record,
head);
acl = container_of(ptr, struct tomoyo_path_acl, head);
if (perm <= 0xFFFF) {
if (!(acl->perm & perm))
continue;
@ -676,17 +672,16 @@ static int tomoyo_check_file_acl(const struct tomoyo_domain_info *domain,
if (!tomoyo_check_flags(domain, TOMOYO_MAC_FOR_FILE))
return 0;
if (operation == 6)
perm = 1 << TOMOYO_TYPE_READ_WRITE_ACL;
perm = 1 << TOMOYO_TYPE_READ_WRITE;
else if (operation == 4)
perm = 1 << TOMOYO_TYPE_READ_ACL;
perm = 1 << TOMOYO_TYPE_READ;
else if (operation == 2)
perm = 1 << TOMOYO_TYPE_WRITE_ACL;
perm = 1 << TOMOYO_TYPE_WRITE;
else if (operation == 1)
perm = 1 << TOMOYO_TYPE_EXECUTE_ACL;
perm = 1 << TOMOYO_TYPE_EXECUTE;
else
BUG();
return tomoyo_check_single_path_acl2(domain, filename, perm,
operation != 1);
return tomoyo_path_acl2(domain, filename, perm, operation != 1);
}
/**
@ -718,13 +713,13 @@ static int tomoyo_check_file_perm2(struct tomoyo_domain_info * const domain,
&& tomoyo_is_globally_readable_file(filename))
error = 0;
if (perm == 6)
msg = tomoyo_sp2keyword(TOMOYO_TYPE_READ_WRITE_ACL);
msg = tomoyo_path2keyword(TOMOYO_TYPE_READ_WRITE);
else if (perm == 4)
msg = tomoyo_sp2keyword(TOMOYO_TYPE_READ_ACL);
msg = tomoyo_path2keyword(TOMOYO_TYPE_READ);
else if (perm == 2)
msg = tomoyo_sp2keyword(TOMOYO_TYPE_WRITE_ACL);
msg = tomoyo_path2keyword(TOMOYO_TYPE_WRITE);
else if (perm == 1)
msg = tomoyo_sp2keyword(TOMOYO_TYPE_EXECUTE_ACL);
msg = tomoyo_path2keyword(TOMOYO_TYPE_EXECUTE);
else
BUG();
if (!error)
@ -773,28 +768,28 @@ int tomoyo_write_file_policy(char *data, struct tomoyo_domain_info *domain,
if (strncmp(data, "allow_", 6))
goto out;
data += 6;
for (type = 0; type < TOMOYO_MAX_SINGLE_PATH_OPERATION; type++) {
if (strcmp(data, tomoyo_sp_keyword[type]))
for (type = 0; type < TOMOYO_MAX_PATH_OPERATION; type++) {
if (strcmp(data, tomoyo_path_keyword[type]))
continue;
return tomoyo_update_single_path_acl(type, filename,
domain, is_delete);
return tomoyo_update_path_acl(type, filename, domain,
is_delete);
}
filename2 = strchr(filename, ' ');
if (!filename2)
goto out;
*filename2++ = '\0';
for (type = 0; type < TOMOYO_MAX_DOUBLE_PATH_OPERATION; type++) {
if (strcmp(data, tomoyo_dp_keyword[type]))
for (type = 0; type < TOMOYO_MAX_PATH2_OPERATION; type++) {
if (strcmp(data, tomoyo_path2_keyword[type]))
continue;
return tomoyo_update_double_path_acl(type, filename, filename2,
domain, is_delete);
return tomoyo_update_path2_acl(type, filename, filename2,
domain, is_delete);
}
out:
return -EINVAL;
}
/**
* tomoyo_update_single_path_acl - Update "struct tomoyo_single_path_acl_record" list.
* tomoyo_update_path_acl - Update "struct tomoyo_path_acl" list.
*
* @type: Type of operation.
* @filename: Filename.
@ -805,15 +800,15 @@ int tomoyo_write_file_policy(char *data, struct tomoyo_domain_info *domain,
*
* Caller holds tomoyo_read_lock().
*/
static int tomoyo_update_single_path_acl(const u8 type, const char *filename,
struct tomoyo_domain_info *
const domain, const bool is_delete)
static int tomoyo_update_path_acl(const u8 type, const char *filename,
struct tomoyo_domain_info *const domain,
const bool is_delete)
{
static const u32 rw_mask =
(1 << TOMOYO_TYPE_READ_ACL) | (1 << TOMOYO_TYPE_WRITE_ACL);
(1 << TOMOYO_TYPE_READ) | (1 << TOMOYO_TYPE_WRITE);
const struct tomoyo_path_info *saved_filename;
struct tomoyo_acl_info *ptr;
struct tomoyo_single_path_acl_record *entry = NULL;
struct tomoyo_path_acl *entry = NULL;
int error = is_delete ? -ENOENT : -ENOMEM;
const u32 perm = 1 << type;
@ -828,10 +823,9 @@ static int tomoyo_update_single_path_acl(const u8 type, const char *filename,
entry = kmalloc(sizeof(*entry), GFP_KERNEL);
mutex_lock(&tomoyo_policy_lock);
list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
struct tomoyo_single_path_acl_record *acl =
container_of(ptr, struct tomoyo_single_path_acl_record,
head);
if (ptr->type != TOMOYO_TYPE_SINGLE_PATH_ACL)
struct tomoyo_path_acl *acl =
container_of(ptr, struct tomoyo_path_acl, head);
if (ptr->type != TOMOYO_TYPE_PATH_ACL)
continue;
if (acl->filename != saved_filename)
continue;
@ -841,9 +835,8 @@ static int tomoyo_update_single_path_acl(const u8 type, const char *filename,
else
acl->perm_high &= ~(perm >> 16);
if ((acl->perm & rw_mask) != rw_mask)
acl->perm &= ~(1 << TOMOYO_TYPE_READ_WRITE_ACL);
else if (!(acl->perm &
(1 << TOMOYO_TYPE_READ_WRITE_ACL)))
acl->perm &= ~(1 << TOMOYO_TYPE_READ_WRITE);
else if (!(acl->perm & (1 << TOMOYO_TYPE_READ_WRITE)))
acl->perm &= ~rw_mask;
} else {
if (perm <= 0xFFFF)
@ -851,20 +844,20 @@ static int tomoyo_update_single_path_acl(const u8 type, const char *filename,
else
acl->perm_high |= (perm >> 16);
if ((acl->perm & rw_mask) == rw_mask)
acl->perm |= 1 << TOMOYO_TYPE_READ_WRITE_ACL;
else if (acl->perm & (1 << TOMOYO_TYPE_READ_WRITE_ACL))
acl->perm |= 1 << TOMOYO_TYPE_READ_WRITE;
else if (acl->perm & (1 << TOMOYO_TYPE_READ_WRITE))
acl->perm |= rw_mask;
}
error = 0;
break;
}
if (!is_delete && error && tomoyo_memory_ok(entry)) {
entry->head.type = TOMOYO_TYPE_SINGLE_PATH_ACL;
entry->head.type = TOMOYO_TYPE_PATH_ACL;
if (perm <= 0xFFFF)
entry->perm = perm;
else
entry->perm_high = (perm >> 16);
if (perm == (1 << TOMOYO_TYPE_READ_WRITE_ACL))
if (perm == (1 << TOMOYO_TYPE_READ_WRITE))
entry->perm |= rw_mask;
entry->filename = saved_filename;
saved_filename = NULL;
@ -879,7 +872,7 @@ static int tomoyo_update_single_path_acl(const u8 type, const char *filename,
}
/**
* tomoyo_update_double_path_acl - Update "struct tomoyo_double_path_acl_record" list.
* tomoyo_update_path2_acl - Update "struct tomoyo_path2_acl" list.
*
* @type: Type of operation.
* @filename1: First filename.
@ -891,15 +884,15 @@ static int tomoyo_update_single_path_acl(const u8 type, const char *filename,
*
* Caller holds tomoyo_read_lock().
*/
static int tomoyo_update_double_path_acl(const u8 type, const char *filename1,
const char *filename2,
struct tomoyo_domain_info *
const domain, const bool is_delete)
static int tomoyo_update_path2_acl(const u8 type, const char *filename1,
const char *filename2,
struct tomoyo_domain_info *const domain,
const bool is_delete)
{
const struct tomoyo_path_info *saved_filename1;
const struct tomoyo_path_info *saved_filename2;
struct tomoyo_acl_info *ptr;
struct tomoyo_double_path_acl_record *entry = NULL;
struct tomoyo_path2_acl *entry = NULL;
int error = is_delete ? -ENOENT : -ENOMEM;
const u8 perm = 1 << type;
@ -916,10 +909,9 @@ static int tomoyo_update_double_path_acl(const u8 type, const char *filename1,
entry = kmalloc(sizeof(*entry), GFP_KERNEL);
mutex_lock(&tomoyo_policy_lock);
list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
struct tomoyo_double_path_acl_record *acl =
container_of(ptr, struct tomoyo_double_path_acl_record,
head);
if (ptr->type != TOMOYO_TYPE_DOUBLE_PATH_ACL)
struct tomoyo_path2_acl *acl =
container_of(ptr, struct tomoyo_path2_acl, head);
if (ptr->type != TOMOYO_TYPE_PATH2_ACL)
continue;
if (acl->filename1 != saved_filename1 ||
acl->filename2 != saved_filename2)
@ -932,7 +924,7 @@ static int tomoyo_update_double_path_acl(const u8 type, const char *filename1,
break;
}
if (!is_delete && error && tomoyo_memory_ok(entry)) {
entry->head.type = TOMOYO_TYPE_DOUBLE_PATH_ACL;
entry->head.type = TOMOYO_TYPE_PATH2_ACL;
entry->perm = perm;
entry->filename1 = saved_filename1;
saved_filename1 = NULL;
@ -951,7 +943,7 @@ static int tomoyo_update_double_path_acl(const u8 type, const char *filename1,
}
/**
* tomoyo_check_single_path_acl - Check permission for single path operation.
* tomoyo_path_acl - Check permission for single path operation.
*
* @domain: Pointer to "struct tomoyo_domain_info".
* @type: Type of operation.
@ -961,17 +953,16 @@ static int tomoyo_update_double_path_acl(const u8 type, const char *filename1,
*
* Caller holds tomoyo_read_lock().
*/
static int tomoyo_check_single_path_acl(struct tomoyo_domain_info *domain,
const u8 type,
const struct tomoyo_path_info *filename)
static int tomoyo_path_acl(struct tomoyo_domain_info *domain, const u8 type,
const struct tomoyo_path_info *filename)
{
if (!tomoyo_check_flags(domain, TOMOYO_MAC_FOR_FILE))
return 0;
return tomoyo_check_single_path_acl2(domain, filename, 1 << type, 1);
return tomoyo_path_acl2(domain, filename, 1 << type, 1);
}
/**
* tomoyo_check_double_path_acl - Check permission for double path operation.
* tomoyo_path2_acl - Check permission for double path operation.
*
* @domain: Pointer to "struct tomoyo_domain_info".
* @type: Type of operation.
@ -982,12 +973,10 @@ static int tomoyo_check_single_path_acl(struct tomoyo_domain_info *domain,
*
* Caller holds tomoyo_read_lock().
*/
static int tomoyo_check_double_path_acl(const struct tomoyo_domain_info *domain,
const u8 type,
const struct tomoyo_path_info *
filename1,
const struct tomoyo_path_info *
filename2)
static int tomoyo_path2_acl(const struct tomoyo_domain_info *domain,
const u8 type,
const struct tomoyo_path_info *filename1,
const struct tomoyo_path_info *filename2)
{
struct tomoyo_acl_info *ptr;
const u8 perm = 1 << type;
@ -996,11 +985,10 @@ static int tomoyo_check_double_path_acl(const struct tomoyo_domain_info *domain,
if (!tomoyo_check_flags(domain, TOMOYO_MAC_FOR_FILE))
return 0;
list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
struct tomoyo_double_path_acl_record *acl;
if (ptr->type != TOMOYO_TYPE_DOUBLE_PATH_ACL)
struct tomoyo_path2_acl *acl;
if (ptr->type != TOMOYO_TYPE_PATH2_ACL)
continue;
acl = container_of(ptr, struct tomoyo_double_path_acl_record,
head);
acl = container_of(ptr, struct tomoyo_path2_acl, head);
if (!(acl->perm & perm))
continue;
if (!tomoyo_path_matches_pattern(filename1, acl->filename1))
@ -1014,7 +1002,7 @@ static int tomoyo_check_double_path_acl(const struct tomoyo_domain_info *domain,
}
/**
* tomoyo_check_single_path_permission2 - Check permission for single path operation.
* tomoyo_path_permission2 - Check permission for single path operation.
*
* @domain: Pointer to "struct tomoyo_domain_info".
* @operation: Type of operation.
@ -1025,10 +1013,10 @@ static int tomoyo_check_double_path_acl(const struct tomoyo_domain_info *domain,
*
* Caller holds tomoyo_read_lock().
*/
static int tomoyo_check_single_path_permission2(struct tomoyo_domain_info *
const domain, u8 operation,
const struct tomoyo_path_info *
filename, const u8 mode)
static int tomoyo_path_permission2(struct tomoyo_domain_info *const domain,
u8 operation,
const struct tomoyo_path_info *filename,
const u8 mode)
{
const char *msg;
int error;
@ -1037,8 +1025,8 @@ static int tomoyo_check_single_path_permission2(struct tomoyo_domain_info *
if (!mode)
return 0;
next:
error = tomoyo_check_single_path_acl(domain, operation, filename);
msg = tomoyo_sp2keyword(operation);
error = tomoyo_path_acl(domain, operation, filename);
msg = tomoyo_path2keyword(operation);
if (!error)
goto ok;
if (tomoyo_verbose_mode(domain))
@ -1047,7 +1035,7 @@ static int tomoyo_check_single_path_permission2(struct tomoyo_domain_info *
tomoyo_get_last_name(domain));
if (mode == 1 && tomoyo_domain_quota_is_ok(domain)) {
const char *name = tomoyo_get_file_pattern(filename)->name;
tomoyo_update_single_path_acl(operation, name, domain, false);
tomoyo_update_path_acl(operation, name, domain, false);
}
if (!is_enforce)
error = 0;
@ -1057,9 +1045,9 @@ static int tomoyo_check_single_path_permission2(struct tomoyo_domain_info *
* we need to check "allow_rewrite" permission if the filename is
* specified by "deny_rewrite" keyword.
*/
if (!error && operation == TOMOYO_TYPE_TRUNCATE_ACL &&
if (!error && operation == TOMOYO_TYPE_TRUNCATE &&
tomoyo_is_no_rewrite_file(filename)) {
operation = TOMOYO_TYPE_REWRITE_ACL;
operation = TOMOYO_TYPE_REWRITE;
goto next;
}
return error;
@ -1127,17 +1115,15 @@ int tomoyo_check_open_permission(struct tomoyo_domain_info *domain,
if ((acc_mode & MAY_WRITE) &&
((flag & O_TRUNC) || !(flag & O_APPEND)) &&
(tomoyo_is_no_rewrite_file(buf))) {
error = tomoyo_check_single_path_permission2(domain,
TOMOYO_TYPE_REWRITE_ACL,
buf, mode);
error = tomoyo_path_permission2(domain, TOMOYO_TYPE_REWRITE,
buf, mode);
}
if (!error)
error = tomoyo_check_file_perm2(domain, buf, acc_mode, "open",
mode);
if (!error && (flag & O_TRUNC))
error = tomoyo_check_single_path_permission2(domain,
TOMOYO_TYPE_TRUNCATE_ACL,
buf, mode);
error = tomoyo_path_permission2(domain, TOMOYO_TYPE_TRUNCATE,
buf, mode);
out:
kfree(buf);
tomoyo_read_unlock(idx);
@ -1147,7 +1133,7 @@ int tomoyo_check_open_permission(struct tomoyo_domain_info *domain,
}
/**
* tomoyo_check_1path_perm - Check permission for "create", "unlink", "mkdir", "rmdir", "mkfifo", "mksock", "mkblock", "mkchar", "truncate", "symlink", "ioctl", "chmod", "chown", "chgrp", "chroot", "mount" and "unmount".
* tomoyo_path_perm - Check permission for "create", "unlink", "mkdir", "rmdir", "mkfifo", "mksock", "mkblock", "mkchar", "truncate", "symlink", "ioctl", "chmod", "chown", "chgrp", "chroot", "mount" and "unmount".
*
* @domain: Pointer to "struct tomoyo_domain_info".
* @operation: Type of operation.
@ -1155,8 +1141,8 @@ int tomoyo_check_open_permission(struct tomoyo_domain_info *domain,
*
* Returns 0 on success, negative value otherwise.
*/
int tomoyo_check_1path_perm(struct tomoyo_domain_info *domain,
const u8 operation, struct path *path)
int tomoyo_path_perm(struct tomoyo_domain_info *domain,
const u8 operation, struct path *path)
{
int error = -ENOMEM;
struct tomoyo_path_info *buf;
@ -1171,9 +1157,9 @@ int tomoyo_check_1path_perm(struct tomoyo_domain_info *domain,
if (!buf)
goto out;
switch (operation) {
case TOMOYO_TYPE_MKDIR_ACL:
case TOMOYO_TYPE_RMDIR_ACL:
case TOMOYO_TYPE_CHROOT_ACL:
case TOMOYO_TYPE_MKDIR:
case TOMOYO_TYPE_RMDIR:
case TOMOYO_TYPE_CHROOT:
if (!buf->is_dir) {
/*
* tomoyo_get_path() reserves space for appending "/."
@ -1182,8 +1168,7 @@ int tomoyo_check_1path_perm(struct tomoyo_domain_info *domain,
tomoyo_fill_path_info(buf);
}
}
error = tomoyo_check_single_path_permission2(domain, operation, buf,
mode);
error = tomoyo_path_permission2(domain, operation, buf, mode);
out:
kfree(buf);
tomoyo_read_unlock(idx);
@ -1220,9 +1205,7 @@ int tomoyo_check_rewrite_permission(struct tomoyo_domain_info *domain,
error = 0;
goto out;
}
error = tomoyo_check_single_path_permission2(domain,
TOMOYO_TYPE_REWRITE_ACL,
buf, mode);
error = tomoyo_path_permission2(domain, TOMOYO_TYPE_REWRITE, buf, mode);
out:
kfree(buf);
tomoyo_read_unlock(idx);
@ -1232,7 +1215,7 @@ int tomoyo_check_rewrite_permission(struct tomoyo_domain_info *domain,
}
/**
* tomoyo_check_2path_perm - Check permission for "rename", "link" and "pivot_root".
* tomoyo_path2_perm - Check permission for "rename", "link" and "pivot_root".
*
* @domain: Pointer to "struct tomoyo_domain_info".
* @operation: Type of operation.
@ -1241,9 +1224,9 @@ int tomoyo_check_rewrite_permission(struct tomoyo_domain_info *domain,
*
* Returns 0 on success, negative value otherwise.
*/
int tomoyo_check_2path_perm(struct tomoyo_domain_info * const domain,
const u8 operation, struct path *path1,
struct path *path2)
int tomoyo_path2_perm(struct tomoyo_domain_info * const domain,
const u8 operation, struct path *path1,
struct path *path2)
{
int error = -ENOMEM;
struct tomoyo_path_info *buf1, *buf2;
@ -1275,8 +1258,8 @@ int tomoyo_check_2path_perm(struct tomoyo_domain_info * const domain,
}
}
}
error = tomoyo_check_double_path_acl(domain, operation, buf1, buf2);
msg = tomoyo_dp2keyword(operation);
error = tomoyo_path2_acl(domain, operation, buf1, buf2);
msg = tomoyo_path22keyword(operation);
if (!error)
goto out;
if (tomoyo_verbose_mode(domain))
@ -1287,8 +1270,8 @@ int tomoyo_check_2path_perm(struct tomoyo_domain_info * const domain,
if (mode == 1 && tomoyo_domain_quota_is_ok(domain)) {
const char *name1 = tomoyo_get_file_pattern(buf1)->name;
const char *name2 = tomoyo_get_file_pattern(buf2)->name;
tomoyo_update_double_path_acl(operation, name1, name2, domain,
false);
tomoyo_update_path2_acl(operation, name1, name2, domain,
false);
}
out:
kfree(buf1);

18
security/tomoyo/gc.c
Просмотреть файл

@ -86,16 +86,16 @@ static void tomoyo_del_manager(struct tomoyo_policy_manager_entry *ptr)
static void tomoyo_del_acl(struct tomoyo_acl_info *acl)
{
switch (acl->type) {
case TOMOYO_TYPE_SINGLE_PATH_ACL:
case TOMOYO_TYPE_PATH_ACL:
{
struct tomoyo_single_path_acl_record *entry
struct tomoyo_path_acl *entry
= container_of(acl, typeof(*entry), head);
tomoyo_put_name(entry->filename);
}
break;
case TOMOYO_TYPE_DOUBLE_PATH_ACL:
case TOMOYO_TYPE_PATH2_ACL:
{
struct tomoyo_double_path_acl_record *entry
struct tomoyo_path2_acl *entry
= container_of(acl, typeof(*entry), head);
tomoyo_put_name(entry->filename1);
tomoyo_put_name(entry->filename2);
@ -238,18 +238,18 @@ static void tomoyo_collect_entry(void)
list_for_each_entry_rcu(acl, &domain->acl_info_list,
list) {
switch (acl->type) {
case TOMOYO_TYPE_SINGLE_PATH_ACL:
case TOMOYO_TYPE_PATH_ACL:
if (container_of(acl,
struct tomoyo_single_path_acl_record,
struct tomoyo_path_acl,
head)->perm ||
container_of(acl,
struct tomoyo_single_path_acl_record,
struct tomoyo_path_acl,
head)->perm_high)
continue;
break;
case TOMOYO_TYPE_DOUBLE_PATH_ACL:
case TOMOYO_TYPE_PATH2_ACL:
if (container_of(acl,
struct tomoyo_double_path_acl_record,
struct tomoyo_path2_acl,
head)->perm)
continue;
break;

72
security/tomoyo/tomoyo.c
Просмотреть файл

@ -100,67 +100,56 @@ static int tomoyo_bprm_check_security(struct linux_binprm *bprm)
static int tomoyo_path_truncate(struct path *path, loff_t length,
unsigned int time_attrs)
{
return tomoyo_check_1path_perm(tomoyo_domain(),
TOMOYO_TYPE_TRUNCATE_ACL,
path);
return tomoyo_path_perm(tomoyo_domain(), TOMOYO_TYPE_TRUNCATE, path);
}
static int tomoyo_path_unlink(struct path *parent, struct dentry *dentry)
{
struct path path = { parent->mnt, dentry };
return tomoyo_check_1path_perm(tomoyo_domain(),
TOMOYO_TYPE_UNLINK_ACL,
&path);
return tomoyo_path_perm(tomoyo_domain(), TOMOYO_TYPE_UNLINK, &path);
}
static int tomoyo_path_mkdir(struct path *parent, struct dentry *dentry,
int mode)
{
struct path path = { parent->mnt, dentry };
return tomoyo_check_1path_perm(tomoyo_domain(),
TOMOYO_TYPE_MKDIR_ACL,
&path);
return tomoyo_path_perm(tomoyo_domain(), TOMOYO_TYPE_MKDIR, &path);
}
static int tomoyo_path_rmdir(struct path *parent, struct dentry *dentry)
{
struct path path = { parent->mnt, dentry };
return tomoyo_check_1path_perm(tomoyo_domain(),
TOMOYO_TYPE_RMDIR_ACL,
&path);
return tomoyo_path_perm(tomoyo_domain(), TOMOYO_TYPE_RMDIR, &path);
}
static int tomoyo_path_symlink(struct path *parent, struct dentry *dentry,
const char *old_name)
{
struct path path = { parent->mnt, dentry };
return tomoyo_check_1path_perm(tomoyo_domain(),
TOMOYO_TYPE_SYMLINK_ACL,
&path);
return tomoyo_path_perm(tomoyo_domain(), TOMOYO_TYPE_SYMLINK, &path);
}
static int tomoyo_path_mknod(struct path *parent, struct dentry *dentry,
int mode, unsigned int dev)
{
struct path path = { parent->mnt, dentry };
int type = TOMOYO_TYPE_CREATE_ACL;
int type = TOMOYO_TYPE_CREATE;
switch (mode & S_IFMT) {
case S_IFCHR:
type = TOMOYO_TYPE_MKCHAR_ACL;
type = TOMOYO_TYPE_MKCHAR;
break;
case S_IFBLK:
type = TOMOYO_TYPE_MKBLOCK_ACL;
type = TOMOYO_TYPE_MKBLOCK;
break;
case S_IFIFO:
type = TOMOYO_TYPE_MKFIFO_ACL;
type = TOMOYO_TYPE_MKFIFO;
break;
case S_IFSOCK:
type = TOMOYO_TYPE_MKSOCK_ACL;
type = TOMOYO_TYPE_MKSOCK;
break;
}
return tomoyo_check_1path_perm(tomoyo_domain(),
type, &path);
return tomoyo_path_perm(tomoyo_domain(), type, &path);
}
static int tomoyo_path_link(struct dentry *old_dentry, struct path *new_dir,
@ -168,9 +157,8 @@ static int tomoyo_path_link(struct dentry *old_dentry, struct path *new_dir,
{
struct path path1 = { new_dir->mnt, old_dentry };
struct path path2 = { new_dir->mnt, new_dentry };
return tomoyo_check_2path_perm(tomoyo_domain(),
TOMOYO_TYPE_LINK_ACL,
&path1, &path2);
return tomoyo_path2_perm(tomoyo_domain(), TOMOYO_TYPE_LINK, &path1,
&path2);
}
static int tomoyo_path_rename(struct path *old_parent,
@ -180,9 +168,8 @@ static int tomoyo_path_rename(struct path *old_parent,
{
struct path path1 = { old_parent->mnt, old_dentry };
struct path path2 = { new_parent->mnt, new_dentry };
return tomoyo_check_2path_perm(tomoyo_domain(),
TOMOYO_TYPE_RENAME_ACL,
&path1, &path2);
return tomoyo_path2_perm(tomoyo_domain(), TOMOYO_TYPE_RENAME, &path1,
&path2);
}
static int tomoyo_file_fcntl(struct file *file, unsigned int cmd,
@ -209,55 +196,50 @@ static int tomoyo_dentry_open(struct file *f, const struct cred *cred)
static int tomoyo_file_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
return tomoyo_check_1path_perm(tomoyo_domain(), TOMOYO_TYPE_IOCTL_ACL,
&file->f_path);
return tomoyo_path_perm(tomoyo_domain(), TOMOYO_TYPE_IOCTL,
&file->f_path);
}
static int tomoyo_path_chmod(struct dentry *dentry, struct vfsmount *mnt,
mode_t mode)
{
struct path path = { mnt, dentry };
return tomoyo_check_1path_perm(tomoyo_domain(), TOMOYO_TYPE_CHMOD_ACL,
&path);
return tomoyo_path_perm(tomoyo_domain(), TOMOYO_TYPE_CHMOD, &path);
}
static int tomoyo_path_chown(struct path *path, uid_t uid, gid_t gid)
{
int error = 0;
if (uid != (uid_t) -1)
error = tomoyo_check_1path_perm(tomoyo_domain(),
TOMOYO_TYPE_CHOWN_ACL, path);
error = tomoyo_path_perm(tomoyo_domain(), TOMOYO_TYPE_CHOWN,
path);
if (!error && gid != (gid_t) -1)
error = tomoyo_check_1path_perm(tomoyo_domain(),
TOMOYO_TYPE_CHGRP_ACL, path);
error = tomoyo_path_perm(tomoyo_domain(), TOMOYO_TYPE_CHGRP,
path);
return error;
}
static int tomoyo_path_chroot(struct path *path)
{
return tomoyo_check_1path_perm(tomoyo_domain(), TOMOYO_TYPE_CHROOT_ACL,
path);
return tomoyo_path_perm(tomoyo_domain(), TOMOYO_TYPE_CHROOT, path);
}
static int tomoyo_sb_mount(char *dev_name, struct path *path,
char *type, unsigned long flags, void *data)
{
return tomoyo_check_1path_perm(tomoyo_domain(), TOMOYO_TYPE_MOUNT_ACL,
path);
return tomoyo_path_perm(tomoyo_domain(), TOMOYO_TYPE_MOUNT, path);
}
static int tomoyo_sb_umount(struct vfsmount *mnt, int flags)
{
struct path path = { mnt, mnt->mnt_root };
return tomoyo_check_1path_perm(tomoyo_domain(), TOMOYO_TYPE_UMOUNT_ACL,
&path);
return tomoyo_path_perm(tomoyo_domain(), TOMOYO_TYPE_UMOUNT, &path);
}
static int tomoyo_sb_pivotroot(struct path *old_path, struct path *new_path)
{
return tomoyo_check_2path_perm(tomoyo_domain(),
TOMOYO_TYPE_PIVOT_ROOT_ACL,
new_path, old_path);
return tomoyo_path2_perm(tomoyo_domain(), TOMOYO_TYPE_PIVOT_ROOT,
new_path, old_path);
}
/*