[mirror_ubuntu-focal-kernel.git] / fs / nfsd / nfs2acl.c

/*
 * Process version 2 NFSACL requests.
 *
 * Copyright (C) 2002-2003 Andreas Gruenbacher <agruen@suse.de>
 */

#include "nfsd.h"
/* FIXME: nfsacl.h is a broken header */
#include <linux/nfsacl.h>
#include <linux/gfp.h>
#include "cache.h"
#include "xdr3.h"
#include "vfs.h"

#define NFSDDBG_FACILITY		NFSDDBG_PROC
#define RETURN_STATUS(st)	{ resp->status = (st); return (st); }

/*
 * NULL call.
 */
static __be32
nfsacld_proc_null(struct svc_rqst *rqstp)
{
	return nfs_ok;
}

/*
 * Get the Access and/or Default ACL of a file.
 */
static __be32 nfsacld_proc_getacl(struct svc_rqst *rqstp)
{
	struct nfsd3_getaclargs *argp = rqstp->rq_argp;
	struct nfsd3_getaclres *resp = rqstp->rq_resp;
	struct posix_acl *acl;
	struct inode *inode;
	svc_fh *fh;
	__be32 nfserr = 0;

	dprintk("nfsd: GETACL(2acl)   %s\n", SVCFH_fmt(&argp->fh));

	fh = fh_copy(&resp->fh, &argp->fh);
	nfserr = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_NOP);
	if (nfserr)
		RETURN_STATUS(nfserr);

	inode = d_inode(fh->fh_dentry);

	if (argp->mask & ~NFS_ACL_MASK)
		RETURN_STATUS(nfserr_inval);
	resp->mask = argp->mask;

	nfserr = fh_getattr(fh, &resp->stat);
	if (nfserr)
		RETURN_STATUS(nfserr);

	if (resp->mask & (NFS_ACL|NFS_ACLCNT)) {
		acl = get_acl(inode, ACL_TYPE_ACCESS);
		if (acl == NULL) {
			/* Solaris returns the inode's minimum ACL. */
			acl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
		}
		if (IS_ERR(acl)) {
			nfserr = nfserrno(PTR_ERR(acl));
			goto fail;
		}
		resp->acl_access = acl;
	}
	if (resp->mask & (NFS_DFACL|NFS_DFACLCNT)) {
		/* Check how Solaris handles requests for the Default ACL
		   of a non-directory! */
		acl = get_acl(inode, ACL_TYPE_DEFAULT);
		if (IS_ERR(acl)) {
			nfserr = nfserrno(PTR_ERR(acl));
			goto fail;
		}
		resp->acl_default = acl;
	}

	/* resp->acl_{access,default} are released in nfssvc_release_getacl. */
	RETURN_STATUS(0);

fail:
	posix_acl_release(resp->acl_access);
	posix_acl_release(resp->acl_default);
	RETURN_STATUS(nfserr);
}

/*
 * Set the Access and/or Default ACL of a file.
 */
static __be32 nfsacld_proc_setacl(struct svc_rqst *rqstp)
{
	struct nfsd3_setaclargs *argp = rqstp->rq_argp;
	struct nfsd_attrstat *resp = rqstp->rq_resp;
	struct inode *inode;
	svc_fh *fh;
	__be32 nfserr = 0;
	int error;

	dprintk("nfsd: SETACL(2acl)   %s\n", SVCFH_fmt(&argp->fh));

	fh = fh_copy(&resp->fh, &argp->fh);
	nfserr = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_SATTR);
	if (nfserr)
		goto out;

	inode = d_inode(fh->fh_dentry);

	error = fh_want_write(fh);
	if (error)
		goto out_errno;

	fh_lock(fh);

	error = set_posix_acl(inode, ACL_TYPE_ACCESS, argp->acl_access);
	if (error)
		goto out_drop_lock;
	error = set_posix_acl(inode, ACL_TYPE_DEFAULT, argp->acl_default);
	if (error)
		goto out_drop_lock;

	fh_unlock(fh);

	fh_drop_write(fh);

	nfserr = fh_getattr(fh, &resp->stat);

