[mirror_ubuntu-artful-kernel.git] / fs / cifs / xattr.c

/*
 *   fs/cifs/xattr.c
 *
 *   Copyright (c) International Business Machines  Corp., 2003, 2007
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   This library is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as published
 *   by the Free Software Foundation; either version 2.1 of the License, or
 *   (at your option) any later version.
 *
 *   This library is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 *   the GNU Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public License
 *   along with this library; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include <linux/fs.h>
#include <linux/posix_acl_xattr.h>
#include <linux/slab.h>
#include <linux/xattr.h>
#include "cifsfs.h"
#include "cifspdu.h"
#include "cifsglob.h"
#include "cifsproto.h"
#include "cifs_debug.h"

#define MAX_EA_VALUE_SIZE 65535
#define CIFS_XATTR_DOS_ATTRIB "user.DosAttrib"
#define CIFS_XATTR_CIFS_ACL "system.cifs_acl"

/* BB need to add server (Samba e.g) support for security and trusted prefix */

int cifs_removexattr(struct dentry *direntry, const char *ea_name)
{
	int rc = -EOPNOTSUPP;
#ifdef CONFIG_CIFS_XATTR
	unsigned int xid;
	struct cifs_sb_info *cifs_sb;
	struct tcon_link *tlink;
	struct cifs_tcon *pTcon;
	struct super_block *sb;
	char *full_path = NULL;

	if (direntry == NULL)
		return -EIO;
	if (direntry->d_inode == NULL)
		return -EIO;
	sb = direntry->d_inode->i_sb;
	if (sb == NULL)
		return -EIO;

	cifs_sb = CIFS_SB(sb);
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink))
		return PTR_ERR(tlink);
	pTcon = tlink_tcon(tlink);

	xid = get_xid();

	full_path = build_path_from_dentry(direntry);
	if (full_path == NULL) {
		rc = -ENOMEM;
		goto remove_ea_exit;
	}
	if (ea_name == NULL) {
		cifs_dbg(FYI, "Null xattr names not supported\n");
	} else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)
		&& (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN))) {
		cifs_dbg(FYI,
			 "illegal xattr request %s (only user namespace supported)\n",
			 ea_name);
		/* BB what if no namespace prefix? */
		/* Should we just pass them to server, except for
		system and perhaps security prefixes? */
	} else {
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
			goto remove_ea_exit;

		ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */
		if (pTcon->ses->server->ops->set_EA)
			rc = pTcon->ses->server->ops->set_EA(xid, pTcon,
				full_path, ea_name, NULL, (__u16)0,
				cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
					CIFS_MOUNT_MAP_SPECIAL_CHR);
	}
remove_ea_exit:
	kfree(full_path);
	free_xid(xid);
	cifs_put_tlink(tlink);
#endif
	return rc;
}

