[linux-block.git] / fs / fuse / xattr.c

/*
 * FUSE: Filesystem in Userspace
 * Copyright (C) 2001-2016  Miklos Szeredi <miklos@szeredi.hu>
 *
 * This program can be distributed under the terms of the GNU GPL.
 * See the file COPYING.
 */

#include "fuse_i.h"

#include <linux/xattr.h>
#include <linux/posix_acl_xattr.h>

int fuse_setxattr(struct inode *inode, const char *name, const void *value,
		  size_t size, int flags, unsigned int extra_flags)
{
	struct fuse_mount *fm = get_fuse_mount(inode);
	FUSE_ARGS(args);
	struct fuse_setxattr_in inarg;
	int err;

	if (fm->fc->no_setxattr)
		return -EOPNOTSUPP;

	memset(&inarg, 0, sizeof(inarg));
	inarg.size = size;
	inarg.flags = flags;
	inarg.setxattr_flags = extra_flags;

	args.opcode = FUSE_SETXATTR;
	args.nodeid = get_node_id(inode);
	args.in_numargs = 3;
	args.in_args[0].size = fm->fc->setxattr_ext ?
		sizeof(inarg) : FUSE_COMPAT_SETXATTR_IN_SIZE;
	args.in_args[0].value = &inarg;
	args.in_args[1].size = strlen(name) + 1;
	args.in_args[1].value = name;
	args.in_args[2].size = size;
	args.in_args[2].value = value;
	err = fuse_simple_request(fm, &args);
	if (err == -ENOSYS) {
		fm->fc->no_setxattr = 1;
		err = -EOPNOTSUPP;
	}
	if (!err) {
		fuse_invalidate_attr(inode);
		fuse_update_ctime(inode);
	}
	return err;
}

ssize_t fuse_getxattr(struct inode *inode, const char *name, void *value,
		      size_t size)
{
	struct fuse_mount *fm = get_fuse_mount(inode);
	FUSE_ARGS(args);
	struct fuse_getxattr_in inarg;
	struct fuse_getxattr_out outarg;
	ssize_t ret;

	if (fm->fc->no_getxattr)
		return -EOPNOTSUPP;

	memset(&inarg, 0, sizeof(inarg));
	inarg.size = size;
	args.opcode = FUSE_GETXATTR;
	args.nodeid = get_node_id(inode);
	args.in_numargs = 2;
	args.in_args[0].size = sizeof(inarg);
	args.in_args[0].value = &inarg;
	args.in_args[1].size = strlen(name) + 1;
	args.in_args[1].value = name;
	/* This is really two different operations rolled into one */
	args.out_numargs = 1;
	if (size) {
		args.out_argvar = true;
		args.out_args[0].size = size;
		args.out_args[0].value = value;
	} else {
		args.out_args[0].size = sizeof(outarg);
		args.out_args[0].value = &outarg;
	}
	ret = fuse_simple_request(fm, &args);
	if (!ret && !size)
		ret = min_t(ssize_t, outarg.size, XATTR_SIZE_MAX);
	if (ret == -ENOSYS) {
		fm->fc->no_getxattr = 1;
		ret = -EOPNOTSUPP;
	}
	return ret;
}