out:
	/* argp->acl_{access,default} may have been allocated in
	   nfssvc_decode_setaclargs. */
	posix_acl_release(argp->acl_access);
	posix_acl_release(argp->acl_default);
	return nfserr;
out_drop_lock:
	fh_unlock(fh);
	fh_drop_write(fh);
out_errno:
	nfserr = nfserrno(error);
	goto out;
}

/*
 * Check file attributes
 */
static __be32 nfsacld_proc_getattr(struct svc_rqst *rqstp)
{
	struct nfsd_fhandle *argp = rqstp->rq_argp;
	struct nfsd_attrstat *resp = rqstp->rq_resp;
	__be32 nfserr;
	dprintk("nfsd: GETATTR  %s\n", SVCFH_fmt(&argp->fh));

	fh_copy(&resp->fh, &argp->fh);
	nfserr = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_NOP);
	if (nfserr)
		return nfserr;
	nfserr = fh_getattr(&resp->fh, &resp->stat);
	return nfserr;
}

/*
 * Check file access
 */
static __be32 nfsacld_proc_access(struct svc_rqst *rqstp)
{
	struct nfsd3_accessargs *argp = rqstp->rq_argp;
	struct nfsd3_accessres *resp = rqstp->rq_resp;
	__be32 nfserr;

	dprintk("nfsd: ACCESS(2acl)   %s 0x%x\n",
			SVCFH_fmt(&argp->fh),
			argp->access);

	fh_copy(&resp->fh, &argp->fh);
	resp->access = argp->access;
	nfserr = nfsd_access(rqstp, &resp->fh, &resp->access, NULL);
	if (nfserr)
		return nfserr;
	nfserr = fh_getattr(&resp->fh, &resp->stat);
	return nfserr;
}

/*
 * XDR decode functions
 */
static int nfsaclsvc_decode_getaclargs(struct svc_rqst *rqstp, __be32 *p)
{
	struct nfsd3_getaclargs *argp = rqstp->rq_argp;

	p = nfs2svc_decode_fh(p, &argp->fh);
	if (!p)
		return 0;
	argp->mask = ntohl(*p); p++;

	return xdr_argsize_check(rqstp, p);
}


static int nfsaclsvc_decode_setaclargs(struct svc_rqst *rqstp, __be32 *p)
{
	struct nfsd3_setaclargs *argp = rqstp->rq_argp;
	struct kvec *head = rqstp->rq_arg.head;
	unsigned int base;
	int n;

	p = nfs2svc_decode_fh(p, &argp->fh);
	if (!p)
		return 0;
	argp->mask = ntohl(*p++);
	if (argp->mask & ~NFS_ACL_MASK ||
	    !xdr_argsize_check(rqstp, p))
		return 0;

	base = (char *)p - (char *)head->iov_base;
	n = nfsacl_decode(&rqstp->rq_arg, base, NULL,
			  (argp->mask & NFS_ACL) ?
			  &argp->acl_access : NULL);
	if (n > 0)
		n = nfsacl_decode(&rqstp->rq_arg, base + n, NULL,
				  (argp->mask & NFS_DFACL) ?
				  &argp->acl_default : NULL);
	return (n > 0);
}

static int nfsaclsvc_decode_fhandleargs(struct svc_rqst *rqstp, __be32 *p)
{
	struct nfsd_fhandle *argp = rqstp->rq_argp;

	p = nfs2svc_decode_fh(p, &argp->fh);
	if (!p)
		return 0;
	return xdr_argsize_check(rqstp, p);
}

static int nfsaclsvc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p)
{
	struct nfsd3_accessargs *argp = rqstp->rq_argp;

	p = nfs2svc_decode_fh(p, &argp->fh);
	if (!p)
		return 0;
	argp->access = ntohl(*p++);

	return xdr_argsize_check(rqstp, p);
}

/*
 * XDR encode functions
 */

/*
 * There must be an encoding function for void results so svc_process
 * will work properly.
 */