int cifs_setxattr(struct dentry *direntry, const char *ea_name,
		  const void *ea_value, size_t value_size, int flags)
{
	int rc = -EOPNOTSUPP;
#ifdef CONFIG_CIFS_XATTR
	unsigned int xid;
	struct cifs_sb_info *cifs_sb;
	struct tcon_link *tlink;
	struct cifs_tcon *pTcon;
	struct super_block *sb;
	char *full_path;

	if (direntry == NULL)
		return -EIO;
	if (direntry->d_inode == NULL)
		return -EIO;
	sb = direntry->d_inode->i_sb;
	if (sb == NULL)
		return -EIO;

	cifs_sb = CIFS_SB(sb);
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink))
		return PTR_ERR(tlink);
	pTcon = tlink_tcon(tlink);

	xid = get_xid();

	full_path = build_path_from_dentry(direntry);
	if (full_path == NULL) {
		rc = -ENOMEM;
		goto set_ea_exit;
	}
	/* return dos attributes as pseudo xattr */
	/* return alt name if available as pseudo attr */

	/* if proc/fs/cifs/streamstoxattr is set then
		search server for EAs or streams to
		returns as xattrs */
	if (value_size > MAX_EA_VALUE_SIZE) {
		cifs_dbg(FYI, "size of EA value too large\n");
		rc = -EOPNOTSUPP;
		goto set_ea_exit;
	}

	if (ea_name == NULL) {
		cifs_dbg(FYI, "Null xattr names not supported\n");
	} else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)
		   == 0) {
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
			goto set_ea_exit;
		if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0)
			cifs_dbg(FYI, "attempt to set cifs inode metadata\n");

		ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */
		if (pTcon->ses->server->ops->set_EA)
			rc = pTcon->ses->server->ops->set_EA(xid, pTcon,
				full_path, ea_name, ea_value, (__u16)value_size,
				cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
					CIFS_MOUNT_MAP_SPECIAL_CHR);
	} else if (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN)
		   == 0) {
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
			goto set_ea_exit;

		ea_name += XATTR_OS2_PREFIX_LEN; /* skip past os2. prefix */
		if (pTcon->ses->server->ops->set_EA)
			rc = pTcon->ses->server->ops->set_EA(xid, pTcon,
				full_path, ea_name, ea_value, (__u16)value_size,
				cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
					CIFS_MOUNT_MAP_SPECIAL_CHR);
	} else if (strncmp(ea_name, CIFS_XATTR_CIFS_ACL,
			strlen(CIFS_XATTR_CIFS_ACL)) == 0) {
#ifdef CONFIG_CIFS_ACL
		struct cifs_ntsd *pacl;
		pacl = kmalloc(value_size, GFP_KERNEL);
		if (!pacl) {
			rc = -ENOMEM;
		} else {
			memcpy(pacl, ea_value, value_size);
			if (pTcon->ses->server->ops->set_acl)
				rc = pTcon->ses->server->ops->set_acl(pacl,
						value_size, direntry->d_inode,
						full_path, CIFS_ACL_DACL);
			else
				rc = -EOPNOTSUPP;
			if (rc == 0) /* force revalidate of the inode */
				CIFS_I(direntry->d_inode)->time = 0;
			kfree(pacl);
		}
#else
		cifs_dbg(FYI, "Set CIFS ACL not supported yet\n");
#endif /* CONFIG_CIFS_ACL */
	} else {
		int temp;
		temp = strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,
			strlen(POSIX_ACL_XATTR_ACCESS));
		if (temp == 0) {
#ifdef CONFIG_CIFS_POSIX
			if (sb->s_flags & MS_POSIXACL)
				rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
					ea_value, (const int)value_size,
					ACL_TYPE_ACCESS, cifs_sb->local_nls,
					cifs_sb->mnt_cifs_flags &
						CIFS_MOUNT_MAP_SPECIAL_CHR);
			cifs_dbg(FYI, "set POSIX ACL rc %d\n", rc);
#else
			cifs_dbg(FYI, "set POSIX ACL not supported\n");
#endif
		} else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT,
				   strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
#ifdef CONFIG_CIFS_POSIX
			if (sb->s_flags & MS_POSIXACL)
				rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
					ea_value, (const int)value_size,
					ACL_TYPE_DEFAULT, cifs_sb->local_nls,
					cifs_sb->mnt_cifs_flags &
						CIFS_MOUNT_MAP_SPECIAL_CHR);
			cifs_dbg(FYI, "set POSIX default ACL rc %d\n", rc);
#else
			cifs_dbg(FYI, "set default POSIX ACL not supported\n");
#endif
		} else {
			cifs_dbg(FYI, "illegal xattr request %s (only user namespace supported)\n",
				 ea_name);
		  /* BB what if no namespace prefix? */
		  /* Should we just pass them to server, except for
		  system and perhaps security prefixes? */
		}
	}

set_ea_exit:
	kfree(full_path);
	free_xid(xid);
	cifs_put_tlink(tlink);
