Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a1f9bb6a authored by Tetsuo Handa's avatar Tetsuo Handa Committed by James Morris
Browse files

TOMOYO: Split file access control functions by type of parameters.



Check numeric parameters for operations that deal them
(e.g. chmod/chown/ioctl).

Signed-off-by: default avatarTetsuo Handa <penguin-kernel@I-love.SAKURA.ne.jp>
Signed-off-by: default avatarJames Morris <jmorris@namei.org>
parent cb0abe6a
Loading
Loading
Loading
Loading
+100 −5
Original line number Original line Diff line number Diff line
@@ -1043,12 +1043,11 @@ bool tomoyo_domain_quota_is_ok(struct tomoyo_request_info *r)
		return true;
		return true;
	list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
	list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
		switch (ptr->type) {
		switch (ptr->type) {
			struct tomoyo_path_acl *acl;
			u16 perm;
			u32 perm;
			u8 i;
			u8 i;
		case TOMOYO_TYPE_PATH_ACL:
		case TOMOYO_TYPE_PATH_ACL:
			acl = container_of(ptr, struct tomoyo_path_acl, head);
			perm = container_of(ptr, struct tomoyo_path_acl, head)
			perm = acl->perm | (((u32) acl->perm_high) << 16);
				->perm;
			for (i = 0; i < TOMOYO_MAX_PATH_OPERATION; i++)
			for (i = 0; i < TOMOYO_MAX_PATH_OPERATION; i++)
				if (perm & (1 << i))
				if (perm & (1 << i))
					count++;
					count++;
@@ -1062,6 +1061,20 @@ bool tomoyo_domain_quota_is_ok(struct tomoyo_request_info *r)
				if (perm & (1 << i))
				if (perm & (1 << i))
					count++;
					count++;
			break;
			break;
		case TOMOYO_TYPE_PATH_NUMBER_ACL:
			perm = container_of(ptr, struct tomoyo_path_number_acl,
					    head)->perm;
			for (i = 0; i < TOMOYO_MAX_PATH_NUMBER_OPERATION; i++)
				if (perm & (1 << i))
					count++;
			break;
		case TOMOYO_TYPE_PATH_NUMBER3_ACL:
			perm = container_of(ptr, struct tomoyo_path_number3_acl,
					    head)->perm;
			for (i = 0; i < TOMOYO_MAX_PATH_NUMBER3_OPERATION; i++)
				if (perm & (1 << i))
					count++;
			break;
		}
		}
	}
	}
	if (count < tomoyo_check_flags(domain, TOMOYO_MAX_ACCEPT_ENTRY))
	if (count < tomoyo_check_flags(domain, TOMOYO_MAX_ACCEPT_ENTRY))