static int nfsaclsvc_encode_voidres(struct svc_rqst *rqstp, __be32 *p)
{
	return xdr_ressize_check(rqstp, p);
}

/* GETACL */
static int nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p)
{
	struct nfsd3_getaclres *resp = rqstp->rq_resp;
	struct dentry *dentry = resp->fh.fh_dentry;
	struct inode *inode;
	struct kvec *head = rqstp->rq_res.head;
	unsigned int base;
	int n;
	int w;

	/*
	 * Since this is version 2, the check for nfserr in
	 * nfsd_dispatch actually ensures the following cannot happen.
	 * However, it seems fragile to depend on that.
	 */
	if (dentry == NULL || d_really_is_negative(dentry))
		return 0;
	inode = d_inode(dentry);

	p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
	*p++ = htonl(resp->mask);
	if (!xdr_ressize_check(rqstp, p))
		return 0;
	base = (char *)p - (char *)head->iov_base;

	rqstp->rq_res.page_len = w = nfsacl_size(
		(resp->mask & NFS_ACL)   ? resp->acl_access  : NULL,
		(resp->mask & NFS_DFACL) ? resp->acl_default : NULL);
	while (w > 0) {
		if (!*(rqstp->rq_next_page++))
			return 0;
		w -= PAGE_SIZE;
	}

	n = nfsacl_encode(&rqstp->rq_res, base, inode,
			  resp->acl_access,
			  resp->mask & NFS_ACL, 0);
	if (n > 0)
		n = nfsacl_encode(&rqstp->rq_res, base + n, inode,
				  resp->acl_default,
				  resp->mask & NFS_DFACL,
				  NFS_ACL_DEFAULT);
	return (n > 0);
}

static int nfsaclsvc_encode_attrstatres(struct svc_rqst *rqstp, __be32 *p)
{
	struct nfsd_attrstat *resp = rqstp->rq_resp;

	p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
	return xdr_ressize_check(rqstp, p);
}

/* ACCESS */
static int nfsaclsvc_encode_accessres(struct svc_rqst *rqstp, __be32 *p)
{
	struct nfsd3_accessres *resp = rqstp->rq_resp;

	p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
	*p++ = htonl(resp->access);
	return xdr_ressize_check(rqstp, p);
}

/*
 * XDR release functions
 */
static void nfsaclsvc_release_getacl(struct svc_rqst *rqstp)
{
	struct nfsd3_getaclres *resp = rqstp->rq_resp;

	fh_put(&resp->fh);
	posix_acl_release(resp->acl_access);
	posix_acl_release(resp->acl_default);
}

static void nfsaclsvc_release_attrstat(struct svc_rqst *rqstp)
{
	struct nfsd_attrstat *resp = rqstp->rq_resp;

	fh_put(&resp->fh);
}

static void nfsaclsvc_release_access(struct svc_rqst *rqstp)
{
	struct nfsd3_accessres *resp = rqstp->rq_resp;

	fh_put(&resp->fh);
}

#define nfsaclsvc_decode_voidargs	NULL
#define nfsaclsvc_release_void		NULL
#define nfsd3_fhandleargs	nfsd_fhandle
#define nfsd3_attrstatres	nfsd_attrstat
#define nfsd3_voidres		nfsd3_voidargs
struct nfsd3_voidargs { int dummy; };