#endif
	return rc;
}

ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
	void *ea_value, size_t buf_size)
{
	ssize_t rc = -EOPNOTSUPP;
#ifdef CONFIG_CIFS_XATTR
	unsigned int xid;
	struct cifs_sb_info *cifs_sb;
	struct tcon_link *tlink;
	struct cifs_tcon *pTcon;
	struct super_block *sb;
	char *full_path;

	if (direntry == NULL)
		return -EIO;
	if (direntry->d_inode == NULL)
		return -EIO;
	sb = direntry->d_inode->i_sb;
	if (sb == NULL)
		return -EIO;

	cifs_sb = CIFS_SB(sb);
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink))
		return PTR_ERR(tlink);
	pTcon = tlink_tcon(tlink);

	xid = get_xid();

	full_path = build_path_from_dentry(direntry);
	if (full_path == NULL) {
		rc = -ENOMEM;
		goto get_ea_exit;
	}
	/* return dos attributes as pseudo xattr */
	/* return alt name if available as pseudo attr */
	if (ea_name == NULL) {
		cifs_dbg(FYI, "Null xattr names not supported\n");
	} else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)
		   == 0) {
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
			goto get_ea_exit;

		if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0) {
			cifs_dbg(FYI, "attempt to query cifs inode metadata\n");
			/* revalidate/getattr then populate from inode */
		} /* BB add else when above is implemented */
		ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */
		if (pTcon->ses->server->ops->query_all_EAs)
			rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
				full_path, ea_name, ea_value, buf_size,
				cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
					CIFS_MOUNT_MAP_SPECIAL_CHR);
	} else if (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN) == 0) {
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
			goto get_ea_exit;

		ea_name += XATTR_OS2_PREFIX_LEN; /* skip past os2. prefix */
		if (pTcon->ses->server->ops->query_all_EAs)
			rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
				full_path, ea_name, ea_value, buf_size,
				cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
					CIFS_MOUNT_MAP_SPECIAL_CHR);
	} else if (strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,
			  strlen(POSIX_ACL_XATTR_ACCESS)) == 0) {
#ifdef CONFIG_CIFS_POSIX
		if (sb->s_flags & MS_POSIXACL)
			rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
				ea_value, buf_size, ACL_TYPE_ACCESS,
				cifs_sb->local_nls,
				cifs_sb->mnt_cifs_flags &
					CIFS_MOUNT_MAP_SPECIAL_CHR);
#else
		cifs_dbg(FYI, "Query POSIX ACL not supported yet\n");
#endif /* CONFIG_CIFS_POSIX */
	} else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT,
			  strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
#ifdef CONFIG_CIFS_POSIX
		if (sb->s_flags & MS_POSIXACL)
			rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
				ea_value, buf_size, ACL_TYPE_DEFAULT,
				cifs_sb->local_nls,
				cifs_sb->mnt_cifs_flags &
					CIFS_MOUNT_MAP_SPECIAL_CHR);
#else
		cifs_dbg(FYI, "Query POSIX default ACL not supported yet\n");
#endif /* CONFIG_CIFS_POSIX */
	} else if (strncmp(ea_name, CIFS_XATTR_CIFS_ACL,
				strlen(CIFS_XATTR_CIFS_ACL)) == 0) {
#ifdef CONFIG_CIFS_ACL
			u32 acllen;
			struct cifs_ntsd *pacl;

			if (pTcon->ses->server->ops->get_acl == NULL)
				goto get_ea_exit; /* rc already EOPNOTSUPP */

			pacl = pTcon->ses->server->ops->get_acl(cifs_sb,
					direntry->d_inode, full_path, &acllen);
			if (IS_ERR(pacl)) {
				rc = PTR_ERR(pacl);
				cifs_dbg(VFS, "%s: error %zd getting sec desc\n",
					 __func__, rc);
			} else {
				if (ea_value) {
					if (acllen > buf_size)
						acllen = -ERANGE;
					else
						memcpy(ea_value, pacl, acllen);
				}
				rc = acllen;
				kfree(pacl);
			}
#else
			cifs_dbg(FYI, "Query CIFS ACL not supported yet\n");
#endif /* CONFIG_CIFS_ACL */
	} else if (strncmp(ea_name,
		  XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) == 0) {
		cifs_dbg(FYI, "Trusted xattr namespace not supported yet\n");
	} else if (strncmp(ea_name,
		  XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) == 0) {
		cifs_dbg(FYI, "Security xattr namespace not supported yet\n");
	} else
		cifs_dbg(FYI,
			 "illegal xattr request %s (only user namespace supported)\n",
			 ea_name);

	/* We could add an additional check for streams ie
	    if proc/fs/cifs/streamstoxattr is set then
		search server for EAs or streams to
		returns as xattrs */

	if (rc == -EINVAL)
		rc = -EOPNOTSUPP;

get_ea_exit:
	kfree(full_path);
	free_xid(xid);
	cifs_put_tlink(tlink);
#endif
	return rc;
}