@@ -1579,7 +1592,7 @@ static bool tomoyo_print_path_acl(struct tomoyo_io_buffer *head,
{
{
	int pos;
	int pos;
	u8 bit;
	u8 bit;
	const u32 perm = ptr->perm | (((u32) ptr->perm_high) << 16);
	const u16 perm = ptr->perm;


	for (bit = head->read_bit; bit < TOMOYO_MAX_PATH_OPERATION; bit++) {
	for (bit = head->read_bit; bit < TOMOYO_MAX_PATH_OPERATION; bit++) {
		if (!(perm & (1 << bit)))
		if (!(perm & (1 << bit)))
@@ -1637,6 +1650,76 @@ static bool tomoyo_print_path2_acl(struct tomoyo_io_buffer *head,
	return false;
	return false;
}
}


/**
 * tomoyo_print_path_number_acl - Print a path_number ACL entry.
 *
 * @head: Pointer to "struct tomoyo_io_buffer".
 * @ptr:  Pointer to "struct tomoyo_path_number_acl".
 *
 * Returns true on success, false otherwise.
 */
static bool tomoyo_print_path_number_acl(struct tomoyo_io_buffer *head,
					 struct tomoyo_path_number_acl *ptr)
{
	int pos;
	u8 bit;
	const u8 perm = ptr->perm;
	for (bit = head->read_bit; bit < TOMOYO_MAX_PATH_NUMBER_OPERATION;
	     bit++) {
		if (!(perm & (1 << bit)))
			continue;
		pos = head->read_avail;
		if (!tomoyo_io_printf(head, "allow_%s",
				      tomoyo_path_number2keyword(bit)) ||
		    !tomoyo_print_name_union(head, &ptr->name) ||
		    !tomoyo_print_number_union(head, &ptr->number) ||
		    !tomoyo_io_printf(head, "\n"))
			goto out;
	}
	head->read_bit = 0;
	return true;
 out:
	head->read_bit = bit;
	head->read_avail = pos;
	return false;
}

/**
 * tomoyo_print_path_number3_acl - Print a path_number3 ACL entry.
 *
 * @head: Pointer to "struct tomoyo_io_buffer".
 * @ptr:  Pointer to "struct tomoyo_path_number3_acl".
 *
 * Returns true on success, false otherwise.
 */
static bool tomoyo_print_path_number3_acl(struct tomoyo_io_buffer *head,
					  struct tomoyo_path_number3_acl *ptr)
{
	int pos;
	u8 bit;
	const u16 perm = ptr->perm;
	for (bit = head->read_bit; bit < TOMOYO_MAX_PATH_NUMBER3_OPERATION;
	     bit++) {
		if (!(perm & (1 << bit)))
			continue;
		pos = head->read_avail;
		if (!tomoyo_io_printf(head, "allow_%s",
				      tomoyo_path_number32keyword(bit)) ||
		    !tomoyo_print_name_union(head, &ptr->name) ||
		    !tomoyo_print_number_union(head, &ptr->mode) ||
		    !tomoyo_print_number_union(head, &ptr->major) ||
		    !tomoyo_print_number_union(head, &ptr->minor) ||
		    !tomoyo_io_printf(head, "\n"))
			goto out;
	}
	head->read_bit = 0;
	return true;
 out:
	head->read_bit = bit;
	head->read_avail = pos;
	return false;
}

/**
/**
 * tomoyo_print_entry - Print an ACL entry.
 * tomoyo_print_entry - Print an ACL entry.
 *
 *
@@ -1660,6 +1743,18 @@ static bool tomoyo_print_entry(struct tomoyo_io_buffer *head,
			= container_of(ptr, struct tomoyo_path2_acl, head);
			= container_of(ptr, struct tomoyo_path2_acl, head);
		return tomoyo_print_path2_acl(head, acl);
		return tomoyo_print_path2_acl(head, acl);
	}
	}
	if (acl_type == TOMOYO_TYPE_PATH_NUMBER_ACL) {
		struct tomoyo_path_number_acl *acl
			= container_of(ptr, struct tomoyo_path_number_acl,
				       head);
		return tomoyo_print_path_number_acl(head, acl);
	}
	if (acl_type == TOMOYO_TYPE_PATH_NUMBER3_ACL) {
		struct tomoyo_path_number3_acl *acl
			= container_of(ptr, struct tomoyo_path_number3_acl,
				       head);
		return tomoyo_print_path_number3_acl(head, acl);
	}
	BUG(); /* This must not happen. */
	BUG(); /* This must not happen. */
	return false;
	return false;
}
}
+105 −21
Original line number Original line Diff line number Diff line
@@ -88,17 +88,21 @@ enum tomoyo_mac_index {
enum tomoyo_acl_entry_type_index {
enum tomoyo_acl_entry_type_index {
	TOMOYO_TYPE_PATH_ACL,
	TOMOYO_TYPE_PATH_ACL,
	TOMOYO_TYPE_PATH2_ACL,
	TOMOYO_TYPE_PATH2_ACL,
	TOMOYO_TYPE_PATH_NUMBER_ACL,
	TOMOYO_TYPE_PATH_NUMBER3_ACL,
};
};


/* Index numbers for File Controls. */
/* Index numbers for File Controls. */


/*
/*
 * TYPE_READ_WRITE_ACL is special. TYPE_READ_WRITE_ACL is automatically set
 * TOMOYO_TYPE_READ_WRITE is special. TOMOYO_TYPE_READ_WRITE is automatically
 * if both TYPE_READ_ACL and TYPE_WRITE_ACL are set. Both TYPE_READ_ACL and
 * set if both TOMOYO_TYPE_READ and TOMOYO_TYPE_WRITE are set.
 * TYPE_WRITE_ACL are automatically set if TYPE_READ_WRITE_ACL is set.
 * Both TOMOYO_TYPE_READ and TOMOYO_TYPE_WRITE are automatically set if
 * TYPE_READ_WRITE_ACL is automatically cleared if either TYPE_READ_ACL or
 * TOMOYO_TYPE_READ_WRITE is set.
 * TYPE_WRITE_ACL is cleared. Both TYPE_READ_ACL and TYPE_WRITE_ACL are
 * TOMOYO_TYPE_READ_WRITE is automatically cleared if either TOMOYO_TYPE_READ
 * automatically cleared if TYPE_READ_WRITE_ACL is cleared.
 * or TOMOYO_TYPE_WRITE is cleared.
 * Both TOMOYO_TYPE_READ and TOMOYO_TYPE_WRITE are automatically cleared if
 * TOMOYO_TYPE_READ_WRITE is cleared.
 */
 */


enum tomoyo_path_acl_index {
enum tomoyo_path_acl_index {
@@ -106,27 +110,23 @@ enum tomoyo_path_acl_index {
	TOMOYO_TYPE_EXECUTE,
	TOMOYO_TYPE_EXECUTE,
	TOMOYO_TYPE_READ,
	TOMOYO_TYPE_READ,
	TOMOYO_TYPE_WRITE,
	TOMOYO_TYPE_WRITE,
	TOMOYO_TYPE_CREATE,
	TOMOYO_TYPE_UNLINK,
	TOMOYO_TYPE_UNLINK,
	TOMOYO_TYPE_MKDIR,
	TOMOYO_TYPE_RMDIR,
	TOMOYO_TYPE_RMDIR,
	TOMOYO_TYPE_MKFIFO,
	TOMOYO_TYPE_MKSOCK,
	TOMOYO_TYPE_MKBLOCK,
	TOMOYO_TYPE_MKCHAR,
	TOMOYO_TYPE_TRUNCATE,
	TOMOYO_TYPE_TRUNCATE,
	TOMOYO_TYPE_SYMLINK,
	TOMOYO_TYPE_SYMLINK,
	TOMOYO_TYPE_REWRITE,
	TOMOYO_TYPE_REWRITE,
	TOMOYO_TYPE_IOCTL,
	TOMOYO_TYPE_CHMOD,
	TOMOYO_TYPE_CHOWN,
	TOMOYO_TYPE_CHGRP,
	TOMOYO_TYPE_CHROOT,
	TOMOYO_TYPE_CHROOT,
	TOMOYO_TYPE_MOUNT,
	TOMOYO_TYPE_MOUNT,
	TOMOYO_TYPE_UMOUNT,
	TOMOYO_TYPE_UMOUNT,
	TOMOYO_MAX_PATH_OPERATION
	TOMOYO_MAX_PATH_OPERATION
};
};


enum tomoyo_path_number3_acl_index {
	TOMOYO_TYPE_MKBLOCK,
	TOMOYO_TYPE_MKCHAR,
	TOMOYO_MAX_PATH_NUMBER3_OPERATION
};

enum tomoyo_path2_acl_index {
enum tomoyo_path2_acl_index {
	TOMOYO_TYPE_LINK,
	TOMOYO_TYPE_LINK,
	TOMOYO_TYPE_RENAME,
	TOMOYO_TYPE_RENAME,
@@ -134,6 +134,18 @@ enum tomoyo_path2_acl_index {
	TOMOYO_MAX_PATH2_OPERATION
	TOMOYO_MAX_PATH2_OPERATION
};
};


enum tomoyo_path_number_acl_index {
	TOMOYO_TYPE_CREATE,
	TOMOYO_TYPE_MKDIR,
	TOMOYO_TYPE_MKFIFO,
	TOMOYO_TYPE_MKSOCK,
	TOMOYO_TYPE_IOCTL,
	TOMOYO_TYPE_CHMOD,
	TOMOYO_TYPE_CHOWN,
	TOMOYO_TYPE_CHGRP,
	TOMOYO_MAX_PATH_NUMBER_OPERATION
};

enum tomoyo_securityfs_interface_index {
enum tomoyo_securityfs_interface_index {
	TOMOYO_DOMAINPOLICY,
	TOMOYO_DOMAINPOLICY,
	TOMOYO_EXCEPTIONPOLICY,
	TOMOYO_EXCEPTIONPOLICY,
@@ -347,19 +359,61 @@ struct tomoyo_domain_info {
 *  (3) "name" is the pathname.
 *  (3) "name" is the pathname.
 *
 *
 * Directives held by this structure are "allow_read/write", "allow_execute",
 * Directives held by this structure are "allow_read/write", "allow_execute",
 * "allow_read", "allow_write", "allow_create", "allow_unlink", "allow_mkdir",
 * "allow_read", "allow_write", "allow_unlink", "allow_rmdir",
 * "allow_rmdir", "allow_mkfifo", "allow_mksock", "allow_mkblock",
 * "allow_truncate", "allow_symlink", "allow_rewrite", "allow_chroot",
 * "allow_mkchar", "allow_truncate", "allow_symlink", "allow_rewrite",
 * "allow_ioctl", "allow_chmod", "allow_chown", "allow_chgrp", "allow_chroot",
 * "allow_mount" and "allow_unmount".
 * "allow_mount" and "allow_unmount".
 */
 */
struct tomoyo_path_acl {
struct tomoyo_path_acl {
	struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH_ACL */
	struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH_ACL */
	u8 perm_high;
	u16 perm;
	u16 perm;
	struct tomoyo_name_union name;
	struct tomoyo_name_union name;
};
};


/*
 * tomoyo_path_number_acl is a structure which is used for holding an
 * entry with one pathname and one number operation.
 * It has following fields.
 *
 *  (1) "head" which is a "struct tomoyo_acl_info".
 *  (2) "perm" which is a bitmask of permitted operations.
 *  (3) "name" is the pathname.
 *  (4) "number" is the numeric value.
 *
 * Directives held by this structure are "allow_create", "allow_mkdir",
 * "allow_ioctl", "allow_mkfifo", "allow_mksock", "allow_chmod", "allow_chown"
 * and "allow_chgrp".
 *
 */
struct tomoyo_path_number_acl {
	struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH_NUMBER_ACL */
	u8 perm;
	struct tomoyo_name_union name;
	struct tomoyo_number_union number;
};

/*
 * tomoyo_path_number3_acl is a structure which is used for holding an
 * entry with one pathname and three numbers operation.
 * It has following fields.
 *
 *  (1) "head" which is a "struct tomoyo_acl_info".
 *  (2) "perm" which is a bitmask of permitted operations.
 *  (3) "mode" is the create mode.
 *  (4) "major" is the major number of device node.
 *  (5) "minor" is the minor number of device node.
 *
 * Directives held by this structure are "allow_mkchar", "allow_mkblock".
 *
 */
struct tomoyo_path_number3_acl {
	struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH_NUMBER3_ACL */
	u8 perm;
	struct tomoyo_name_union name;
	struct tomoyo_number_union mode;
	struct tomoyo_number_union major;
	struct tomoyo_number_union minor;
};

/*
/*
 * tomoyo_path2_acl 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()).
 * entry with two pathnames operation (i.e. link(), rename() and pivot_root()).
@@ -639,6 +693,8 @@ bool tomoyo_tokenize(char *buffer, char *w[], size_t size);
bool tomoyo_verbose_mode(const struct tomoyo_domain_info *domain);
bool tomoyo_verbose_mode(const struct tomoyo_domain_info *domain);
/* Convert double path operation to operation name. */
/* Convert double path operation to operation name. */
const char *tomoyo_path22keyword(const u8 operation);
const char *tomoyo_path22keyword(const u8 operation);
const char *tomoyo_path_number2keyword(const u8 operation);
const char *tomoyo_path_number32keyword(const u8 operation);
/* Get the last component of the given domainname. */
/* Get the last component of the given domainname. */
const char *tomoyo_get_last_name(const struct tomoyo_domain_info *domain);
const char *tomoyo_get_last_name(const struct tomoyo_domain_info *domain);
/* Convert single path operation to operation name. */
/* Convert single path operation to operation name. */
@@ -736,11 +792,18 @@ int tomoyo_check_exec_perm(struct tomoyo_domain_info *domain,
			   const struct tomoyo_path_info *filename);
			   const struct tomoyo_path_info *filename);
int tomoyo_check_open_permission(struct tomoyo_domain_info *domain,
int tomoyo_check_open_permission(struct tomoyo_domain_info *domain,
				 struct path *path, const int flag);
				 struct path *path, const int flag);
int tomoyo_path_number_perm(const u8 operation, struct path *path,
			    unsigned long number);
int tomoyo_path_number3_perm(const u8 operation, struct path *path,
			     const unsigned int mode, unsigned int dev);
int tomoyo_path_perm(const u8 operation, struct path *path);
int tomoyo_path_perm(const u8 operation, struct path *path);
int tomoyo_path2_perm(const u8 operation, struct path *path1,
int tomoyo_path2_perm(const u8 operation, struct path *path1,
		      struct path *path2);
		      struct path *path2);
int tomoyo_find_next_domain(struct linux_binprm *bprm);
int tomoyo_find_next_domain(struct linux_binprm *bprm);


void tomoyo_print_ulong(char *buffer, const int buffer_len,
			const unsigned long value, const u8 type);

/* Drop refcount on tomoyo_name_union. */
/* Drop refcount on tomoyo_name_union. */
void tomoyo_put_name_union(struct tomoyo_name_union *ptr);
void tomoyo_put_name_union(struct tomoyo_name_union *ptr);


@@ -880,6 +943,18 @@ static inline bool tomoyo_is_same_path_acl(const struct tomoyo_path_acl *p1,
		tomoyo_is_same_name_union(&p1->name, &p2->name);
		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,
static inline bool tomoyo_is_same_path2_acl(const struct tomoyo_path2_acl *p1,
					    const struct tomoyo_path2_acl *p2)
					    const struct tomoyo_path2_acl *p2)
{
{
@@ -888,6 +963,15 @@ static inline bool tomoyo_is_same_path2_acl(const struct tomoyo_path2_acl *p1,
		tomoyo_is_same_name_union(&p1->name2, &p2->name2);
		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_domain_initializer_entry
static inline bool tomoyo_is_same_domain_initializer_entry
(const struct tomoyo_domain_initializer_entry *p1,
(const struct tomoyo_domain_initializer_entry *p1,
 const struct tomoyo_domain_initializer_entry *p2)
 const struct tomoyo_domain_initializer_entry *p2)
+501 −87

File changed.

Preview size limit exceeded, changes collapsed.

+31 −4
Original line number Original line Diff line number Diff line
@@ -106,6 +106,24 @@ static void tomoyo_del_acl(struct tomoyo_acl_info *acl)
			tomoyo_put_name_union(&entry->name2);
			tomoyo_put_name_union(&entry->name2);
		}
		}
		break;
		break;
	case TOMOYO_TYPE_PATH_NUMBER_ACL:
		{
			struct tomoyo_path_number_acl *entry
				= container_of(acl, typeof(*entry), head);
			tomoyo_put_name_union(&entry->name);
			tomoyo_put_number_union(&entry->number);
		}
		break;
	case TOMOYO_TYPE_PATH_NUMBER3_ACL:
		{
			struct tomoyo_path_number3_acl *entry
				= container_of(acl, typeof(*entry), head);
			tomoyo_put_name_union(&entry->name);
			tomoyo_put_number_union(&entry->mode);
			tomoyo_put_number_union(&entry->major);
			tomoyo_put_number_union(&entry->minor);
		}
		break;
	default:
	default:
		printk(KERN_WARNING "Unknown type\n");
		printk(KERN_WARNING "Unknown type\n");
		break;
		break;
@@ -268,10 +286,7 @@ static void tomoyo_collect_entry(void)
				case TOMOYO_TYPE_PATH_ACL:
				case TOMOYO_TYPE_PATH_ACL:
					if (container_of(acl,
					if (container_of(acl,
					 struct tomoyo_path_acl,
					 struct tomoyo_path_acl,
							 head)->perm ||
							 head)->perm)
					    container_of(acl,
					 struct tomoyo_path_acl,
							 head)->perm_high)
						continue;
						continue;
					break;
					break;
				case TOMOYO_TYPE_PATH2_ACL:
				case TOMOYO_TYPE_PATH2_ACL:
@@ -280,6 +295,18 @@ static void tomoyo_collect_entry(void)
							 head)->perm)
							 head)->perm)
						continue;
						continue;
					break;
					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:
				default:
					continue;
					continue;
				}
				}
+15 −6
Original line number Original line Diff line number Diff line
@@ -112,7 +112,8 @@ static int tomoyo_path_mkdir(struct path *parent, struct dentry *dentry,
			     int mode)
			     int mode)
{
{
	struct path path = { parent->mnt, dentry };
	struct path path = { parent->mnt, dentry };
	return tomoyo_path_perm(TOMOYO_TYPE_MKDIR, &path);
	return tomoyo_path_number_perm(TOMOYO_TYPE_MKDIR, &path,
				       mode & S_IALLUGO);
}
}


static int tomoyo_path_rmdir(struct path *parent, struct dentry *dentry)
static int tomoyo_path_rmdir(struct path *parent, struct dentry *dentry)
@@ -133,6 +134,7 @@ static int tomoyo_path_mknod(struct path *parent, struct dentry *dentry,
{
{
	struct path path = { parent->mnt, dentry };
	struct path path = { parent->mnt, dentry };
	int type = TOMOYO_TYPE_CREATE;
	int type = TOMOYO_TYPE_CREATE;
	const unsigned int perm = mode & S_IALLUGO;


	switch (mode & S_IFMT) {
	switch (mode & S_IFMT) {
	case S_IFCHR:
	case S_IFCHR:
@@ -141,6 +143,12 @@ static int tomoyo_path_mknod(struct path *parent, struct dentry *dentry,
	case S_IFBLK:
	case S_IFBLK:
		type = TOMOYO_TYPE_MKBLOCK;
		type = TOMOYO_TYPE_MKBLOCK;
		break;
		break;
	default:
		goto no_dev;
	}
	return tomoyo_path_number3_perm(type, &path, perm, dev);
 no_dev:
	switch (mode & S_IFMT) {
	case S_IFIFO:
	case S_IFIFO:
		type = TOMOYO_TYPE_MKFIFO;
		type = TOMOYO_TYPE_MKFIFO;
		break;
		break;
@@ -148,7 +156,7 @@ static int tomoyo_path_mknod(struct path *parent, struct dentry *dentry,
		type = TOMOYO_TYPE_MKSOCK;
		type = TOMOYO_TYPE_MKSOCK;
		break;
		break;
	}
	}
	return tomoyo_path_perm(type, &path);
	return tomoyo_path_number_perm(type, &path, perm);
}
}


static int tomoyo_path_link(struct dentry *old_dentry, struct path *new_dir,
static int tomoyo_path_link(struct dentry *old_dentry, struct path *new_dir,
@@ -189,23 +197,24 @@ static int tomoyo_dentry_open(struct file *f, const struct cred *cred)
static int tomoyo_file_ioctl(struct file *file, unsigned int cmd,
static int tomoyo_file_ioctl(struct file *file, unsigned int cmd,
			     unsigned long arg)
			     unsigned long arg)
{
{
	return tomoyo_path_perm(TOMOYO_TYPE_IOCTL, &file->f_path);
	return tomoyo_path_number_perm(TOMOYO_TYPE_IOCTL, &file->f_path, cmd);
}
}


static int tomoyo_path_chmod(struct dentry *dentry, struct vfsmount *mnt,
static int tomoyo_path_chmod(struct dentry *dentry, struct vfsmount *mnt,
			     mode_t mode)
			     mode_t mode)
{
{
	struct path path = { mnt, dentry };
	struct path path = { mnt, dentry };
	return tomoyo_path_perm(TOMOYO_TYPE_CHMOD, &path);
	return tomoyo_path_number_perm(TOMOYO_TYPE_CHMOD, &path,
				       mode & S_IALLUGO);
}
}


static int tomoyo_path_chown(struct path *path, uid_t uid, gid_t gid)
static int tomoyo_path_chown(struct path *path, uid_t uid, gid_t gid)
{
{
	int error = 0;
	int error = 0;
	if (uid != (uid_t) -1)
	if (uid != (uid_t) -1)
		error = tomoyo_path_perm(TOMOYO_TYPE_CHOWN, path);
		error = tomoyo_path_number_perm(TOMOYO_TYPE_CHOWN, path, uid);
	if (!error && gid != (gid_t) -1)
	if (!error && gid != (gid_t) -1)
		error = tomoyo_path_perm(TOMOYO_TYPE_CHGRP, path);
		error = tomoyo_path_number_perm(TOMOYO_TYPE_CHGRP, path, gid);
	return error;
	return error;
}
}