[mirror_ubuntu-jammy-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);
			rc = set_cifs_acl(pacl, value_size,
				direntry->d_inode, full_path, CIFS_ACL_DACL);
			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;

			pacl = get_cifs_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 SF	178	memcpy(pacl, ea_value, value_size);
b73b9a4b SF	179	rc = set_cifs_acl(pacl, value_size,
a5ff3769	180	direntry->d_inode, full_path, CIFS_ACL_DACL);
b73b9a4b SF	181	if (rc == 0) /* force revalidate of the inode */
	182	CIFS_I(direntry->d_inode)->time = 0;
	183	kfree(pacl);
b0f8ef20	184	}
b73b9a4b	185	#else
f96637be	186	cifs_dbg(FYI, "Set CIFS ACL not supported yet\n");
b73b9a4b	187	#endif /* CONFIG_CIFS_ACL */
1da177e4	188	} else {
79a58d1f SF	189	int temp;
79a58d1f SF	190	temp = strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,
1da177e4 LT	191	strlen(POSIX_ACL_XATTR_ACCESS));
	192	if (temp == 0) {
	193	#ifdef CONFIG_CIFS_POSIX
79a58d1f SF	194	if (sb->s_flags & MS_POSIXACL)
	195	rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
	196	ea_value, (const int)value_size,
	197	ACL_TYPE_ACCESS, cifs_sb->local_nls,
	198	cifs_sb->mnt_cifs_flags &
737b758c	199	CIFS_MOUNT_MAP_SPECIAL_CHR);
f96637be	200	cifs_dbg(FYI, "set POSIX ACL rc %d\n", rc);
1da177e4	201	#else
f96637be	202	cifs_dbg(FYI, "set POSIX ACL not supported\n");
1da177e4	203	#endif
79a58d1f SF	204	} else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT,
79a58d1f SF	205	strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
1da177e4	206	#ifdef CONFIG_CIFS_POSIX
79a58d1f SF	207	if (sb->s_flags & MS_POSIXACL)
	208	rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
	209	ea_value, (const int)value_size,
737b758c	210	ACL_TYPE_DEFAULT, cifs_sb->local_nls,
79a58d1f	211	cifs_sb->mnt_cifs_flags &
737b758c	212	CIFS_MOUNT_MAP_SPECIAL_CHR);
f96637be	213	cifs_dbg(FYI, "set POSIX default ACL rc %d\n", rc);
1da177e4	214	#else
f96637be	215	cifs_dbg(FYI, "set default POSIX ACL not supported\n");
1da177e4 LT	216	#endif
1da177e4 LT	217	} else {
f96637be JP	218	cifs_dbg(FYI, "illegal xattr request %s (only user namespace supported)\n",
f96637be JP	219	ea_name);
1da177e4	220	/* BB what if no namespace prefix? */
79a58d1f	221	/* Should we just pass them to server, except for
1da177e4 LT	222	system and perhaps security prefixes? */
	223	}
	224	}
	225
	226	set_ea_exit:
f99d49ad	227	kfree(full_path);
6d5786a3	228	free_xid(xid);
7ffec372	229	cifs_put_tlink(tlink);
1da177e4 LT	230	#endif
	231	return rc;
	232	}
	233