ssize_t cifs_listxattr(struct dentry *direntry, char *data, size_t buf_size)
{
	ssize_t rc = -EOPNOTSUPP;
#ifdef CONFIG_CIFS_XATTR
	unsigned int xid;
	struct cifs_sb_info *cifs_sb;
	struct tcon_link *tlink;
	struct cifs_tcon *pTcon;
	struct super_block *sb;
	char *full_path;

	if (direntry == NULL)
		return -EIO;
	if (direntry->d_inode == NULL)
		return -EIO;
	sb = direntry->d_inode->i_sb;
	if (sb == NULL)
		return -EIO;

	cifs_sb = CIFS_SB(sb);
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
		return -EOPNOTSUPP;

	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink))
		return PTR_ERR(tlink);
	pTcon = tlink_tcon(tlink);

	xid = get_xid();

	full_path = build_path_from_dentry(direntry);
	if (full_path == NULL) {
		rc = -ENOMEM;
		goto list_ea_exit;
	}
	/* return dos attributes as pseudo xattr */
	/* return alt name if available as pseudo attr */

	/* if proc/fs/cifs/streamstoxattr is set then
		search server for EAs or streams to
		returns as xattrs */

	if (pTcon->ses->server->ops->query_all_EAs)
		rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
				full_path, NULL, data, buf_size,
				cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
					CIFS_MOUNT_MAP_SPECIAL_CHR);
list_ea_exit:
	kfree(full_path);
	free_xid(xid);
	cifs_put_tlink(tlink);
#endif
	return rc;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* fs/cifs/xattr.c
	3	*
79a58d1f	4	* Copyright (c) International Business Machines Corp., 2003, 2007
1da177e4 LT	5	* Author(s): Steve French (sfrench@us.ibm.com)
	6	*
	7	* This library is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU Lesser General Public License as published
	9	* by the Free Software Foundation; either version 2.1 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This library is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
	15	* the GNU Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public License
	18	* along with this library; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	20	*/
	21
	22	#include <linux/fs.h>
	23	#include <linux/posix_acl_xattr.h>
5a0e3ad6	24	#include <linux/slab.h>
f995e740	25	#include <linux/xattr.h>
1da177e4 LT	26	#include "cifsfs.h"
	27	#include "cifspdu.h"
	28	#include "cifsglob.h"
	29	#include "cifsproto.h"
	30	#include "cifs_debug.h"
	31
	32	#define MAX_EA_VALUE_SIZE 65535
	33	#define CIFS_XATTR_DOS_ATTRIB "user.DosAttrib"
fbeba8bb	34	#define CIFS_XATTR_CIFS_ACL "system.cifs_acl"
1da177e4	35
f995e740	36	/* BB need to add server (Samba e.g) support for security and trusted prefix */
1da177e4	37
79a58d1f	38	int cifs_removexattr(struct dentry direntry, const char ea_name)
1da177e4 LT	39	{
	40	int rc = -EOPNOTSUPP;
	41	#ifdef CONFIG_CIFS_XATTR
6d5786a3	42	unsigned int xid;
1da177e4	43	struct cifs_sb_info *cifs_sb;
7ffec372	44	struct tcon_link *tlink;
96daf2b0	45	struct cifs_tcon *pTcon;
79a58d1f	46	struct super_block *sb;
7ffec372	47	char *full_path = NULL;
79a58d1f SF	48
79a58d1f SF	49	if (direntry == NULL)
1da177e4	50	return -EIO;
79a58d1f	51	if (direntry->d_inode == NULL)
1da177e4 LT	52	return -EIO;
1da177e4 LT	53	sb = direntry->d_inode->i_sb;
79a58d1f	54	if (sb == NULL)
1da177e4	55	return -EIO;
79a58d1f	56
1da177e4	57	cifs_sb = CIFS_SB(sb);
7ffec372 JL	58	tlink = cifs_sb_tlink(cifs_sb);
	59	if (IS_ERR(tlink))
	60	return PTR_ERR(tlink);
	61	pTcon = tlink_tcon(tlink);
	62
6d5786a3	63	xid = get_xid();
79a58d1f	64
1da177e4	65	full_path = build_path_from_dentry(direntry);
79a58d1f	66	if (full_path == NULL) {
0f3bc09e	67	rc = -ENOMEM;
7ffec372	68	goto remove_ea_exit;
1da177e4	69	}
79a58d1f	70	if (ea_name == NULL) {
f96637be	71	cifs_dbg(FYI, "Null xattr names not supported\n");
f995e740 MZ	72	} else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)
f995e740 MZ	73	&& (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN))) {
f96637be JP	74	cifs_dbg(FYI,
	75	"illegal xattr request %s (only user namespace supported)\n",
	76	ea_name);
1da177e4 LT	77	/* BB what if no namespace prefix? */
	78	/* Should we just pass them to server, except for
	79	system and perhaps security prefixes? */
	80	} else {
79a58d1f	81	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
1da177e4 LT	82	goto remove_ea_exit;
1da177e4 LT	83
f995e740	84	ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */
666753c3 SF	85	if (pTcon->ses->server->ops->set_EA)
	86	rc = pTcon->ses->server->ops->set_EA(xid, pTcon,
	87	full_path, ea_name, NULL, (__u16)0,
	88	cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
	89	CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4 LT	90	}
1da177e4 LT	91	remove_ea_exit:
f99d49ad	92	kfree(full_path);
6d5786a3	93	free_xid(xid);
7ffec372	94	cifs_put_tlink(tlink);
1da177e4 LT	95	#endif
	96	return rc;
	97	}
	98