static int fuse_verify_xattr_list(char *list, size_t size)
{
	size_t origsize = size;

	while (size) {
		size_t thislen = strnlen(list, size);

		if (!thislen || thislen == size)
			return -EIO;

		size -= thislen + 1;
		list += thislen + 1;
	}

	return origsize;
}

ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
{
	struct inode *inode = d_inode(entry);
	struct fuse_mount *fm = get_fuse_mount(inode);
	FUSE_ARGS(args);
	struct fuse_getxattr_in inarg;
	struct fuse_getxattr_out outarg;
	ssize_t ret;

	if (fuse_is_bad(inode))
		return -EIO;

	if (!fuse_allow_current_process(fm->fc))
		return -EACCES;

	if (fm->fc->no_listxattr)
		return -EOPNOTSUPP;

	memset(&inarg, 0, sizeof(inarg));
	inarg.size = size;
	args.opcode = FUSE_LISTXATTR;
	args.nodeid = get_node_id(inode);
	args.in_numargs = 1;
	args.in_args[0].size = sizeof(inarg);
	args.in_args[0].value = &inarg;
	/* This is really two different operations rolled into one */
	args.out_numargs = 1;
	if (size) {
		args.out_argvar = true;
		args.out_args[0].size = size;
		args.out_args[0].value = list;
	} else {
		args.out_args[0].size = sizeof(outarg);
		args.out_args[0].value = &outarg;
	}
	ret = fuse_simple_request(fm, &args);
	if (!ret && !size)
		ret = min_t(ssize_t, outarg.size, XATTR_LIST_MAX);
	if (ret > 0 && size)
		ret = fuse_verify_xattr_list(list, ret);
	if (ret == -ENOSYS) {
		fm->fc->no_listxattr = 1;
		ret = -EOPNOTSUPP;
	}
	return ret;
}

int fuse_removexattr(struct inode *inode, const char *name)
{
	struct fuse_mount *fm = get_fuse_mount(inode);
	FUSE_ARGS(args);
	int err;

	if (fm->fc->no_removexattr)
		return -EOPNOTSUPP;

	args.opcode = FUSE_REMOVEXATTR;
	args.nodeid = get_node_id(inode);
	args.in_numargs = 1;
	args.in_args[0].size = strlen(name) + 1;
	args.in_args[0].value = name;
	err = fuse_simple_request(fm, &args);
	if (err == -ENOSYS) {
		fm->fc->no_removexattr = 1;
		err = -EOPNOTSUPP;
	}
	if (!err) {
		fuse_invalidate_attr(inode);
		fuse_update_ctime(inode);
	}
	return err;
}

static int fuse_xattr_get(const struct xattr_handler *handler,
			 struct dentry *dentry, struct inode *inode,
			 const char *name, void *value, size_t size)
{
	if (fuse_is_bad(inode))
		return -EIO;

	return fuse_getxattr(inode, name, value, size);
}

static int fuse_xattr_set(const struct xattr_handler *handler,
			  struct user_namespace *mnt_userns,
			  struct dentry *dentry, struct inode *inode,
			  const char *name, const void *value, size_t size,
			  int flags)
{
	if (fuse_is_bad(inode))
		return -EIO;

	if (!value)
		return fuse_removexattr(inode, name);

	return fuse_setxattr(inode, name, value, size, flags, 0);
}

static bool no_xattr_list(struct dentry *dentry)
{
	return false;
}

static int no_xattr_get(const struct xattr_handler *handler,
			struct dentry *dentry, struct inode *inode,
			const char *name, void *value, size_t size)
{
	return -EOPNOTSUPP;
}

static int no_xattr_set(const struct xattr_handler *handler,
			struct user_namespace *mnt_userns,
			struct dentry *dentry, struct inode *nodee,
			const char *name, const void *value,
			size_t size, int flags)
{
	return -EOPNOTSUPP;
}

static const struct xattr_handler fuse_xattr_handler = {
	.prefix = "",
	.get    = fuse_xattr_get,
	.set    = fuse_xattr_set,
};

const struct xattr_handler *fuse_xattr_handlers[] = {
	&fuse_xattr_handler,
	NULL
};

const struct xattr_handler *fuse_acl_xattr_handlers[] = {
	&posix_acl_access_xattr_handler,
	&posix_acl_default_xattr_handler,
	&fuse_xattr_handler,
	NULL
};

static const struct xattr_handler fuse_no_acl_access_xattr_handler = {
	.name  = XATTR_NAME_POSIX_ACL_ACCESS,
	.flags = ACL_TYPE_ACCESS,
	.list  = no_xattr_list,
	.get   = no_xattr_get,
	.set   = no_xattr_set,
};