#define PROC(name, argt, rest, relt, cache, respsize)			\
{									\
	.pc_func	= nfsacld_proc_##name,				\
	.pc_decode	= nfsaclsvc_decode_##argt##args,		\
	.pc_encode	= nfsaclsvc_encode_##rest##res,			\
	.pc_release	= nfsaclsvc_release_##relt,	\
	.pc_argsize	= sizeof(struct nfsd3_##argt##args),		\
	.pc_ressize	= sizeof(struct nfsd3_##rest##res),		\
	.pc_cachetype	= cache,					\
	.pc_xdrressize	= respsize,					\
}

#define ST 1		/* status*/
#define AT 21		/* attributes */
#define pAT (1+AT)	/* post attributes - conditional */
#define ACL (1+NFS_ACL_MAX_ENTRIES*3)  /* Access Control List */

static const struct svc_procedure nfsd_acl_procedures2[] = {
  PROC(null,	void,		void,		void,	  RC_NOCACHE, ST),
  PROC(getacl,	getacl,		getacl,		getacl,	  RC_NOCACHE, ST+1+2*(1+ACL)),
  PROC(setacl,	setacl,		attrstat,	attrstat, RC_NOCACHE, ST+AT),
  PROC(getattr, fhandle,	attrstat,	attrstat, RC_NOCACHE, ST+AT),
  PROC(access,	access,		access,		access,   RC_NOCACHE, ST+AT+1),
};

static unsigned int nfsd_acl_count2[ARRAY_SIZE(nfsd_acl_procedures2)];
const struct svc_version nfsd_acl_version2 = {
	.vs_vers	= 2,
	.vs_nproc	= 5,
	.vs_proc	= nfsd_acl_procedures2,
	.vs_count	= nfsd_acl_count2,
	.vs_dispatch	= nfsd_dispatch,
	.vs_xdrsize	= NFS3_SVC_XDRSIZE,
};
Commit	Line	Data
a257cdd0	1	/*
a257cdd0 AG	2	* Process version 2 NFSACL requests.
	3	*
	4	* Copyright (C) 2002-2003 Andreas Gruenbacher <agruen@suse.de>
	5	*/
	6
9a74af21 BH	7	#include "nfsd.h"
9a74af21 BH	8	/* FIXME: nfsacl.h is a broken header */
a257cdd0	9	#include <linux/nfsacl.h>
5a0e3ad6	10	#include <linux/gfp.h>
9a74af21 BH	11	#include "cache.h"
9a74af21 BH	12	#include "xdr3.h"
0a3adade	13	#include "vfs.h"
a257cdd0 AG	14
	15	#define NFSDDBG_FACILITY NFSDDBG_PROC
	16	#define RETURN_STATUS(st) { resp->status = (st); return (st); }
	17
	18	/*
	19	* NULL call.
	20	*/
7111c66e	21	static __be32
a6beb732	22	nfsacld_proc_null(struct svc_rqst *rqstp)
a257cdd0 AG	23	{
	24	return nfs_ok;
	25	}
	26
	27	/*
	28	* Get the Access and/or Default ACL of a file.
	29	*/
a6beb732	30	static __be32 nfsacld_proc_getacl(struct svc_rqst *rqstp)
a257cdd0	31	{
a6beb732 CH	32	struct nfsd3_getaclargs *argp = rqstp->rq_argp;
a6beb732 CH	33	struct nfsd3_getaclres *resp = rqstp->rq_resp;
a257cdd0	34	struct posix_acl *acl;
4ac7249e CH	35	struct inode *inode;
4ac7249e CH	36	svc_fh *fh;
c4d987ba	37	__be32 nfserr = 0;
a257cdd0 AG	38
	39	dprintk("nfsd: GETACL(2acl) %s\n", SVCFH_fmt(&argp->fh));
	40
	41	fh = fh_copy(&resp->fh, &argp->fh);
8837abca MS	42	nfserr = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_NOP);
8837abca MS	43	if (nfserr)
ac8587dc	44	RETURN_STATUS(nfserr);
a257cdd0	45
2b0143b5	46	inode = d_inode(fh->fh_dentry);
4ac7249e	47
7b8f4586	48	if (argp->mask & ~NFS_ACL_MASK)
a257cdd0 AG	49	RETURN_STATUS(nfserr_inval);
	50	resp->mask = argp->mask;
	51
4f4a4fad BF	52	nfserr = fh_getattr(fh, &resp->stat);
4f4a4fad BF	53	if (nfserr)
7b8f4586	54	RETURN_STATUS(nfserr);
4f4a4fad	55
a257cdd0	56	if (resp->mask & (NFS_ACL\|NFS_ACLCNT)) {
4ac7249e	57	acl = get_acl(inode, ACL_TYPE_ACCESS);
a257cdd0 AG	58	if (acl == NULL) {
a257cdd0 AG	59	/* Solaris returns the inode's minimum ACL. */
a257cdd0 AG	60	acl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
a257cdd0 AG	61	}
35e634b8 KM	62	if (IS_ERR(acl)) {
	63	nfserr = nfserrno(PTR_ERR(acl));
	64	goto fail;
	65	}
a257cdd0 AG	66	resp->acl_access = acl;
	67	}
	68	if (resp->mask & (NFS_DFACL\|NFS_DFACLCNT)) {
	69	/* Check how Solaris handles requests for the Default ACL
	70	of a non-directory! */
4ac7249e	71	acl = get_acl(inode, ACL_TYPE_DEFAULT);
a257cdd0	72	if (IS_ERR(acl)) {
4ac7249e CH	73	nfserr = nfserrno(PTR_ERR(acl));
4ac7249e CH	74	goto fail;
a257cdd0 AG	75	}
	76	resp->acl_default = acl;
	77	}
	78
	79	/* resp->acl_{access,default} are released in nfssvc_release_getacl. */
	80	RETURN_STATUS(0);
	81
	82	fail:
	83	posix_acl_release(resp->acl_access);
	84	posix_acl_release(resp->acl_default);
	85	RETURN_STATUS(nfserr);
	86	}
	87
	88	/*
	89	* Set the Access and/or Default ACL of a file.
	90	*/
a6beb732	91	static __be32 nfsacld_proc_setacl(struct svc_rqst *rqstp)
a257cdd0	92	{
a6beb732 CH	93	struct nfsd3_setaclargs *argp = rqstp->rq_argp;
a6beb732 CH	94	struct nfsd_attrstat *resp = rqstp->rq_resp;
4ac7249e	95	struct inode *inode;
a257cdd0	96	svc_fh *fh;
c4d987ba	97	__be32 nfserr = 0;
4ac7249e	98	int error;
a257cdd0 AG	99
	100	dprintk("nfsd: SETACL(2acl) %s\n", SVCFH_fmt(&argp->fh));
	101
	102	fh = fh_copy(&resp->fh, &argp->fh);
8837abca	103	nfserr = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_SATTR);
4ac7249e CH	104	if (nfserr)
4ac7249e CH	105	goto out;
a257cdd0	106
2b0143b5	107	inode = d_inode(fh->fh_dentry);
a257cdd0	108
4ac7249e CH	109	error = fh_want_write(fh);
	110	if (error)
	111	goto out_errno;
	112
99965378 BH	113	fh_lock(fh);
	114
	115	error = set_posix_acl(inode, ACL_TYPE_ACCESS, argp->acl_access);
4ac7249e	116	if (error)
99965378 BH	117	goto out_drop_lock;
99965378 BH	118	error = set_posix_acl(inode, ACL_TYPE_DEFAULT, argp->acl_default);
4ac7249e	119	if (error)
99965378 BH	120	goto out_drop_lock;
	121
	122	fh_unlock(fh);
4ac7249e CH	123
	124	fh_drop_write(fh);
	125
	126	nfserr = fh_getattr(fh, &resp->stat);
	127
	128	out:
a257cdd0 AG	129	/* argp->acl_{access,default} may have been allocated in
	130	nfssvc_decode_setaclargs. */
	131	posix_acl_release(argp->acl_access);
	132	posix_acl_release(argp->acl_default);
	133	return nfserr;
99965378 BH	134	out_drop_lock:
99965378 BH	135	fh_unlock(fh);
4ac7249e CH	136	fh_drop_write(fh);
	137	out_errno:
	138	nfserr = nfserrno(error);
	139	goto out;
a257cdd0 AG	140	}
	141
	142	/*
	143	* Check file attributes
	144	*/