79a58d1f SF	99	int cifs_setxattr(struct dentry direntry, const char ea_name,
79a58d1f SF	100	const void *ea_value, size_t value_size, int flags)
1da177e4 LT	101	{
	102	int rc = -EOPNOTSUPP;
	103	#ifdef CONFIG_CIFS_XATTR
6d5786a3	104	unsigned int xid;
1da177e4	105	struct cifs_sb_info *cifs_sb;
7ffec372	106	struct tcon_link *tlink;
96daf2b0	107	struct cifs_tcon *pTcon;
79a58d1f SF	108	struct super_block *sb;
79a58d1f SF	109	char *full_path;
1da177e4	110
79a58d1f	111	if (direntry == NULL)
1da177e4	112	return -EIO;
79a58d1f	113	if (direntry->d_inode == NULL)
1da177e4 LT	114	return -EIO;
1da177e4 LT	115	sb = direntry->d_inode->i_sb;
79a58d1f	116	if (sb == NULL)
1da177e4	117	return -EIO;
1da177e4 LT	118
1da177e4 LT	119	cifs_sb = CIFS_SB(sb);
7ffec372 JL	120	tlink = cifs_sb_tlink(cifs_sb);
	121	if (IS_ERR(tlink))
	122	return PTR_ERR(tlink);
	123	pTcon = tlink_tcon(tlink);
	124
6d5786a3	125	xid = get_xid();
1da177e4	126
1da177e4	127	full_path = build_path_from_dentry(direntry);
79a58d1f	128	if (full_path == NULL) {
0f3bc09e	129	rc = -ENOMEM;
7ffec372	130	goto set_ea_exit;
1da177e4 LT	131	}
	132	/* return dos attributes as pseudo xattr */
	133	/* return alt name if available as pseudo attr */
	134
	135	/* if proc/fs/cifs/streamstoxattr is set then
79a58d1f	136	search server for EAs or streams to
1da177e4	137	returns as xattrs */
79a58d1f	138	if (value_size > MAX_EA_VALUE_SIZE) {
f96637be	139	cifs_dbg(FYI, "size of EA value too large\n");
7ffec372 JL	140	rc = -EOPNOTSUPP;
7ffec372 JL	141	goto set_ea_exit;
1da177e4 LT	142	}
1da177e4 LT	143
79a58d1f	144	if (ea_name == NULL) {
f96637be	145	cifs_dbg(FYI, "Null xattr names not supported\n");
f995e740 MZ	146	} else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)
f995e740 MZ	147	== 0) {
79a58d1f	148	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
1da177e4	149	goto set_ea_exit;
ad7a2926	150	if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0)
f96637be	151	cifs_dbg(FYI, "attempt to set cifs inode metadata\n");
ad7a2926	152
f995e740	153	ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */
666753c3 SF	154	if (pTcon->ses->server->ops->set_EA)
	155	rc = pTcon->ses->server->ops->set_EA(xid, pTcon,
	156	full_path, ea_name, ea_value, (__u16)value_size,
	157	cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
	158	CIFS_MOUNT_MAP_SPECIAL_CHR);