static const struct xattr_handler fuse_no_acl_default_xattr_handler = {
	.name  = XATTR_NAME_POSIX_ACL_DEFAULT,
	.flags = ACL_TYPE_ACCESS,
	.list  = no_xattr_list,
	.get   = no_xattr_get,
	.set   = no_xattr_set,
};

const struct xattr_handler *fuse_no_acl_xattr_handlers[] = {
	&fuse_no_acl_access_xattr_handler,
	&fuse_no_acl_default_xattr_handler,
	&fuse_xattr_handler,
	NULL
};
Commit	Line	Data
703c7362 SF	1	/*
	2	* FUSE: Filesystem in Userspace
	3	* Copyright (C) 2001-2016 Miklos Szeredi <miklos@szeredi.hu>
	4	*
	5	* This program can be distributed under the terms of the GNU GPL.
	6	* See the file COPYING.
	7	*/
	8
	9	#include "fuse_i.h"
	10
	11	#include <linux/xattr.h>
60bcc88a	12	#include <linux/posix_acl_xattr.h>
703c7362	13
60bcc88a	14	int fuse_setxattr(struct inode inode, const char name, const void *value,
52a4c95f	15	size_t size, int flags, unsigned int extra_flags)
703c7362	16	{
fcee216b	17	struct fuse_mount *fm = get_fuse_mount(inode);
703c7362 SF	18	FUSE_ARGS(args);
	19	struct fuse_setxattr_in inarg;
	20	int err;
	21
fcee216b	22	if (fm->fc->no_setxattr)
703c7362 SF	23	return -EOPNOTSUPP;
	24
	25	memset(&inarg, 0, sizeof(inarg));
	26	inarg.size = size;
	27	inarg.flags = flags;
52a4c95f VG	28	inarg.setxattr_flags = extra_flags;
52a4c95f VG	29
d5b48543 MS	30	args.opcode = FUSE_SETXATTR;
	31	args.nodeid = get_node_id(inode);
	32	args.in_numargs = 3;
52a4c95f VG	33	args.in_args[0].size = fm->fc->setxattr_ext ?
52a4c95f VG	34	sizeof(inarg) : FUSE_COMPAT_SETXATTR_IN_SIZE;
d5b48543 MS	35	args.in_args[0].value = &inarg;
	36	args.in_args[1].size = strlen(name) + 1;
	37	args.in_args[1].value = name;
	38	args.in_args[2].size = size;
	39	args.in_args[2].value = value;
fcee216b	40	err = fuse_simple_request(fm, &args);
703c7362	41	if (err == -ENOSYS) {
fcee216b	42	fm->fc->no_setxattr = 1;
703c7362 SF	43	err = -EOPNOTSUPP;
	44	}
	45	if (!err) {
	46	fuse_invalidate_attr(inode);
	47	fuse_update_ctime(inode);
	48	}
	49	return err;
	50	}
	51