79a58d1f SF	234	ssize_t cifs_getxattr(struct dentry direntry, const char ea_name,
79a58d1f SF	235	void *ea_value, size_t buf_size)
1da177e4 LT	236	{
	237	ssize_t rc = -EOPNOTSUPP;
	238	#ifdef CONFIG_CIFS_XATTR
6d5786a3	239	unsigned int xid;
1da177e4	240	struct cifs_sb_info *cifs_sb;
7ffec372	241	struct tcon_link *tlink;
96daf2b0	242	struct cifs_tcon *pTcon;
79a58d1f SF	243	struct super_block *sb;
79a58d1f SF	244	char *full_path;
1da177e4	245
79a58d1f	246	if (direntry == NULL)
1da177e4	247	return -EIO;
79a58d1f	248	if (direntry->d_inode == NULL)
1da177e4 LT	249	return -EIO;
1da177e4 LT	250	sb = direntry->d_inode->i_sb;
79a58d1f	251	if (sb == NULL)
1da177e4 LT	252	return -EIO;
1da177e4 LT	253
1da177e4	254	cifs_sb = CIFS_SB(sb);
7ffec372 JL	255	tlink = cifs_sb_tlink(cifs_sb);
	256	if (IS_ERR(tlink))
	257	return PTR_ERR(tlink);
	258	pTcon = tlink_tcon(tlink);
	259
6d5786a3	260	xid = get_xid();
1da177e4	261
1da177e4	262	full_path = build_path_from_dentry(direntry);
79a58d1f	263	if (full_path == NULL) {
0f3bc09e	264	rc = -ENOMEM;
7ffec372	265	goto get_ea_exit;
1da177e4 LT	266	}
	267	/* return dos attributes as pseudo xattr */
	268	/* return alt name if available as pseudo attr */
79a58d1f	269	if (ea_name == NULL) {
f96637be	270	cifs_dbg(FYI, "Null xattr names not supported\n");
f995e740 MZ	271	} else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)
f995e740 MZ	272	== 0) {
79a58d1f	273	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
1da177e4 LT	274	goto get_ea_exit;
1da177e4 LT	275
79a58d1f	276	if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0) {
f96637be	277	cifs_dbg(FYI, "attempt to query cifs inode metadata\n");
1da177e4 LT	278	/* revalidate/getattr then populate from inode */
1da177e4 LT	279	} /* BB add else when above is implemented */
f995e740	280	ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */
666753c3 SF	281	if (pTcon->ses->server->ops->query_all_EAs)
	282	rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
	283	full_path, ea_name, ea_value, buf_size,
	284	cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
	285	CIFS_MOUNT_MAP_SPECIAL_CHR);
f995e740	286	} else if (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN) == 0) {
79a58d1f	287	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
1da177e4 LT	288	goto get_ea_exit;
1da177e4 LT	289
f995e740	290	ea_name += XATTR_OS2_PREFIX_LEN; /* skip past os2. prefix */
666753c3 SF	291	if (pTcon->ses->server->ops->query_all_EAs)
	292	rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
	293	full_path, ea_name, ea_value, buf_size,
	294	cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
	295	CIFS_MOUNT_MAP_SPECIAL_CHR);
79a58d1f	296	} else if (strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,
0a4b92c0	297	strlen(POSIX_ACL_XATTR_ACCESS)) == 0) {
1da177e4	298	#ifdef CONFIG_CIFS_POSIX
79a58d1f	299	if (sb->s_flags & MS_POSIXACL)
1da0c78b	300	rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
79a58d1f	301	ea_value, buf_size, ACL_TYPE_ACCESS,
737b758c	302	cifs_sb->local_nls,
79a58d1f	303	cifs_sb->mnt_cifs_flags &
737b758c	304	CIFS_MOUNT_MAP_SPECIAL_CHR);
79a58d1f	305	#else
f96637be	306	cifs_dbg(FYI, "Query POSIX ACL not supported yet\n");
1da177e4	307	#endif /* CONFIG_CIFS_POSIX */
79a58d1f	308	} else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT,
0a4b92c0	309	strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
1da177e4	310	#ifdef CONFIG_CIFS_POSIX
79a58d1f	311	if (sb->s_flags & MS_POSIXACL)
1da0c78b	312	rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
79a58d1f	313	ea_value, buf_size, ACL_TYPE_DEFAULT,
737b758c	314	cifs_sb->local_nls,
79a58d1f	315	cifs_sb->mnt_cifs_flags &
737b758c	316	CIFS_MOUNT_MAP_SPECIAL_CHR);
79a58d1f	317	#else
f96637be	318	cifs_dbg(FYI, "Query POSIX default ACL not supported yet\n");
fbeba8bb SP	319	#endif /* CONFIG_CIFS_POSIX */
	320	} else if (strncmp(ea_name, CIFS_XATTR_CIFS_ACL,
	321	strlen(CIFS_XATTR_CIFS_ACL)) == 0) {
	322	#ifdef CONFIG_CIFS_ACL
	323	u32 acllen;
	324	struct cifs_ntsd *pacl;
	325
	326	pacl = get_cifs_acl(cifs_sb, direntry->d_inode,
	327	full_path, &acllen);
	328	if (IS_ERR(pacl)) {
	329	rc = PTR_ERR(pacl);
f96637be JP	330	cifs_dbg(VFS, "%s: error %zd getting sec desc\n",
f96637be JP	331	__func__, rc);
fbeba8bb SP	332	} else {
	333	if (ea_value) {
	334	if (acllen > buf_size)
	335	acllen = -ERANGE;
	336	else
	337	memcpy(ea_value, pacl, acllen);
	338	}
	339	rc = acllen;
	340	kfree(pacl);
	341	}
	342	#else
f96637be	343	cifs_dbg(FYI, "Query CIFS ACL not supported yet\n");
fbeba8bb	344	#endif /* CONFIG_CIFS_ACL */
79a58d1f	345	} else if (strncmp(ea_name,
f995e740	346	XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) == 0) {
f96637be	347	cifs_dbg(FYI, "Trusted xattr namespace not supported yet\n");
79a58d1f	348	} else if (strncmp(ea_name,
f995e740	349	XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) == 0) {
f96637be	350	cifs_dbg(FYI, "Security xattr namespace not supported yet\n");
ad7a2926	351	} else
f96637be JP	352	cifs_dbg(FYI,
	353	"illegal xattr request %s (only user namespace supported)\n",
	354	ea_name);