f995e740 MZ	159	} else if (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN)
f995e740 MZ	160	== 0) {
79a58d1f	161	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
1da177e4 LT	162	goto set_ea_exit;
1da177e4 LT	163
f995e740	164	ea_name += XATTR_OS2_PREFIX_LEN; /* skip past os2. prefix */
666753c3 SF	165	if (pTcon->ses->server->ops->set_EA)
	166	rc = pTcon->ses->server->ops->set_EA(xid, pTcon,
	167	full_path, ea_name, ea_value, (__u16)value_size,
	168	cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
	169	CIFS_MOUNT_MAP_SPECIAL_CHR);
b73b9a4b SF	170	} else if (strncmp(ea_name, CIFS_XATTR_CIFS_ACL,
b73b9a4b SF	171	strlen(CIFS_XATTR_CIFS_ACL)) == 0) {
b0f8ef20 SN	172	#ifdef CONFIG_CIFS_ACL
b0f8ef20 SN	173	struct cifs_ntsd *pacl;
b73b9a4b SF	174	pacl = kmalloc(value_size, GFP_KERNEL);
b73b9a4b SF	175	if (!pacl) {
b73b9a4b SF	176	rc = -ENOMEM;
b73b9a4b SF	177	} else {
b73b9a4b	178	memcpy(pacl, ea_value, value_size);
83e3bc23 SF	179	if (pTcon->ses->server->ops->set_acl)
	180	rc = pTcon->ses->server->ops->set_acl(pacl,
	181	value_size, direntry->d_inode,
	182	full_path, CIFS_ACL_DACL);
	183	else
	184	rc = -EOPNOTSUPP;
b73b9a4b SF	185	if (rc == 0) /* force revalidate of the inode */
	186	CIFS_I(direntry->d_inode)->time = 0;
	187	kfree(pacl);
b0f8ef20	188	}
b73b9a4b	189	#else
f96637be	190	cifs_dbg(FYI, "Set CIFS ACL not supported yet\n");
b73b9a4b	191	#endif /* CONFIG_CIFS_ACL */
1da177e4	192	} else {
79a58d1f SF	193	int temp;
79a58d1f SF	194	temp = strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,
1da177e4 LT	195	strlen(POSIX_ACL_XATTR_ACCESS));
	196	if (temp == 0) {
	197	#ifdef CONFIG_CIFS_POSIX
79a58d1f SF	198	if (sb->s_flags & MS_POSIXACL)
	199	rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
	200	ea_value, (const int)value_size,
	201	ACL_TYPE_ACCESS, cifs_sb->local_nls,
	202	cifs_sb->mnt_cifs_flags &
737b758c	203	CIFS_MOUNT_MAP_SPECIAL_CHR);
f96637be	204	cifs_dbg(FYI, "set POSIX ACL rc %d\n", rc);
1da177e4	205	#else
f96637be	206	cifs_dbg(FYI, "set POSIX ACL not supported\n");
1da177e4	207	#endif
79a58d1f SF	208	} else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT,
79a58d1f SF	209	strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
1da177e4	210	#ifdef CONFIG_CIFS_POSIX
79a58d1f SF	211	if (sb->s_flags & MS_POSIXACL)
	212	rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
	213	ea_value, (const int)value_size,
737b758c	214	ACL_TYPE_DEFAULT, cifs_sb->local_nls,
79a58d1f	215	cifs_sb->mnt_cifs_flags &
737b758c	216	CIFS_MOUNT_MAP_SPECIAL_CHR);
f96637be	217	cifs_dbg(FYI, "set POSIX default ACL rc %d\n", rc);
1da177e4	218	#else
f96637be	219	cifs_dbg(FYI, "set default POSIX ACL not supported\n");
1da177e4 LT	220	#endif
1da177e4 LT	221	} else {
f96637be JP	222	cifs_dbg(FYI, "illegal xattr request %s (only user namespace supported)\n",
f96637be JP	223	ea_name);
1da177e4	224	/* BB what if no namespace prefix? */
79a58d1f	225	/* Should we just pass them to server, except for
1da177e4 LT	226	system and perhaps security prefixes? */
	227	}
	228	}
	229
	230	set_ea_exit:
f99d49ad	231	kfree(full_path);
6d5786a3	232	free_xid(xid);
7ffec372	233	cifs_put_tlink(tlink);
1da177e4 LT	234	#endif
	235	return rc;
	236	}
	237