60bcc88a SF	52	ssize_t fuse_getxattr(struct inode inode, const char name, void *value,
60bcc88a SF	53	size_t size)
703c7362	54	{
fcee216b	55	struct fuse_mount *fm = get_fuse_mount(inode);
703c7362 SF	56	FUSE_ARGS(args);
	57	struct fuse_getxattr_in inarg;
	58	struct fuse_getxattr_out outarg;
	59	ssize_t ret;
	60
fcee216b	61	if (fm->fc->no_getxattr)
703c7362 SF	62	return -EOPNOTSUPP;
	63
	64	memset(&inarg, 0, sizeof(inarg));
	65	inarg.size = size;
d5b48543 MS	66	args.opcode = FUSE_GETXATTR;
	67	args.nodeid = get_node_id(inode);
	68	args.in_numargs = 2;
	69	args.in_args[0].size = sizeof(inarg);
	70	args.in_args[0].value = &inarg;
	71	args.in_args[1].size = strlen(name) + 1;
	72	args.in_args[1].value = name;
703c7362	73	/* This is really two different operations rolled into one */
d5b48543	74	args.out_numargs = 1;
703c7362	75	if (size) {
1f4e9d03	76	args.out_argvar = true;
d5b48543 MS	77	args.out_args[0].size = size;
d5b48543 MS	78	args.out_args[0].value = value;
703c7362	79	} else {
d5b48543 MS	80	args.out_args[0].size = sizeof(outarg);
d5b48543 MS	81	args.out_args[0].value = &outarg;
703c7362	82	}
fcee216b	83	ret = fuse_simple_request(fm, &args);
703c7362	84	if (!ret && !size)
63401ccd	85	ret = min_t(ssize_t, outarg.size, XATTR_SIZE_MAX);
703c7362	86	if (ret == -ENOSYS) {
fcee216b	87	fm->fc->no_getxattr = 1;
703c7362 SF	88	ret = -EOPNOTSUPP;
	89	}
	90	return ret;
	91	}
	92
	93	static int fuse_verify_xattr_list(char *list, size_t size)
	94	{
	95	size_t origsize = size;
	96
	97	while (size) {
	98	size_t thislen = strnlen(list, size);
	99
	100	if (!thislen \|\| thislen == size)
	101	return -EIO;
	102
	103	size -= thislen + 1;
	104	list += thislen + 1;
	105	}
	106
	107	return origsize;
	108	}
	109
	110	ssize_t fuse_listxattr(struct dentry entry, char list, size_t size)
	111	{
	112	struct inode *inode = d_inode(entry);
fcee216b	113	struct fuse_mount *fm = get_fuse_mount(inode);
703c7362 SF	114	FUSE_ARGS(args);
	115	struct fuse_getxattr_in inarg;
	116	struct fuse_getxattr_out outarg;
	117	ssize_t ret;
	118
5d069dbe MS	119	if (fuse_is_bad(inode))
	120	return -EIO;
	121
fcee216b	122	if (!fuse_allow_current_process(fm->fc))
703c7362 SF	123	return -EACCES;
703c7362 SF	124
fcee216b	125	if (fm->fc->no_listxattr)
703c7362 SF	126	return -EOPNOTSUPP;
	127
	128	memset(&inarg, 0, sizeof(inarg));
	129	inarg.size = size;
d5b48543 MS	130	args.opcode = FUSE_LISTXATTR;
	131	args.nodeid = get_node_id(inode);
	132	args.in_numargs = 1;
	133	args.in_args[0].size = sizeof(inarg);
	134	args.in_args[0].value = &inarg;
703c7362	135	/* This is really two different operations rolled into one */
d5b48543	136	args.out_numargs = 1;
703c7362	137	if (size) {
1f4e9d03	138	args.out_argvar = true;
d5b48543 MS	139	args.out_args[0].size = size;
d5b48543 MS	140	args.out_args[0].value = list;
703c7362	141	} else {
d5b48543 MS	142	args.out_args[0].size = sizeof(outarg);
d5b48543 MS	143	args.out_args[0].value = &outarg;
703c7362	144	}
fcee216b	145	ret = fuse_simple_request(fm, &args);
703c7362	146	if (!ret && !size)
63401ccd	147	ret = min_t(ssize_t, outarg.size, XATTR_LIST_MAX);
703c7362 SF	148	if (ret > 0 && size)
	149	ret = fuse_verify_xattr_list(list, ret);
	150	if (ret == -ENOSYS) {
fcee216b	151	fm->fc->no_listxattr = 1;
703c7362 SF	152	ret = -EOPNOTSUPP;
	153	}
	154	return ret;
	155	}
	156