a6beb732	145	static __be32 nfsacld_proc_getattr(struct svc_rqst *rqstp)
a257cdd0	146	{
a6beb732 CH	147	struct nfsd_fhandle *argp = rqstp->rq_argp;
a6beb732 CH	148	struct nfsd_attrstat *resp = rqstp->rq_resp;
4f4a4fad	149	__be32 nfserr;
a257cdd0 AG	150	dprintk("nfsd: GETATTR %s\n", SVCFH_fmt(&argp->fh));
	151
	152	fh_copy(&resp->fh, &argp->fh);
4f4a4fad BF	153	nfserr = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_NOP);
	154	if (nfserr)
	155	return nfserr;
	156	nfserr = fh_getattr(&resp->fh, &resp->stat);
	157	return nfserr;
a257cdd0 AG	158	}
	159
	160	/*
	161	* Check file access
	162	*/
a6beb732	163	static __be32 nfsacld_proc_access(struct svc_rqst *rqstp)
a257cdd0	164	{
a6beb732 CH	165	struct nfsd3_accessargs *argp = rqstp->rq_argp;
a6beb732 CH	166	struct nfsd3_accessres *resp = rqstp->rq_resp;
c4d987ba	167	__be32 nfserr;
a257cdd0 AG	168
	169	dprintk("nfsd: ACCESS(2acl) %s 0x%x\n",
	170	SVCFH_fmt(&argp->fh),
	171	argp->access);
	172
	173	fh_copy(&resp->fh, &argp->fh);
	174	resp->access = argp->access;
	175	nfserr = nfsd_access(rqstp, &resp->fh, &resp->access, NULL);
4f4a4fad BF	176	if (nfserr)
	177	return nfserr;
	178	nfserr = fh_getattr(&resp->fh, &resp->stat);
a257cdd0 AG	179	return nfserr;
	180	}
	181
	182	/*
	183	* XDR decode functions
	184	*/