79a58d1f SF	238	ssize_t cifs_getxattr(struct dentry direntry, const char ea_name,
79a58d1f SF	239	void *ea_value, size_t buf_size)
1da177e4 LT	240	{
	241	ssize_t rc = -EOPNOTSUPP;
	242	#ifdef CONFIG_CIFS_XATTR
6d5786a3	243	unsigned int xid;
1da177e4	244	struct cifs_sb_info *cifs_sb;
7ffec372	245	struct tcon_link *tlink;
96daf2b0	246	struct cifs_tcon *pTcon;
79a58d1f SF	247	struct super_block *sb;
79a58d1f SF	248	char *full_path;
1da177e4	249
79a58d1f	250	if (direntry == NULL)
1da177e4	251	return -EIO;
79a58d1f	252	if (direntry->d_inode == NULL)
1da177e4 LT	253	return -EIO;
1da177e4 LT	254	sb = direntry->d_inode->i_sb;
79a58d1f	255	if (sb == NULL)
1da177e4 LT	256	return -EIO;
1da177e4 LT	257
1da177e4	258	cifs_sb = CIFS_SB(sb);
7ffec372 JL	259	tlink = cifs_sb_tlink(cifs_sb);
	260	if (IS_ERR(tlink))
	261	return PTR_ERR(tlink);
	262	pTcon = tlink_tcon(tlink);
	263
6d5786a3	264	xid = get_xid();
1da177e4	265
1da177e4	266	full_path = build_path_from_dentry(direntry);
79a58d1f	267	if (full_path == NULL) {
0f3bc09e	268	rc = -ENOMEM;
7ffec372	269	goto get_ea_exit;
1da177e4 LT	270	}
	271	/* return dos attributes as pseudo xattr */
	272	/* return alt name if available as pseudo attr */
79a58d1f	273	if (ea_name == NULL) {
f96637be	274	cifs_dbg(FYI, "Null xattr names not supported\n");
f995e740 MZ	275	} else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)
f995e740 MZ	276	== 0) {
79a58d1f	277	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
1da177e4 LT	278	goto get_ea_exit;
1da177e4 LT	279
79a58d1f	280	if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0) {
f96637be	281	cifs_dbg(FYI, "attempt to query cifs inode metadata\n");
1da177e4 LT	282	/* revalidate/getattr then populate from inode */
1da177e4 LT	283	} /* BB add else when above is implemented */
f995e740	284	ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */
666753c3 SF	285	if (pTcon->ses->server->ops->query_all_EAs)
	286	rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
	287	full_path, ea_name, ea_value, buf_size,
	288	cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
	289	CIFS_MOUNT_MAP_SPECIAL_CHR);
f995e740	290	} else if (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN) == 0) {
79a58d1f	291	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
1da177e4 LT	292	goto get_ea_exit;
1da177e4 LT	293
f995e740	294	ea_name += XATTR_OS2_PREFIX_LEN; /* skip past os2. prefix */
666753c3 SF	295	if (pTcon->ses->server->ops->query_all_EAs)
	296	rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
	297	full_path, ea_name, ea_value, buf_size,
	298	cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
	299	CIFS_MOUNT_MAP_SPECIAL_CHR);
79a58d1f	300	} else if (strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,
0a4b92c0	301	strlen(POSIX_ACL_XATTR_ACCESS)) == 0) {
1da177e4	302	#ifdef CONFIG_CIFS_POSIX
79a58d1f	303	if (sb->s_flags & MS_POSIXACL)
1da0c78b	304	rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
79a58d1f	305	ea_value, buf_size, ACL_TYPE_ACCESS,
737b758c	306	cifs_sb->local_nls,
79a58d1f	307	cifs_sb->mnt_cifs_flags &
737b758c	308	CIFS_MOUNT_MAP_SPECIAL_CHR);
79a58d1f	309	#else
f96637be	310	cifs_dbg(FYI, "Query POSIX ACL not supported yet\n");
1da177e4	311	#endif /* CONFIG_CIFS_POSIX */
79a58d1f	312	} else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT,
0a4b92c0	313	strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
1da177e4	314	#ifdef CONFIG_CIFS_POSIX
79a58d1f	315	if (sb->s_flags & MS_POSIXACL)
1da0c78b	316	rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
79a58d1f	317	ea_value, buf_size, ACL_TYPE_DEFAULT,
737b758c	318	cifs_sb->local_nls,
79a58d1f	319	cifs_sb->mnt_cifs_flags &
737b758c	320	CIFS_MOUNT_MAP_SPECIAL_CHR);
79a58d1f	321	#else
f96637be	322	cifs_dbg(FYI, "Query POSIX default ACL not supported yet\n");
fbeba8bb SP	323	#endif /* CONFIG_CIFS_POSIX */
	324	} else if (strncmp(ea_name, CIFS_XATTR_CIFS_ACL,
	325	strlen(CIFS_XATTR_CIFS_ACL)) == 0) {
	326	#ifdef CONFIG_CIFS_ACL
	327	u32 acllen;
	328	struct cifs_ntsd *pacl;
	329
83e3bc23 SF	330	if (pTcon->ses->server->ops->get_acl == NULL)
	331	goto get_ea_exit; /* rc already EOPNOTSUPP */
	332
	333	pacl = pTcon->ses->server->ops->get_acl(cifs_sb,
	334	direntry->d_inode, full_path, &acllen);
fbeba8bb SP	335	if (IS_ERR(pacl)) {
fbeba8bb SP	336	rc = PTR_ERR(pacl);
f96637be JP	337	cifs_dbg(VFS, "%s: error %zd getting sec desc\n",
f96637be JP	338	__func__, rc);
fbeba8bb SP	339	} else {
	340	if (ea_value) {
	341	if (acllen > buf_size)
	342	acllen = -ERANGE;
	343	else
	344	memcpy(ea_value, pacl, acllen);
	345	}
	346	rc = acllen;
	347	kfree(pacl);
	348	}
	349	#else
f96637be	350	cifs_dbg(FYI, "Query CIFS ACL not supported yet\n");
fbeba8bb	351	#endif /* CONFIG_CIFS_ACL */
79a58d1f	352	} else if (strncmp(ea_name,
f995e740	353	XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) == 0) {
f96637be	354	cifs_dbg(FYI, "Trusted xattr namespace not supported yet\n");
79a58d1f	355	} else if (strncmp(ea_name,
f995e740	356	XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) == 0) {
f96637be	357	cifs_dbg(FYI, "Security xattr namespace not supported yet\n");
ad7a2926	358	} else
f96637be JP	359	cifs_dbg(FYI,
	360	"illegal xattr request %s (only user namespace supported)\n",
	361	ea_name);