1da177e4	355
79a58d1f	356	/* We could add an additional check for streams ie
1da177e4	357	if proc/fs/cifs/streamstoxattr is set then
79a58d1f	358	search server for EAs or streams to
1da177e4 LT	359	returns as xattrs */
1da177e4 LT	360
79a58d1f SF	361	if (rc == -EINVAL)
79a58d1f SF	362	rc = -EOPNOTSUPP;
1da177e4 LT	363
1da177e4 LT	364	get_ea_exit:
f99d49ad	365	kfree(full_path);
6d5786a3	366	free_xid(xid);
7ffec372	367	cifs_put_tlink(tlink);
1da177e4 LT	368	#endif
	369	return rc;
	370	}
	371
79a58d1f	372	ssize_t cifs_listxattr(struct dentry direntry, char data, size_t buf_size)
1da177e4 LT	373	{
	374	ssize_t rc = -EOPNOTSUPP;
	375	#ifdef CONFIG_CIFS_XATTR
6d5786a3	376	unsigned int xid;
1da177e4	377	struct cifs_sb_info *cifs_sb;
7ffec372	378	struct tcon_link *tlink;
96daf2b0	379	struct cifs_tcon *pTcon;
79a58d1f SF	380	struct super_block *sb;
79a58d1f SF	381	char *full_path;
1da177e4	382
79a58d1f	383	if (direntry == NULL)
1da177e4	384	return -EIO;
79a58d1f	385	if (direntry->d_inode == NULL)
1da177e4 LT	386	return -EIO;
1da177e4 LT	387	sb = direntry->d_inode->i_sb;
79a58d1f	388	if (sb == NULL)
1da177e4	389	return -EIO;
1da177e4 LT	390
1da177e4 LT	391	cifs_sb = CIFS_SB(sb);
79a58d1f	392	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
ea4c07d7 SF	393	return -EOPNOTSUPP;
ea4c07d7 SF	394
7ffec372 JL	395	tlink = cifs_sb_tlink(cifs_sb);
	396	if (IS_ERR(tlink))
	397	return PTR_ERR(tlink);
	398	pTcon = tlink_tcon(tlink);
	399
6d5786a3	400	xid = get_xid();
ea4c07d7	401
1da177e4	402	full_path = build_path_from_dentry(direntry);
79a58d1f	403	if (full_path == NULL) {
0f3bc09e	404	rc = -ENOMEM;
7ffec372	405	goto list_ea_exit;
1da177e4 LT	406	}
	407	/* return dos attributes as pseudo xattr */
	408	/* return alt name if available as pseudo attr */
	409
	410	/* if proc/fs/cifs/streamstoxattr is set then
79a58d1f	411	search server for EAs or streams to
1da177e4	412	returns as xattrs */
1da177e4	413
666753c3 SF	414	if (pTcon->ses->server->ops->query_all_EAs)
	415	rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
	416	full_path, NULL, data, buf_size,
	417	cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
	418	CIFS_MOUNT_MAP_SPECIAL_CHR);
7ffec372	419	list_ea_exit:
f99d49ad	420	kfree(full_path);
6d5786a3	421	free_xid(xid);
7ffec372	422	cifs_put_tlink(tlink);
1da177e4 LT	423	#endif
	424	return rc;
	425	}