026fec7e	185	static int nfsaclsvc_decode_getaclargs(struct svc_rqst rqstp, __be32 p)
a257cdd0	186	{
026fec7e CH	187	struct nfsd3_getaclargs *argp = rqstp->rq_argp;
026fec7e CH	188
d40aa337 BT	189	p = nfs2svc_decode_fh(p, &argp->fh);
d40aa337 BT	190	if (!p)
a257cdd0 AG	191	return 0;
	192	argp->mask = ntohl(*p); p++;
	193
	194	return xdr_argsize_check(rqstp, p);
	195	}
	196
	197
026fec7e	198	static int nfsaclsvc_decode_setaclargs(struct svc_rqst rqstp, __be32 p)
a257cdd0	199	{
026fec7e	200	struct nfsd3_setaclargs *argp = rqstp->rq_argp;
a257cdd0 AG	201	struct kvec *head = rqstp->rq_arg.head;
	202	unsigned int base;
	203	int n;
	204
d40aa337 BT	205	p = nfs2svc_decode_fh(p, &argp->fh);
d40aa337 BT	206	if (!p)
a257cdd0 AG	207	return 0;
a257cdd0 AG	208	argp->mask = ntohl(*p++);
7b8f4586	209	if (argp->mask & ~NFS_ACL_MASK \|\|
a257cdd0 AG	210	!xdr_argsize_check(rqstp, p))
	211	return 0;
	212
	213	base = (char )p - (char )head->iov_base;
	214	n = nfsacl_decode(&rqstp->rq_arg, base, NULL,
	215	(argp->mask & NFS_ACL) ?
	216	&argp->acl_access : NULL);
	217	if (n > 0)
	218	n = nfsacl_decode(&rqstp->rq_arg, base + n, NULL,
	219	(argp->mask & NFS_DFACL) ?
	220	&argp->acl_default : NULL);
	221	return (n > 0);
	222	}
	223
026fec7e	224	static int nfsaclsvc_decode_fhandleargs(struct svc_rqst rqstp, __be32 p)
a257cdd0	225	{
026fec7e CH	226	struct nfsd_fhandle *argp = rqstp->rq_argp;
026fec7e CH	227
d40aa337 BT	228	p = nfs2svc_decode_fh(p, &argp->fh);
d40aa337 BT	229	if (!p)
a257cdd0 AG	230	return 0;
	231	return xdr_argsize_check(rqstp, p);
	232	}
	233