1da177e4	362
79a58d1f	363	/* We could add an additional check for streams ie
1da177e4	364	if proc/fs/cifs/streamstoxattr is set then
79a58d1f	365	search server for EAs or streams to
1da177e4 LT	366	returns as xattrs */
1da177e4 LT	367
79a58d1f SF	368	if (rc == -EINVAL)
79a58d1f SF	369	rc = -EOPNOTSUPP;
1da177e4 LT	370
1da177e4 LT	371	get_ea_exit:
f99d49ad	372	kfree(full_path);
6d5786a3	373	free_xid(xid);
7ffec372	374	cifs_put_tlink(tlink);
1da177e4 LT	375	#endif
	376	return rc;
	377	}
	378
79a58d1f	379	ssize_t cifs_listxattr(struct dentry direntry, char data, size_t buf_size)
1da177e4 LT	380	{
	381	ssize_t rc = -EOPNOTSUPP;
	382	#ifdef CONFIG_CIFS_XATTR
6d5786a3	383	unsigned int xid;
1da177e4	384	struct cifs_sb_info *cifs_sb;
7ffec372	385	struct tcon_link *tlink;
96daf2b0	386	struct cifs_tcon *pTcon;
79a58d1f SF	387	struct super_block *sb;
79a58d1f SF	388	char *full_path;
1da177e4	389
79a58d1f	390	if (direntry == NULL)
1da177e4	391	return -EIO;
79a58d1f	392	if (direntry->d_inode == NULL)
1da177e4 LT	393	return -EIO;
1da177e4 LT	394	sb = direntry->d_inode->i_sb;
79a58d1f	395	if (sb == NULL)
1da177e4	396	return -EIO;
1da177e4 LT	397
1da177e4 LT	398	cifs_sb = CIFS_SB(sb);
79a58d1f	399	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
ea4c07d7 SF	400	return -EOPNOTSUPP;
ea4c07d7 SF	401
7ffec372 JL	402	tlink = cifs_sb_tlink(cifs_sb);
	403	if (IS_ERR(tlink))
	404	return PTR_ERR(tlink);
	405	pTcon = tlink_tcon(tlink);
	406
6d5786a3	407	xid = get_xid();
ea4c07d7	408
1da177e4	409	full_path = build_path_from_dentry(direntry);
79a58d1f	410	if (full_path == NULL) {
0f3bc09e	411	rc = -ENOMEM;
7ffec372	412	goto list_ea_exit;
1da177e4 LT	413	}
	414	/* return dos attributes as pseudo xattr */
	415	/* return alt name if available as pseudo attr */
	416
	417	/* if proc/fs/cifs/streamstoxattr is set then
79a58d1f	418	search server for EAs or streams to
1da177e4	419	returns as xattrs */
1da177e4	420
666753c3 SF	421	if (pTcon->ses->server->ops->query_all_EAs)
	422	rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
	423	full_path, NULL, data, buf_size,
	424	cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
	425	CIFS_MOUNT_MAP_SPECIAL_CHR);
7ffec372	426	list_ea_exit:
f99d49ad	427	kfree(full_path);
6d5786a3	428	free_xid(xid);
7ffec372	429	cifs_put_tlink(tlink);
1da177e4 LT	430	#endif
	431	return rc;
	432	}