60bcc88a	157	int fuse_removexattr(struct inode inode, const char name)
703c7362	158	{
fcee216b	159	struct fuse_mount *fm = get_fuse_mount(inode);
703c7362 SF	160	FUSE_ARGS(args);
	161	int err;
	162
fcee216b	163	if (fm->fc->no_removexattr)
703c7362 SF	164	return -EOPNOTSUPP;
703c7362 SF	165
d5b48543 MS	166	args.opcode = FUSE_REMOVEXATTR;
	167	args.nodeid = get_node_id(inode);
	168	args.in_numargs = 1;
	169	args.in_args[0].size = strlen(name) + 1;
	170	args.in_args[0].value = name;
fcee216b	171	err = fuse_simple_request(fm, &args);
703c7362	172	if (err == -ENOSYS) {
fcee216b	173	fm->fc->no_removexattr = 1;
703c7362 SF	174	err = -EOPNOTSUPP;
	175	}
	176	if (!err) {
	177	fuse_invalidate_attr(inode);
	178	fuse_update_ctime(inode);
	179	}
	180	return err;
	181	}
	182
	183	static int fuse_xattr_get(const struct xattr_handler *handler,
	184	struct dentry dentry, struct inode inode,
	185	const char name, void value, size_t size)
	186	{
5d069dbe MS	187	if (fuse_is_bad(inode))
	188	return -EIO;
	189
703c7362 SF	190	return fuse_getxattr(inode, name, value, size);
	191	}
	192
	193	static int fuse_xattr_set(const struct xattr_handler *handler,
e65ce2a5	194	struct user_namespace *mnt_userns,
703c7362 SF	195	struct dentry dentry, struct inode inode,
	196	const char name, const void value, size_t size,
	197	int flags)
	198	{
5d069dbe MS	199	if (fuse_is_bad(inode))
	200	return -EIO;
	201
703c7362 SF	202	if (!value)
	203	return fuse_removexattr(inode, name);
	204
52a4c95f	205	return fuse_setxattr(inode, name, value, size, flags, 0);
703c7362 SF	206	}
703c7362 SF	207
e45b2546 EB	208	static bool no_xattr_list(struct dentry *dentry)
	209	{
	210	return false;
	211	}
	212
	213	static int no_xattr_get(const struct xattr_handler *handler,
	214	struct dentry dentry, struct inode inode,
	215	const char name, void value, size_t size)
	216	{
	217	return -EOPNOTSUPP;
	218	}
	219
	220	static int no_xattr_set(const struct xattr_handler *handler,
e65ce2a5	221	struct user_namespace *mnt_userns,
e45b2546 EB	222	struct dentry dentry, struct inode nodee,
	223	const char name, const void value,
	224	size_t size, int flags)
	225	{
	226	return -EOPNOTSUPP;
	227	}
	228
703c7362 SF	229	static const struct xattr_handler fuse_xattr_handler = {
	230	.prefix = "",
	231	.get = fuse_xattr_get,
	232	.set = fuse_xattr_set,
	233	};
	234
	235	const struct xattr_handler *fuse_xattr_handlers[] = {
	236	&fuse_xattr_handler,
	237	NULL
	238	};
60bcc88a SF	239
	240	const struct xattr_handler *fuse_acl_xattr_handlers[] = {
	241	&posix_acl_access_xattr_handler,
	242	&posix_acl_default_xattr_handler,
	243	&fuse_xattr_handler,
	244	NULL
	245	};
e45b2546 EB	246
	247	static const struct xattr_handler fuse_no_acl_access_xattr_handler = {
	248	.name = XATTR_NAME_POSIX_ACL_ACCESS,
	249	.flags = ACL_TYPE_ACCESS,
	250	.list = no_xattr_list,
	251	.get = no_xattr_get,
	252	.set = no_xattr_set,
	253	};
	254
	255	static const struct xattr_handler fuse_no_acl_default_xattr_handler = {
	256	.name = XATTR_NAME_POSIX_ACL_DEFAULT,
	257	.flags = ACL_TYPE_ACCESS,
	258	.list = no_xattr_list,
	259	.get = no_xattr_get,
	260	.set = no_xattr_set,
	261	};
	262
	263	const struct xattr_handler *fuse_no_acl_xattr_handlers[] = {
	264	&fuse_no_acl_access_xattr_handler,
	265	&fuse_no_acl_default_xattr_handler,
	266	&fuse_xattr_handler,
	267	NULL
	268	};