026fec7e	234	static int nfsaclsvc_decode_accessargs(struct svc_rqst rqstp, __be32 p)
a257cdd0	235	{
026fec7e CH	236	struct nfsd3_accessargs *argp = rqstp->rq_argp;
026fec7e CH	237
d40aa337 BT	238	p = nfs2svc_decode_fh(p, &argp->fh);
d40aa337 BT	239	if (!p)
a257cdd0 AG	240	return 0;
	241	argp->access = ntohl(*p++);
	242
	243	return xdr_argsize_check(rqstp, p);
	244	}
	245
	246	/*
	247	* XDR encode functions
	248	*/
	249
1b7e0403 PS	250	/*
	251	* There must be an encoding function for void results so svc_process
	252	* will work properly.
	253	*/
63f8de37	254	static int nfsaclsvc_encode_voidres(struct svc_rqst rqstp, __be32 p)
1b7e0403 PS	255	{
	256	return xdr_ressize_check(rqstp, p);
	257	}
	258
a257cdd0	259	/* GETACL */
63f8de37	260	static int nfsaclsvc_encode_getaclres(struct svc_rqst rqstp, __be32 p)
a257cdd0	261	{
63f8de37	262	struct nfsd3_getaclres *resp = rqstp->rq_resp;
a257cdd0	263	struct dentry *dentry = resp->fh.fh_dentry;
aefa89d1	264	struct inode *inode;
a257cdd0 AG	265	struct kvec *head = rqstp->rq_res.head;
	266	unsigned int base;
	267	int n;
cb65a5ba	268	int w;
a257cdd0	269
aefa89d1 P	270	/*
	271	* Since this is version 2, the check for nfserr in
	272	* nfsd_dispatch actually ensures the following cannot happen.
	273	* However, it seems fragile to depend on that.
	274	*/
2b0143b5	275	if (dentry == NULL \|\| d_really_is_negative(dentry))
a257cdd0	276	return 0;
2b0143b5	277	inode = d_inode(dentry);
a257cdd0	278
4f4a4fad	279	p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
a257cdd0 AG	280	*p++ = htonl(resp->mask);
	281	if (!xdr_ressize_check(rqstp, p))
	282	return 0;
	283	base = (char )p - (char )head->iov_base;
	284
cb65a5ba JJ	285	rqstp->rq_res.page_len = w = nfsacl_size(
	286	(resp->mask & NFS_ACL) ? resp->acl_access : NULL,
	287	(resp->mask & NFS_DFACL) ? resp->acl_default : NULL);
a257cdd0	288	while (w > 0) {
afc59400	289	if (!*(rqstp->rq_next_page++))
a257cdd0 AG	290	return 0;
	291	w -= PAGE_SIZE;
	292	}
	293
	294	n = nfsacl_encode(&rqstp->rq_res, base, inode,
	295	resp->acl_access,
	296	resp->mask & NFS_ACL, 0);
	297	if (n > 0)
	298	n = nfsacl_encode(&rqstp->rq_res, base + n, inode,
	299	resp->acl_default,
	300	resp->mask & NFS_DFACL,
	301	NFS_ACL_DEFAULT);
7b8f4586	302	return (n > 0);
a257cdd0 AG	303	}
a257cdd0 AG	304
63f8de37	305	static int nfsaclsvc_encode_attrstatres(struct svc_rqst rqstp, __be32 p)
a257cdd0	306	{
63f8de37 CH	307	struct nfsd_attrstat *resp = rqstp->rq_resp;
63f8de37 CH	308
4f4a4fad	309	p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
a257cdd0 AG	310	return xdr_ressize_check(rqstp, p);
	311	}
	312
	313	/* ACCESS */
63f8de37	314	static int nfsaclsvc_encode_accessres(struct svc_rqst rqstp, __be32 p)
a257cdd0	315	{
63f8de37 CH	316	struct nfsd3_accessres *resp = rqstp->rq_resp;
63f8de37 CH	317
4f4a4fad	318	p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
a257cdd0 AG	319	*p++ = htonl(resp->access);
	320	return xdr_ressize_check(rqstp, p);
	321	}
	322
	323	/*
	324	* XDR release functions
	325	*/
