mirror of
https://github.com/FEX-Emu/linux.git
synced 2024-12-14 04:41:26 +00:00
TOMOYO: Use callback for updating entries.
Use common "struct list_head" + "bool" + "u8" structure and use common code for elements using that structure. 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
James Morris
parent
927942aabb
commit
237ab459f1
@ -950,8 +950,6 @@ static bool tomoyo_print_mount_acl(struct tomoyo_io_buffer *head,
|
||||
struct tomoyo_mount_acl *ptr)
|
||||
{
|
||||
const int pos = head->read_avail;
|
||||
if (ptr->is_deleted)
|
||||
return true;
|
||||
if (!tomoyo_io_printf(head, TOMOYO_KEYWORD_ALLOW_MOUNT) ||
|
||||
!tomoyo_print_name_union(head, &ptr->dev_name) ||
|
||||
!tomoyo_print_name_union(head, &ptr->dir_name) ||
|
||||
@ -977,6 +975,8 @@ static bool tomoyo_print_entry(struct tomoyo_io_buffer *head,
|
||||
{
|
||||
const u8 acl_type = ptr->type;
|
||||
|
||||
if (ptr->is_deleted)
|
||||
return true;
|
||||
if (acl_type == TOMOYO_TYPE_PATH_ACL) {
|
||||
struct tomoyo_path_acl *acl
|
||||
= container_of(ptr, struct tomoyo_path_acl, head);
|
||||
|
||||
@ -112,6 +112,8 @@ enum tomoyo_path_acl_index {
|
||||
TOMOYO_MAX_PATH_OPERATION
|
||||
};
|
||||
|
||||
#define TOMOYO_RW_MASK ((1 << TOMOYO_TYPE_READ) | (1 << TOMOYO_TYPE_WRITE))
|
||||
|
||||
enum tomoyo_path_number3_acl_index {
|
||||
TOMOYO_TYPE_MKBLOCK,
|
||||
TOMOYO_TYPE_MKCHAR,
|
||||
@ -289,17 +291,19 @@ struct tomoyo_number_group_member {
|
||||
*
|
||||
* (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_path_acl" or "struct tomoyo_path2_acl").
|
||||
* (2) "is_deleted" is a bool which is true if this domain is marked as
|
||||
* "deleted", false otherwise.
|
||||
* (3) "type" which tells type of the entry.
|
||||
*
|
||||
* Packing "struct tomoyo_acl_info" allows
|
||||
* "struct tomoyo_path_acl" to embed "u8" + "u16" and
|
||||
* "struct tomoyo_path2_acl" to embed "u8"
|
||||
* without enlarging their structure size.
|
||||
* "struct tomoyo_path_acl" to embed "u16" and "struct tomoyo_path2_acl"
|
||||
* "struct tomoyo_path_number_acl" "struct tomoyo_path_number3_acl" to embed
|
||||
* "u8" without enlarging their structure size.
|
||||
*/
|
||||
struct tomoyo_acl_info {
|
||||
struct list_head list;
|
||||
u8 type;
|
||||
bool is_deleted;
|
||||
u8 type; /* = one of values in "enum tomoyo_acl_entry_type_index". */
|
||||
} __packed;
|
||||
|
||||
/*
|
||||
@ -438,17 +442,15 @@ struct tomoyo_path2_acl {
|
||||
* It has following fields.
|
||||
*
|
||||
* (1) "head" which is a "struct tomoyo_acl_info".
|
||||
* (2) "is_deleted" is boolean.
|
||||
* (3) "dev_name" is the device name.
|
||||
* (4) "dir_name" is the mount point.
|
||||
* (2) "dev_name" is the device name.
|
||||
* (3) "dir_name" is the mount point.
|
||||
* (4) "fs_type" is the filesystem type.
|
||||
* (5) "flags" is the mount flags.
|
||||
*
|
||||
* Directives held by this structure are "allow_rename", "allow_link" and
|
||||
* "allow_pivot_root".
|
||||
* Directive held by this structure is "allow_mount".
|
||||
*/
|
||||
struct tomoyo_mount_acl {
|
||||
struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_MOUNT_ACL */
|
||||
bool is_deleted;
|
||||
struct tomoyo_name_union dev_name;
|
||||
struct tomoyo_name_union dir_name;
|
||||
struct tomoyo_name_union fs_type;
|
||||
@ -914,6 +916,16 @@ void tomoyo_run_gc(void);
|
||||
|
||||
void tomoyo_memory_free(void *ptr);
|
||||
|
||||
int tomoyo_update_domain(struct tomoyo_acl_info *new_entry, const int size,
|
||||
bool is_delete, struct tomoyo_domain_info *domain,
|
||||
bool (*check_duplicate) (const struct tomoyo_acl_info
|
||||
*,
|
||||
const struct tomoyo_acl_info
|
||||
*),
|
||||
bool (*merge_duplicate) (struct tomoyo_acl_info *,
|
||||
struct tomoyo_acl_info *,
|
||||
const bool));
|
||||
|
||||
/********** External variable definitions. **********/
|
||||
|
||||
/* Lock for GC. */
|
||||
@ -1042,52 +1054,6 @@ static inline bool tomoyo_is_same_number_union
|
||||
p1->max_type == p2->max_type && p1->is_group == p2->is_group;
|
||||
}
|
||||
|
||||
static inline bool tomoyo_is_same_path_acl(const struct tomoyo_path_acl *p1,
|
||||
const struct tomoyo_path_acl *p2)
|
||||
{
|
||||
return tomoyo_is_same_acl_head(&p1->head, &p2->head) &&
|
||||
tomoyo_is_same_name_union(&p1->name, &p2->name);
|
||||
}
|
||||
|
||||
static inline bool tomoyo_is_same_path_number3_acl
|
||||
(const struct tomoyo_path_number3_acl *p1,
|
||||
const struct tomoyo_path_number3_acl *p2)
|
||||
{
|
||||
return tomoyo_is_same_acl_head(&p1->head, &p2->head)
|
||||
&& tomoyo_is_same_name_union(&p1->name, &p2->name)
|
||||
&& tomoyo_is_same_number_union(&p1->mode, &p2->mode)
|
||||
&& tomoyo_is_same_number_union(&p1->major, &p2->major)
|
||||
&& tomoyo_is_same_number_union(&p1->minor, &p2->minor);
|
||||
}
|
||||
|
||||
|
||||
static inline bool tomoyo_is_same_path2_acl(const struct tomoyo_path2_acl *p1,
|
||||
const struct tomoyo_path2_acl *p2)
|
||||
{
|
||||
return tomoyo_is_same_acl_head(&p1->head, &p2->head) &&
|
||||
tomoyo_is_same_name_union(&p1->name1, &p2->name1) &&
|
||||
tomoyo_is_same_name_union(&p1->name2, &p2->name2);
|
||||
}
|
||||
|
||||
static inline bool tomoyo_is_same_path_number_acl
|
||||
(const struct tomoyo_path_number_acl *p1,
|
||||
const struct tomoyo_path_number_acl *p2)
|
||||
{
|
||||
return tomoyo_is_same_acl_head(&p1->head, &p2->head)
|
||||
&& tomoyo_is_same_name_union(&p1->name, &p2->name)
|
||||
&& tomoyo_is_same_number_union(&p1->number, &p2->number);
|
||||
}
|
||||
|
||||
static inline bool tomoyo_is_same_mount_acl(const struct tomoyo_mount_acl *p1,
|
||||
const struct tomoyo_mount_acl *p2)
|
||||
{
|
||||
return tomoyo_is_same_acl_head(&p1->head, &p2->head) &&
|
||||
tomoyo_is_same_name_union(&p1->dev_name, &p2->dev_name) &&
|
||||
tomoyo_is_same_name_union(&p1->dir_name, &p2->dir_name) &&
|
||||
tomoyo_is_same_name_union(&p1->fs_type, &p2->fs_type) &&
|
||||
tomoyo_is_same_number_union(&p1->flags, &p2->flags);
|
||||
}
|
||||
|
||||
static inline bool tomoyo_is_same_domain_initializer_entry
|
||||
(const struct tomoyo_domain_initializer_entry *p1,
|
||||
const struct tomoyo_domain_initializer_entry *p2)
|
||||
|
||||
@ -15,6 +15,57 @@
|
||||
/* The initial domain. */
|
||||
struct tomoyo_domain_info tomoyo_kernel_domain;
|
||||
|
||||
/**
|
||||
* tomoyo_update_domain - Update an entry for domain policy.
|
||||
*
|
||||
* @new_entry: Pointer to "struct tomoyo_acl_info".
|
||||
* @size: Size of @new_entry in bytes.
|
||||
* @is_delete: True if it is a delete request.
|
||||
* @domain: Pointer to "struct tomoyo_domain_info".
|
||||
* @check_duplicate: Callback function to find duplicated entry.
|
||||
* @merge_duplicate: Callback function to merge duplicated entry.
|
||||
*
|
||||
* Returns 0 on success, negative value otherwise.
|
||||
*
|
||||
* Caller holds tomoyo_read_lock().
|
||||
*/
|
||||
int tomoyo_update_domain(struct tomoyo_acl_info *new_entry, const int size,
|
||||
bool is_delete, struct tomoyo_domain_info *domain,
|
||||
bool (*check_duplicate) (const struct tomoyo_acl_info
|
||||
*,
|
||||
const struct tomoyo_acl_info
|
||||
*),
|
||||
bool (*merge_duplicate) (struct tomoyo_acl_info *,
|
||||
struct tomoyo_acl_info *,
|
||||
const bool))
|
||||
{
|
||||
int error = is_delete ? -ENOENT : -ENOMEM;
|
||||
struct tomoyo_acl_info *entry;
|
||||
|
||||
if (mutex_lock_interruptible(&tomoyo_policy_lock))
|
||||
return error;
|
||||
list_for_each_entry_rcu(entry, &domain->acl_info_list, list) {
|
||||
if (!check_duplicate(entry, new_entry))
|
||||
continue;
|
||||
if (merge_duplicate)
|
||||
entry->is_deleted = merge_duplicate(entry, new_entry,
|
||||
is_delete);
|
||||
else
|
||||
entry->is_deleted = is_delete;
|
||||
error = 0;
|
||||
break;
|
||||
}
|
||||
if (error && !is_delete) {
|
||||
entry = tomoyo_commit_ok(new_entry, size);
|
||||
if (entry) {
|
||||
list_add_tail_rcu(&entry->list, &domain->acl_info_list);
|
||||
error = 0;
|
||||
}
|
||||
}
|
||||
mutex_unlock(&tomoyo_policy_lock);
|
||||
return error;
|
||||
}
|
||||
|
||||
/*
|
||||
* tomoyo_domain_list is used for holding list of domains.
|
||||
* The ->acl_info_list of "struct tomoyo_domain_info" is used for holding
|
||||
|
||||
@ -664,50 +664,6 @@ bool tomoyo_read_no_rewrite_policy(struct tomoyo_io_buffer *head)
|
||||
return done;
|
||||
}
|
||||
|
||||
/**
|
||||
* tomoyo_update_file_acl - Update file's read/write/execute ACL.
|
||||
*
|
||||
* @perm: Permission (between 1 to 7).
|
||||
* @filename: Filename.
|
||||
* @domain: Pointer to "struct tomoyo_domain_info".
|
||||
* @is_delete: True if it is a delete request.
|
||||
*
|
||||
* Returns 0 on success, negative value otherwise.
|
||||
*
|
||||
* This is legacy support interface for older policy syntax.
|
||||
* Current policy syntax uses "allow_read/write" instead of "6",
|
||||
* "allow_read" instead of "4", "allow_write" instead of "2",
|
||||
* "allow_execute" instead of "1".
|
||||
*
|
||||
* Caller holds tomoyo_read_lock().
|
||||
*/
|
||||
static int tomoyo_update_file_acl(u8 perm, const char *filename,
|
||||
struct tomoyo_domain_info * const domain,
|
||||
const bool is_delete)
|
||||
{
|
||||
if (perm > 7 || !perm) {
|
||||
printk(KERN_DEBUG "%s: Invalid permission '%d %s'\n",
|
||||
__func__, perm, filename);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (filename[0] != '@' && tomoyo_strendswith(filename, "/"))
|
||||
/*
|
||||
* Only 'allow_mkdir' and 'allow_rmdir' are valid for
|
||||
* directory permissions.
|
||||
*/
|
||||
return 0;
|
||||
if (perm & 4)
|
||||
tomoyo_update_path_acl(TOMOYO_TYPE_READ, filename, domain,
|
||||
is_delete);
|
||||
if (perm & 2)
|
||||
tomoyo_update_path_acl(TOMOYO_TYPE_WRITE, filename, domain,
|
||||
is_delete);
|
||||
if (perm & 1)
|
||||
tomoyo_update_path_acl(TOMOYO_TYPE_EXECUTE, filename, domain,
|
||||
is_delete);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* tomoyo_path_acl - Check permission for single path operation.
|
||||
*
|
||||
@ -797,6 +753,40 @@ static int tomoyo_file_perm(struct tomoyo_request_info *r,
|
||||
return error;
|
||||
}
|
||||
|
||||
static bool tomoyo_same_path_acl(const struct tomoyo_acl_info *a,
|
||||
const struct tomoyo_acl_info *b)
|
||||
{
|
||||
const struct tomoyo_path_acl *p1 = container_of(a, typeof(*p1), head);
|
||||
const struct tomoyo_path_acl *p2 = container_of(b, typeof(*p2), head);
|
||||
return tomoyo_is_same_acl_head(&p1->head, &p2->head) &&
|
||||
tomoyo_is_same_name_union(&p1->name, &p2->name);
|
||||
}
|
||||
|
||||
static bool tomoyo_merge_path_acl(struct tomoyo_acl_info *a,
|
||||
struct tomoyo_acl_info *b,
|
||||
const bool is_delete)
|
||||
{
|
||||
u16 * const a_perm = &container_of(a, struct tomoyo_path_acl, head)
|
||||
->perm;
|
||||
u16 perm = *a_perm;
|
||||
const u16 b_perm = container_of(b, struct tomoyo_path_acl, head)->perm;
|
||||
if (is_delete) {
|
||||
perm &= ~b_perm;
|
||||
if ((perm & TOMOYO_RW_MASK) != TOMOYO_RW_MASK)
|
||||
perm &= ~(1 << TOMOYO_TYPE_READ_WRITE);
|
||||
else if (!(perm & (1 << TOMOYO_TYPE_READ_WRITE)))
|
||||
perm &= ~TOMOYO_RW_MASK;
|
||||
} else {
|
||||
perm |= b_perm;
|
||||
if ((perm & TOMOYO_RW_MASK) == TOMOYO_RW_MASK)
|
||||
perm |= (1 << TOMOYO_TYPE_READ_WRITE);
|
||||
else if (perm & (1 << TOMOYO_TYPE_READ_WRITE))
|
||||
perm |= TOMOYO_RW_MASK;
|
||||
}
|
||||
*a_perm = perm;
|
||||
return !perm;
|
||||
}
|
||||
|
||||
/**
|
||||
* tomoyo_update_path_acl - Update "struct tomoyo_path_acl" list.
|
||||
*
|
||||
@ -810,63 +800,56 @@ static int tomoyo_file_perm(struct tomoyo_request_info *r,
|
||||
* Caller holds tomoyo_read_lock().
|
||||
*/
|
||||
static int tomoyo_update_path_acl(const u8 type, const char *filename,
|
||||
struct tomoyo_domain_info *const domain,
|
||||
struct tomoyo_domain_info * const domain,
|
||||
const bool is_delete)
|
||||
{
|
||||
static const u16 tomoyo_rw_mask =
|
||||
(1 << TOMOYO_TYPE_READ) | (1 << TOMOYO_TYPE_WRITE);
|
||||
const u16 perm = 1 << type;
|
||||
struct tomoyo_acl_info *ptr;
|
||||
struct tomoyo_path_acl e = {
|
||||
.head.type = TOMOYO_TYPE_PATH_ACL,
|
||||
.perm = perm
|
||||
.perm = 1 << type
|
||||
};
|
||||
int error = is_delete ? -ENOENT : -ENOMEM;
|
||||
|
||||
if (type == TOMOYO_TYPE_READ_WRITE)
|
||||
e.perm |= tomoyo_rw_mask;
|
||||
if (!domain)
|
||||
return -EINVAL;
|
||||
int error;
|
||||
if (e.perm == (1 << TOMOYO_TYPE_READ_WRITE))
|
||||
e.perm |= TOMOYO_RW_MASK;
|
||||
if (!tomoyo_parse_name_union(filename, &e.name))
|
||||
return -EINVAL;
|
||||
if (mutex_lock_interruptible(&tomoyo_policy_lock))
|
||||
goto out;
|
||||
list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
|
||||
struct tomoyo_path_acl *acl =
|
||||
container_of(ptr, struct tomoyo_path_acl, head);
|
||||
if (!tomoyo_is_same_path_acl(acl, &e))
|
||||
continue;
|
||||
if (is_delete) {
|
||||
acl->perm &= ~perm;
|
||||
if ((acl->perm & tomoyo_rw_mask) != tomoyo_rw_mask)
|
||||
acl->perm &= ~(1 << TOMOYO_TYPE_READ_WRITE);
|
||||
else if (!(acl->perm & (1 << TOMOYO_TYPE_READ_WRITE)))
|
||||
acl->perm &= ~tomoyo_rw_mask;
|
||||
} else {
|
||||
acl->perm |= perm;
|
||||
if ((acl->perm & tomoyo_rw_mask) == tomoyo_rw_mask)
|
||||
acl->perm |= 1 << TOMOYO_TYPE_READ_WRITE;
|
||||
else if (acl->perm & (1 << TOMOYO_TYPE_READ_WRITE))
|
||||
acl->perm |= tomoyo_rw_mask;
|
||||
}
|
||||
error = 0;
|
||||
break;
|
||||
}
|
||||
if (!is_delete && error) {
|
||||
struct tomoyo_path_acl *entry =
|
||||
tomoyo_commit_ok(&e, sizeof(e));
|
||||
if (entry) {
|
||||
list_add_tail_rcu(&entry->head.list,
|
||||
&domain->acl_info_list);
|
||||
error = 0;
|
||||
}
|
||||
}
|
||||
mutex_unlock(&tomoyo_policy_lock);
|
||||
out:
|
||||
error = tomoyo_update_domain(&e.head, sizeof(e), is_delete, domain,
|
||||
tomoyo_same_path_acl,
|
||||
tomoyo_merge_path_acl);
|
||||
tomoyo_put_name_union(&e.name);
|
||||
return error;
|
||||
}
|
||||
|
||||
static bool tomoyo_same_path_number3_acl(const struct tomoyo_acl_info *a,
|
||||
const struct tomoyo_acl_info *b)
|
||||
{
|
||||
const struct tomoyo_path_number3_acl *p1 = container_of(a, typeof(*p1),
|
||||
head);
|
||||
const struct tomoyo_path_number3_acl *p2 = container_of(b, typeof(*p2),
|
||||
head);
|
||||
return tomoyo_is_same_acl_head(&p1->head, &p2->head)
|
||||
&& tomoyo_is_same_name_union(&p1->name, &p2->name)
|
||||
&& tomoyo_is_same_number_union(&p1->mode, &p2->mode)
|
||||
&& tomoyo_is_same_number_union(&p1->major, &p2->major)
|
||||
&& tomoyo_is_same_number_union(&p1->minor, &p2->minor);
|
||||
}
|
||||
|
||||
static bool tomoyo_merge_path_number3_acl(struct tomoyo_acl_info *a,
|
||||
struct tomoyo_acl_info *b,
|
||||
const bool is_delete)
|
||||
{
|
||||
u8 *const a_perm = &container_of(a, struct tomoyo_path_number3_acl,
|
||||
head)->perm;
|
||||
u8 perm = *a_perm;
|
||||
const u8 b_perm = container_of(b, struct tomoyo_path_number3_acl, head)
|
||||
->perm;
|
||||
if (is_delete)
|
||||
perm &= ~b_perm;
|
||||
else
|
||||
perm |= b_perm;
|
||||
*a_perm = perm;
|
||||
return !perm;
|
||||
}
|
||||
|
||||
/**
|
||||
* tomoyo_update_path_number3_acl - Update "struct tomoyo_path_number3_acl" list.
|
||||
*
|
||||
@ -879,20 +862,17 @@ static int tomoyo_update_path_acl(const u8 type, const char *filename,
|
||||
* @is_delete: True if it is a delete request.
|
||||
*
|
||||
* Returns 0 on success, negative value otherwise.
|
||||
*
|
||||
* Caller holds tomoyo_read_lock().
|
||||
*/
|
||||
static inline int tomoyo_update_path_number3_acl(const u8 type,
|
||||
const char *filename,
|
||||
char *mode,
|
||||
char *major, char *minor,
|
||||
struct tomoyo_domain_info *
|
||||
const domain,
|
||||
const bool is_delete)
|
||||
static int tomoyo_update_path_number3_acl(const u8 type, const char *filename,
|
||||
char *mode, char *major, char *minor,
|
||||
struct tomoyo_domain_info * const
|
||||
domain, const bool is_delete)
|
||||
{
|
||||
const u8 perm = 1 << type;
|
||||
struct tomoyo_acl_info *ptr;
|
||||
struct tomoyo_path_number3_acl e = {
|
||||
.head.type = TOMOYO_TYPE_PATH_NUMBER3_ACL,
|
||||
.perm = perm
|
||||
.perm = 1 << type
|
||||
};
|
||||
int error = is_delete ? -ENOENT : -ENOMEM;
|
||||
if (!tomoyo_parse_name_union(filename, &e.name) ||
|
||||
@ -900,30 +880,9 @@ static inline int tomoyo_update_path_number3_acl(const u8 type,
|
||||
!tomoyo_parse_number_union(major, &e.major) ||
|
||||
!tomoyo_parse_number_union(minor, &e.minor))
|
||||
goto out;
|
||||
if (mutex_lock_interruptible(&tomoyo_policy_lock))
|
||||
goto out;
|
||||
list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
|
||||
struct tomoyo_path_number3_acl *acl =
|
||||
container_of(ptr, struct tomoyo_path_number3_acl, head);
|
||||
if (!tomoyo_is_same_path_number3_acl(acl, &e))
|
||||
continue;
|
||||
if (is_delete)
|
||||
acl->perm &= ~perm;
|
||||
else
|
||||
acl->perm |= perm;
|
||||
error = 0;
|
||||
break;
|
||||
}
|
||||
if (!is_delete && error) {
|
||||
struct tomoyo_path_number3_acl *entry =
|
||||
tomoyo_commit_ok(&e, sizeof(e));
|
||||
if (entry) {
|
||||
list_add_tail_rcu(&entry->head.list,
|
||||
&domain->acl_info_list);
|
||||
error = 0;
|
||||
}
|
||||
}
|
||||
mutex_unlock(&tomoyo_policy_lock);
|
||||
error = tomoyo_update_domain(&e.head, sizeof(e), is_delete, domain,
|
||||
tomoyo_same_path_number3_acl,
|
||||
tomoyo_merge_path_number3_acl);
|
||||
out:
|
||||
tomoyo_put_name_union(&e.name);
|
||||
tomoyo_put_number_union(&e.mode);
|
||||
@ -932,6 +891,32 @@ static inline int tomoyo_update_path_number3_acl(const u8 type,
|
||||
return error;
|
||||
}
|
||||
|
||||
static bool tomoyo_same_path2_acl(const struct tomoyo_acl_info *a,
|
||||
const struct tomoyo_acl_info *b)
|
||||
{
|
||||
const struct tomoyo_path2_acl *p1 = container_of(a, typeof(*p1), head);
|
||||
const struct tomoyo_path2_acl *p2 = container_of(b, typeof(*p2), head);
|
||||
return tomoyo_is_same_acl_head(&p1->head, &p2->head)
|
||||
&& tomoyo_is_same_name_union(&p1->name1, &p2->name1)
|
||||
&& tomoyo_is_same_name_union(&p1->name2, &p2->name2);
|
||||
}
|
||||
|
||||
static bool tomoyo_merge_path2_acl(struct tomoyo_acl_info *a,
|
||||
struct tomoyo_acl_info *b,
|
||||
const bool is_delete)
|
||||
{
|
||||
u8 * const a_perm = &container_of(a, struct tomoyo_path2_acl, head)
|
||||
->perm;
|
||||
u8 perm = *a_perm;
|
||||
const u8 b_perm = container_of(b, struct tomoyo_path2_acl, head)->perm;
|
||||
if (is_delete)
|
||||
perm &= ~b_perm;
|
||||
else
|
||||
perm |= b_perm;
|
||||
*a_perm = perm;
|
||||
return !perm;
|
||||
}
|
||||
|
||||
/**
|
||||
* tomoyo_update_path2_acl - Update "struct tomoyo_path2_acl" list.
|
||||
*
|
||||
@ -947,46 +932,20 @@ static inline int tomoyo_update_path_number3_acl(const u8 type,
|
||||
*/
|
||||
static int tomoyo_update_path2_acl(const u8 type, const char *filename1,
|
||||
const char *filename2,
|
||||
struct tomoyo_domain_info *const domain,
|
||||
struct tomoyo_domain_info * const domain,
|
||||
const bool is_delete)
|
||||
{
|
||||
const u8 perm = 1 << type;
|
||||
struct tomoyo_path2_acl e = {
|
||||
.head.type = TOMOYO_TYPE_PATH2_ACL,
|
||||
.perm = perm
|
||||
.perm = 1 << type
|
||||
};
|
||||
struct tomoyo_acl_info *ptr;
|
||||
int error = is_delete ? -ENOENT : -ENOMEM;
|
||||
|
||||
if (!domain)
|
||||
return -EINVAL;
|
||||
if (!tomoyo_parse_name_union(filename1, &e.name1) ||
|
||||
!tomoyo_parse_name_union(filename2, &e.name2))
|
||||
goto out;
|
||||
if (mutex_lock_interruptible(&tomoyo_policy_lock))
|
||||
goto out;
|
||||
list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
|
||||
struct tomoyo_path2_acl *acl =
|
||||
container_of(ptr, struct tomoyo_path2_acl, head);
|
||||
if (!tomoyo_is_same_path2_acl(acl, &e))
|
||||
continue;
|
||||
if (is_delete)
|
||||
acl->perm &= ~perm;
|
||||
else
|
||||
acl->perm |= perm;
|
||||
error = 0;
|
||||
break;
|
||||
}
|
||||
if (!is_delete && error) {
|
||||
struct tomoyo_path2_acl *entry =
|
||||
tomoyo_commit_ok(&e, sizeof(e));
|
||||
if (entry) {
|
||||
list_add_tail_rcu(&entry->head.list,
|
||||
&domain->acl_info_list);
|
||||
error = 0;
|
||||
}
|
||||
}
|
||||
mutex_unlock(&tomoyo_policy_lock);
|
||||
error = tomoyo_update_domain(&e.head, sizeof(e), is_delete, domain,
|
||||
tomoyo_same_path2_acl,
|
||||
tomoyo_merge_path2_acl);
|
||||
out:
|
||||
tomoyo_put_name_union(&e.name1);
|
||||
tomoyo_put_name_union(&e.name2);
|
||||
@ -1157,6 +1116,35 @@ static int tomoyo_path_number_acl(struct tomoyo_request_info *r, const u8 type,
|
||||
return error;
|
||||
}
|
||||
|
||||
static bool tomoyo_same_path_number_acl(const struct tomoyo_acl_info *a,
|
||||
const struct tomoyo_acl_info *b)
|
||||
{
|
||||
const struct tomoyo_path_number_acl *p1 = container_of(a, typeof(*p1),
|
||||
head);
|
||||
const struct tomoyo_path_number_acl *p2 = container_of(b, typeof(*p2),
|
||||
head);
|
||||
return tomoyo_is_same_acl_head(&p1->head, &p2->head)
|
||||
&& tomoyo_is_same_name_union(&p1->name, &p2->name)
|
||||
&& tomoyo_is_same_number_union(&p1->number, &p2->number);
|
||||
}
|
||||
|
||||
static bool tomoyo_merge_path_number_acl(struct tomoyo_acl_info *a,
|
||||
struct tomoyo_acl_info *b,
|
||||
const bool is_delete)
|
||||
{
|
||||
u8 * const a_perm = &container_of(a, struct tomoyo_path_number_acl,
|
||||
head)->perm;
|
||||
u8 perm = *a_perm;
|
||||
const u8 b_perm = container_of(b, struct tomoyo_path_number_acl, head)
|
||||
->perm;
|
||||
if (is_delete)
|
||||
perm &= ~b_perm;
|
||||
else
|
||||
perm |= b_perm;
|
||||
*a_perm = perm;
|
||||
return !perm;
|
||||
}
|
||||
|
||||
/**
|
||||
* tomoyo_update_path_number_acl - Update ioctl/chmod/chown/chgrp ACL.
|
||||
*
|
||||
@ -1168,50 +1156,24 @@ static int tomoyo_path_number_acl(struct tomoyo_request_info *r, const u8 type,
|
||||
*
|
||||
* Returns 0 on success, negative value otherwise.
|
||||
*/
|
||||
static inline int tomoyo_update_path_number_acl(const u8 type,
|
||||
const char *filename,
|
||||
char *number,
|
||||
struct tomoyo_domain_info *
|
||||
const domain,
|
||||
const bool is_delete)
|
||||
static int tomoyo_update_path_number_acl(const u8 type, const char *filename,
|
||||
char *number,
|
||||
struct tomoyo_domain_info * const
|
||||
domain,
|
||||
const bool is_delete)
|
||||
{
|
||||
const u8 perm = 1 << type;
|
||||
struct tomoyo_acl_info *ptr;
|
||||
struct tomoyo_path_number_acl e = {
|
||||
.head.type = TOMOYO_TYPE_PATH_NUMBER_ACL,
|
||||
.perm = perm
|
||||
.perm = 1 << type
|
||||
};
|
||||
int error = is_delete ? -ENOENT : -ENOMEM;
|
||||
if (!domain)
|
||||
return -EINVAL;
|
||||
if (!tomoyo_parse_name_union(filename, &e.name))
|
||||
return -EINVAL;
|
||||
if (!tomoyo_parse_number_union(number, &e.number))
|
||||
goto out;
|
||||
if (mutex_lock_interruptible(&tomoyo_policy_lock))
|
||||
goto out;
|
||||
list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
|
||||
struct tomoyo_path_number_acl *acl =
|
||||
container_of(ptr, struct tomoyo_path_number_acl, head);
|
||||
if (!tomoyo_is_same_path_number_acl(acl, &e))
|
||||
continue;
|
||||
if (is_delete)
|
||||
acl->perm &= ~perm;
|
||||
else
|
||||
acl->perm |= perm;
|
||||
error = 0;
|
||||
break;
|
||||
}
|
||||
if (!is_delete && error) {
|
||||
struct tomoyo_path_number_acl *entry =
|
||||
tomoyo_commit_ok(&e, sizeof(e));
|
||||
if (entry) {
|
||||
list_add_tail_rcu(&entry->head.list,
|
||||
&domain->acl_info_list);
|
||||
error = 0;
|
||||
}
|
||||
}
|
||||
mutex_unlock(&tomoyo_policy_lock);
|
||||
error = tomoyo_update_domain(&e.head, sizeof(e), is_delete, domain,
|
||||
tomoyo_same_path_number_acl,
|
||||
tomoyo_merge_path_number_acl);
|
||||
out:
|
||||
tomoyo_put_name_union(&e.name);
|
||||
tomoyo_put_number_union(&e.number);
|
||||
@ -1585,13 +1547,8 @@ int tomoyo_write_file_policy(char *data, struct tomoyo_domain_info *domain,
|
||||
u8 type;
|
||||
if (!tomoyo_tokenize(data, w, sizeof(w)) || !w[1][0])
|
||||
return -EINVAL;
|
||||
if (strncmp(w[0], "allow_", 6)) {
|
||||
unsigned int perm;
|
||||
if (sscanf(w[0], "%u", &perm) == 1)
|
||||
return tomoyo_update_file_acl((u8) perm, w[1], domain,
|
||||
is_delete);
|
||||
if (strncmp(w[0], "allow_", 6))
|
||||
goto out;
|
||||
}
|
||||
w[0] += 6;
|
||||
for (type = 0; type < TOMOYO_MAX_PATH_OPERATION; type++) {
|
||||
if (strcmp(w[0], tomoyo_path_keyword[type]))
|
||||
|
||||
@ -310,34 +310,8 @@ static void tomoyo_collect_entry(void)
|
||||
struct tomoyo_acl_info *acl;
|
||||
list_for_each_entry_rcu(acl, &domain->acl_info_list,
|
||||
list) {
|
||||
switch (acl->type) {
|
||||
case TOMOYO_TYPE_PATH_ACL:
|
||||
if (container_of(acl,
|
||||
struct tomoyo_path_acl,
|
||||
head)->perm)
|
||||
continue;
|
||||
break;
|
||||
case TOMOYO_TYPE_PATH2_ACL:
|
||||
if (container_of(acl,
|
||||
struct tomoyo_path2_acl,
|
||||
head)->perm)
|
||||
continue;
|
||||
break;
|
||||
case TOMOYO_TYPE_PATH_NUMBER_ACL:
|
||||
if (container_of(acl,
|
||||
struct tomoyo_path_number_acl,
|
||||
head)->perm)
|
||||
continue;
|
||||
break;
|
||||
case TOMOYO_TYPE_PATH_NUMBER3_ACL:
|
||||
if (container_of(acl,
|
||||
struct tomoyo_path_number3_acl,
|
||||
head)->perm)
|
||||
continue;
|
||||
break;
|
||||
default:
|
||||
if (!acl->is_deleted)
|
||||
continue;
|
||||
}
|
||||
if (tomoyo_add_to_gc(TOMOYO_ID_ACL, acl))
|
||||
list_del_rcu(&acl->list);
|
||||
else
|
||||
|
||||
@ -114,11 +114,10 @@ static int tomoyo_mount_acl2(struct tomoyo_request_info *r, char *dev_name,
|
||||
tomoyo_fill_path_info(&rdev);
|
||||
list_for_each_entry_rcu(ptr, &r->domain->acl_info_list, list) {
|
||||
struct tomoyo_mount_acl *acl;
|
||||
if (ptr->type != TOMOYO_TYPE_MOUNT_ACL)
|
||||
if (ptr->is_deleted || ptr->type != TOMOYO_TYPE_MOUNT_ACL)
|
||||
continue;
|
||||
acl = container_of(ptr, struct tomoyo_mount_acl, head);
|
||||
if (acl->is_deleted ||
|
||||
!tomoyo_compare_number_union(flags, &acl->flags) ||
|
||||
if (!tomoyo_compare_number_union(flags, &acl->flags) ||
|
||||
!tomoyo_compare_name_union(&rtype, &acl->fs_type) ||
|
||||
!tomoyo_compare_name_union(&rdir, &acl->dir_name) ||
|
||||
(need_dev &&
|
||||
@ -259,6 +258,18 @@ int tomoyo_mount_permission(char *dev_name, struct path *path, char *type,
|
||||
return error;
|
||||
}
|
||||
|
||||
static bool tomoyo_same_mount_acl(const struct tomoyo_acl_info *a,
|
||||
const struct tomoyo_acl_info *b)
|
||||
{
|
||||
const struct tomoyo_mount_acl *p1 = container_of(a, typeof(*p1), head);
|
||||
const struct tomoyo_mount_acl *p2 = container_of(b, typeof(*p2), head);
|
||||
return tomoyo_is_same_acl_head(&p1->head, &p2->head) &&
|
||||
tomoyo_is_same_name_union(&p1->dev_name, &p2->dev_name) &&
|
||||
tomoyo_is_same_name_union(&p1->dir_name, &p2->dir_name) &&
|
||||
tomoyo_is_same_name_union(&p1->fs_type, &p2->fs_type) &&
|
||||
tomoyo_is_same_number_union(&p1->flags, &p2->flags);
|
||||
}
|
||||
|
||||
/**
|
||||
* tomoyo_write_mount_policy - Write "struct tomoyo_mount_acl" list.
|
||||
*
|
||||
@ -267,11 +278,12 @@ int tomoyo_mount_permission(char *dev_name, struct path *path, char *type,
|
||||
* @is_delete: True if it is a delete request.
|
||||
*
|
||||
* Returns 0 on success, negative value otherwise.
|
||||
*
|
||||
* Caller holds tomoyo_read_lock().
|
||||
*/
|
||||
int tomoyo_write_mount_policy(char *data, struct tomoyo_domain_info *domain,
|
||||
const bool is_delete)
|
||||
{
|
||||
struct tomoyo_acl_info *ptr;
|
||||
struct tomoyo_mount_acl e = { .head.type = TOMOYO_TYPE_MOUNT_ACL };
|
||||
int error = is_delete ? -ENOENT : -ENOMEM;
|
||||
char *w[4];
|
||||
@ -282,27 +294,8 @@ int tomoyo_write_mount_policy(char *data, struct tomoyo_domain_info *domain,
|
||||
!tomoyo_parse_name_union(w[2], &e.fs_type) ||
|
||||
!tomoyo_parse_number_union(w[3], &e.flags))
|
||||
goto out;
|
||||
if (mutex_lock_interruptible(&tomoyo_policy_lock))
|
||||
goto out;
|
||||
list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
|
||||
struct tomoyo_mount_acl *acl =
|
||||
container_of(ptr, struct tomoyo_mount_acl, head);
|
||||
if (!tomoyo_is_same_mount_acl(acl, &e))
|
||||
continue;
|
||||
acl->is_deleted = is_delete;
|
||||
error = 0;
|
||||
break;
|
||||
}
|
||||
if (!is_delete && error) {
|
||||
struct tomoyo_mount_acl *entry =
|
||||
tomoyo_commit_ok(&e, sizeof(e));
|
||||
if (entry) {
|
||||
list_add_tail_rcu(&entry->head.list,
|
||||
&domain->acl_info_list);
|
||||
error = 0;
|
||||
}
|
||||
}
|
||||
mutex_unlock(&tomoyo_policy_lock);
|
||||
error = tomoyo_update_domain(&e.head, sizeof(e), is_delete, domain,
|
||||
tomoyo_same_mount_acl, NULL);
|
||||
out:
|
||||
tomoyo_put_name_union(&e.dev_name);
|
||||
tomoyo_put_name_union(&e.dir_name);
|
||||
|
||||
@ -911,6 +911,8 @@ bool tomoyo_domain_quota_is_ok(struct tomoyo_request_info *r)
|
||||
if (!domain)
|
||||
return true;
|
||||
list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
|
||||
if (!ptr->is_deleted)
|
||||
continue;
|
||||
switch (ptr->type) {
|
||||
u16 perm;
|
||||
u8 i;
|
||||
@ -944,10 +946,8 @@ bool tomoyo_domain_quota_is_ok(struct tomoyo_request_info *r)
|
||||
if (perm & (1 << i))
|
||||
count++;
|
||||
break;
|
||||
case TOMOYO_TYPE_MOUNT_ACL:
|
||||
if (!container_of(ptr, struct tomoyo_mount_acl, head)->
|
||||
is_deleted)
|
||||
count++;
|
||||
default:
|
||||
count++;
|
||||
}
|
||||
}
|
||||
if (count < tomoyo_profile(domain->profile)->learning->
|
||||
|
||||
Loading…
Reference in New Issue
Block a user