8537488b	326	static void nfsaclsvc_release_getacl(struct svc_rqst *rqstp)
a257cdd0	327	{
8537488b CH	328	struct nfsd3_getaclres *resp = rqstp->rq_resp;
8537488b CH	329
a257cdd0 AG	330	fh_put(&resp->fh);
	331	posix_acl_release(resp->acl_access);
	332	posix_acl_release(resp->acl_default);
a257cdd0 AG	333	}
a257cdd0 AG	334
8537488b	335	static void nfsaclsvc_release_attrstat(struct svc_rqst *rqstp)
a257cdd0	336	{
8537488b CH	337	struct nfsd_attrstat *resp = rqstp->rq_resp;
8537488b CH	338
a257cdd0	339	fh_put(&resp->fh);
a257cdd0 AG	340	}
a257cdd0 AG	341
8537488b	342	static void nfsaclsvc_release_access(struct svc_rqst *rqstp)
c9ce2283	343	{
8537488b CH	344	struct nfsd3_accessres *resp = rqstp->rq_resp;
	345
	346	fh_put(&resp->fh);
c9ce2283 GB	347	}
c9ce2283 GB	348
a257cdd0	349	#define nfsaclsvc_decode_voidargs NULL
a257cdd0 AG	350	#define nfsaclsvc_release_void NULL
	351	#define nfsd3_fhandleargs nfsd_fhandle
	352	#define nfsd3_attrstatres nfsd_attrstat
	353	#define nfsd3_voidres nfsd3_voidargs
	354	struct nfsd3_voidargs { int dummy; };
	355
f7235b6b CH	356	#define PROC(name, argt, rest, relt, cache, respsize) \
f7235b6b CH	357	{ \
a6beb732	358	.pc_func = nfsacld_proc_##name, \
026fec7e	359	.pc_decode = nfsaclsvc_decode_##argt##args, \
63f8de37	360	.pc_encode = nfsaclsvc_encode_##rest##res, \
8537488b	361	.pc_release = nfsaclsvc_release_##relt, \
f7235b6b CH	362	.pc_argsize = sizeof(struct nfsd3_##argt##args), \
	363	.pc_ressize = sizeof(struct nfsd3_##rest##res), \
	364	.pc_cachetype = cache, \
	365	.pc_xdrressize = respsize, \
	366	}
a257cdd0 AG	367
	368	#define ST 1 /* status*/
	369	#define AT 21 /* attributes */
	370	#define pAT (1+AT) /* post attributes - conditional */
	371	#define ACL (1+NFS_ACL_MAX_ENTRIES3) / Access Control List */
	372
860bda29	373	static const struct svc_procedure nfsd_acl_procedures2[] = {
a257cdd0 AG	374	PROC(null, void, void, void, RC_NOCACHE, ST),
a257cdd0 AG	375	PROC(getacl, getacl, getacl, getacl, RC_NOCACHE, ST+1+2*(1+ACL)),
c9ce2283 GB	376	PROC(setacl, setacl, attrstat, attrstat, RC_NOCACHE, ST+AT),
	377	PROC(getattr, fhandle, attrstat, attrstat, RC_NOCACHE, ST+AT),
	378	PROC(access, access, access, access, RC_NOCACHE, ST+AT+1),
a257cdd0 AG	379	};
a257cdd0 AG	380
7fd38af9	381	static unsigned int nfsd_acl_count2[ARRAY_SIZE(nfsd_acl_procedures2)];
e9679189 CH	382	const struct svc_version nfsd_acl_version2 = {
	383	.vs_vers = 2,
	384	.vs_nproc = 5,
	385	.vs_proc = nfsd_acl_procedures2,
	386	.vs_count = nfsd_acl_count2,
	387	.vs_dispatch = nfsd_dispatch,
	388	.vs_xdrsize = NFS3_SVC_XDRSIZE,
a257cdd0	389	};