/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License, Version 1.0 only

 * (the "License").  You may not use this file except in compliance

 * with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/param.h>

#include <sys/types.h>

#include <sys/systm.h>

#include <sys/cred.h>

#include <sys/buf.h>

#include <sys/vfs.h>

#include <sys/vnode.h>

#include <sys/uio.h>

#include <sys/errno.h>

#include <sys/sysmacros.h>

#include <sys/statvfs.h>

#include <sys/kmem.h>

#include <sys/dirent.h>

#include <rpc/types.h>

#include <rpc/auth.h>

#include <rpc/rpcsec_gss.h>

#include <rpc/svc.h>

#include <sys/strsubr.h>

#include <sys/strsun.h>

#include <sys/sdt.h>

#include <nfs/nfs.h>

#include <nfs/export.h>

#include <nfs/nfs4.h>

/*

 * RFS4_MINLEN_ENTRY4: XDR-encoded size of smallest possible dirent.

 *	This is used to return NFS4ERR_TOOSMALL when clients specify

 *	maxcount that isn't large enough to hold the smallest possible

 *	XDR encoded dirent.

 *

 *	    sizeof cookie (8 bytes) +

 *	    sizeof name_len (4 bytes) +

 *	    sizeof smallest (padded) name (4 bytes) +

 *	    sizeof bitmap4_len (12 bytes) +   NOTE: we always encode len=2 bm4

 *	    sizeof attrlist4_len (4 bytes) +

 *	    sizeof next boolean (4 bytes)

 *

 * RFS4_MINLEN_RDDIR4: XDR-encoded size of READDIR op reply containing

 * the smallest possible entry4 (assumes no attrs requested).

 *	sizeof nfsstat4 (4 bytes) +

 *	sizeof verifier4 (8 bytes) +

 *	sizeof entsecond_to_ry4list bool (4 bytes) +

 *	sizeof entry4 	(36 bytes) +

 *	sizeof eof bool  (4 bytes)

 *

 * RFS4_MINLEN_RDDIR_BUF: minimum length of buffer server will provide to

 *	VOP_READDIR.  Its value is the size of the maximum possible dirent

 *	for solaris.  The DIRENT64_RECLEN macro returns	the size of dirent

 *	required for a given name length.  MAXNAMELEN is the maximum

 *	filename length allowed in Solaris.  The first two DIRENT64_RECLEN()

 *	macros are to allow for . and .. entries -- just a minor tweak to try

 *	and guarantee that buffer we give to VOP_READDIR will be large enough

 *	to hold ., .., and the largest possible solaris dirent64.

 */

#define	RFS4_MINLEN_ENTRY4 36

#define	RFS4_MINLEN_RDDIR4 (4 + NFS4_VERIFIER_SIZE + 4 + RFS4_MINLEN_ENTRY4 + 4)

#define	RFS4_MINLEN_RDDIR_BUF \

	(DIRENT64_RECLEN(1) + DIRENT64_RECLEN(2) + DIRENT64_RECLEN(MAXNAMELEN))

#ifdef	nextdp

#undef nextdp

#endif

#define	nextdp(dp)	((struct dirent64 *)((char *)(dp) + (dp)->d_reclen))

verifier4	Readdir4verf = 0x0;

static nfs_ftype4 vt_to_nf4[] = {

	0, NF4REG, NF4DIR, NF4BLK, NF4CHR, NF4LNK, NF4FIFO, 0, 0, NF4SOCK, 0

};

int

nfs4_readdir_getvp(vnode_t *dvp, char *d_name, vnode_t **vpp,

		struct exportinfo **exi, struct svc_req *req,

		struct compound_state *cs, int expseudo)

{

	int error;

	int ismntpt;

	fid_t fid;

	vnode_t *vp, *pre_tvp;

	nfsstat4 status;

	struct exportinfo *newexi, *saveexi;

	cred_t *scr;

	*vpp = vp = NULL;

	if (error = VOP_LOOKUP(dvp, d_name, &vp, NULL, 0, NULL, cs->cr))

		return (error);

	/* Is this object mounted upon? */

	ismntpt = vn_ismntpt(vp);

	/*

	 * Nothing more to do if object is not a mount point or

	 * a possible LOFS shadow of an LOFS mount (which won't

	 * have v_vfsmountedhere set)

	 */

	if (ismntpt == 0 && dvp->v_vfsp == vp->v_vfsp && expseudo == 0) {

		*vpp = vp;

		return (0);

	}

	if (ismntpt) {

		/*

		 * Something is mounted here. Traverse and manage the

		 * namespace

		 */

		pre_tvp = vp;

		VN_HOLD(pre_tvp);

		if ((error = traverse(&vp)) != 0) {

			VN_RELE(pre_tvp);

			return (error);

		}

	}

	bzero(&fid, sizeof (fid));

	fid.fid_len = MAXFIDSZ;

	/*

	 * If VOP_FID not supported by underlying fs (mntfs, procfs,

	 * etc.), then return attrs for stub instead of VROOT object.

	 * If it fails for any other reason, then return the error.

	 */

	if (error = VOP_FID(vp, &fid)) {

		if (ismntpt == 0) {

			VN_RELE(vp);

			return (error);

		}

		if (error != ENOSYS && error != ENOTSUP) {

			VN_RELE(vp);

			VN_RELE(pre_tvp);

			return (error);

		}

		/* go back to vnode that is "under" mount */

		VN_RELE(vp);

		*vpp = pre_tvp;

		return (0);

	}

	newexi = checkexport4(&vp->v_vfsp->vfs_fsid, &fid, vp);

	if (newexi == NULL) {

		if (ismntpt == 0) {

			*vpp = vp;

		} else {

			VN_RELE(vp);

			*vpp = pre_tvp;

		}

		return (0);

	}

	if (ismntpt)

		VN_RELE(pre_tvp);

	/* Save the exi and present the new one to checkauth4() */

	saveexi = cs->exi;

	cs->exi = newexi;

	/* Get the right cred like lookup does */

	scr = cs->cr;

	cs->cr = crdup(cs->basecr);

	status = call_checkauth4(cs, req);

	crfree(cs->cr);

	cs->cr = scr;

	cs->exi = saveexi;

	/* Reset what call_checkauth4() may have set */

	*cs->statusp = NFS4_OK;

	if (status != NFS4_OK) {

		VN_RELE(vp);

		if (status == NFS4ERR_DELAY)

			status = NFS4ERR_ACCESS;

		return (status);

	}

	*vpp = vp;

	*exi = newexi;

	return (0);

}

/* This is the set of pathconf data for vfs */

typedef struct {

	uint64_t maxfilesize;

	uint32_t maxlink;

	uint32_t maxname;

} rfs4_pc_encode_t;

static int

rfs4_get_pc_encode(vnode_t *vp, rfs4_pc_encode_t *pce, bitmap4 ar, cred_t *cr)

{

	int error;

	ulong_t pc_val;

	pce->maxfilesize = 0;

	pce->maxlink = 0;

	pce->maxname = 0;

	if (ar & FATTR4_MAXFILESIZE_MASK) {

		/* Maximum File Size */

		if (error = VOP_PATHCONF(vp, _PC_FILESIZEBITS, &pc_val, cr))

			return (error);

		if (pc_val >= (sizeof (uint64_t) * 8))

			pce->maxfilesize = UINT64_MAX;

		else

			pce->maxfilesize = ((1LL << pc_val) - 1);

	}

	if (ar & FATTR4_MAXLINK_MASK) {

		/* Maximum Link Count */

		if (error = VOP_PATHCONF(vp, _PC_LINK_MAX, &pc_val, cr))

			return (error);

		pce->maxlink = pc_val;

	}

	if (ar & FATTR4_MAXNAME_MASK) {

		/* Maximum Name Length */

		if (error = VOP_PATHCONF(vp, _PC_NAME_MAX, &pc_val, cr))

			return (error);

		pce->maxname = pc_val;

	}

	return (0);

}

/* This is the set of statvfs data that is ready for encoding */

typedef struct {

	uint64_t space_avail;

	uint64_t space_free;

	uint64_t space_total;

	u_longlong_t fa;

	u_longlong_t ff;

	u_longlong_t ft;

} rfs4_sb_encode_t;

static int

rfs4_get_sb_encode(vfs_t *vfsp, rfs4_sb_encode_t *psbe)

{

	int error;

	struct statvfs64 sb;

	/* Grab the per filesystem info */

	if (error = VFS_STATVFS(vfsp, &sb)) {

		return (error);

	}

	/* Calculate space available */

	if (sb.f_bavail != (fsblkcnt64_t)-1) {

		psbe->space_avail =

			(fattr4_space_avail) sb.f_frsize *

			(fattr4_space_avail) sb.f_bavail;

	} else {

		psbe->space_avail =

			(fattr4_space_avail) sb.f_bavail;

	}

	/* Calculate space free */

	if (sb.f_bfree != (fsblkcnt64_t)-1) {

		psbe->space_free =

			(fattr4_space_free) sb.f_frsize *

			(fattr4_space_free) sb.f_bfree;

	} else {

		psbe->space_free =

			(fattr4_space_free) sb.f_bfree;

	}

	/* Calculate space total */

	if (sb.f_blocks != (fsblkcnt64_t)-1) {

		psbe->space_total =

			(fattr4_space_total) sb.f_frsize *

			(fattr4_space_total) sb.f_blocks;

	} else {

		psbe->space_total =

			(fattr4_space_total) sb.f_blocks;

	}

	/* For use later on attr encode */

	psbe->fa = sb.f_favail;

	psbe->ff = sb.f_ffree;

	psbe->ft = sb.f_files;

	return (0);

}

/*

 * Macros to handle if we have don't have enough space for the requested

 * attributes and this is the first entry and the

 * requested attributes are more than the minimal useful

 * set, reset the attributes to the minimal set and

 * retry the encoding. If the client has asked for both

 * mounted_on_fileid and fileid, prefer mounted_on_fileid.

 */

#define	MINIMAL_RD_ATTRS						\

	(FATTR4_MOUNTED_ON_FILEID_MASK|					\

	FATTR4_FILEID_MASK|						\

	FATTR4_RDATTR_ERROR_MASK)

#define	MINIMIZE_ATTR_MASK(m) {						\

	if ((m) & FATTR4_MOUNTED_ON_FILEID_MASK)			\

	    (m) &= FATTR4_RDATTR_ERROR_MASK|FATTR4_MOUNTED_ON_FILEID_MASK;\

	else								\

	    (m) &= FATTR4_RDATTR_ERROR_MASK|FATTR4_FILEID_MASK;		\

}

#define	IS_MIN_ATTR_MASK(m)	(((m) & ~MINIMAL_RD_ATTRS) == 0)

/*

 * If readdir only needs to return FILEID, we can take it from the

 * dirent struct and save doing the lookup.

 */

/* ARGSUSED */

void

rfs4_op_readdir(nfs_argop4 *argop, nfs_resop4 *resop,

	struct svc_req *req, struct compound_state *cs)

{

	READDIR4args *args = &argop->nfs_argop4_u.opreaddir;

	READDIR4res *resp = &resop->nfs_resop4_u.opreaddir;

	struct exportinfo *newexi = NULL;

	int error;

	mblk_t *mp;

	uint_t mpcount;

	int alloc_err = 0;

	vnode_t *dvp = cs->vp;

	vnode_t *vp;

	vattr_t va;

	struct dirent64 *dp;

	rfs4_sb_encode_t dsbe, sbe;

	int vfs_different;

	int rddir_data_len, rddir_result_size;

	caddr_t rddir_data;

	offset_t rddir_next_offset;

	int dircount;

	int no_space;

	int iseofdir;

	uint_t eof;

	struct iovec iov;

	struct uio uio;

	int tsize;

	int check_visible;

	int expseudo = 0;

	uint32_t *ptr, *ptr_redzone;

	uint32_t *beginning_ptr;

	uint32_t *lastentry_ptr;

	uint32_t *attrmask_ptr;

	uint32_t *attr_offset_ptr;

	uint32_t attr_length;

	uint32_t rndup;

	uint32_t namelen;

	uint32_t rddirattr_error = 0;

	int nents;

	bitmap4 ar = args->attr_request & NFS4_SRV_RDDIR_SUPPORTED_ATTRS;

	bitmap4 ae;

	rfs4_pc_encode_t dpce, pce;

	ulong_t pc_val;

	uint64_t maxread;

	uint64_t maxwrite;

	uint_t true = TRUE;

	uint_t false = FALSE;

	uid_t lastuid;

	gid_t lastgid;

	int lu_set, lg_set;

	utf8string owner, group;

	int owner_error, group_error;

	lu_set = lg_set = 0;

	owner.utf8string_len = group.utf8string_len = 0;

	owner.utf8string_val = group.utf8string_val = NULL;

	resp->mblk = NULL;

	/* Maximum read and write size */

	maxread = maxwrite = rfs4_tsize(req);

	if (dvp == NULL) {

		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;

		return;

	}

	/*

	 * If there is an unshared filesystem mounted on this vnode,

	 * do not allow readdir in this directory.

	 */

	if (vn_ismntpt(dvp)) {

		*cs->statusp = resp->status = NFS4ERR_ACCESS;

		return;

	}

	if (dvp->v_type != VDIR) {

		*cs->statusp = resp->status = NFS4ERR_NOTDIR;

		return;

	}

	if (args->maxcount <= RFS4_MINLEN_RDDIR4) {

		*cs->statusp = resp->status = NFS4ERR_TOOSMALL;

		return;

	}

	/*

	 * If write-only attrs are requested, then fail the readdir op

	 */

	if (args->attr_request &

	    (FATTR4_TIME_MODIFY_SET_MASK | FATTR4_TIME_ACCESS_SET_MASK)) {

		*cs->statusp = resp->status = NFS4ERR_INVAL;

		return;

	}

	error = VOP_ACCESS(dvp, VREAD, 0, cs->cr);

	if (error) {

		*cs->statusp = resp->status = puterrno4(error);

		return;

	}

	if (args->cookieverf != Readdir4verf) {

		*cs->statusp = resp->status = NFS4ERR_NOT_SAME;

		return;

	}

	/* Is there pseudo-fs work that is needed for this readdir? */

	check_visible = PSEUDO(cs->exi) ||

		! is_exported_sec(cs->nfsflavor, cs->exi) ||

		cs->access & CS_ACCESS_LIMITED;

	/* Check the requested attributes and only do the work if needed */

	if (ar & (FATTR4_MAXFILESIZE_MASK |

		FATTR4_MAXLINK_MASK |

		FATTR4_MAXNAME_MASK)) {

		if (error = rfs4_get_pc_encode(cs->vp, &dpce, ar, cs->cr)) {

			*cs->statusp = resp->status = puterrno4(error);

			return;

		}

		pce = dpce;

	}

	/* If there is statvfs data requested, pick it up once */

	if (ar &

	    (FATTR4_FILES_AVAIL_MASK |

	    FATTR4_FILES_FREE_MASK |

	    FATTR4_FILES_TOTAL_MASK |

	    FATTR4_FILES_AVAIL_MASK |

	    FATTR4_FILES_FREE_MASK |

	    FATTR4_FILES_TOTAL_MASK)) {

		if (error = rfs4_get_sb_encode(dvp->v_vfsp, &dsbe)) {

			*cs->statusp = resp->status = puterrno4(error);

			return;

		}

		sbe = dsbe;

	}

	/*

	 * Max transfer size of the server is the absolute limite.

	 * If the client has decided to max out with something really

	 * tiny, then return toosmall.  Otherwise, move forward and

	 * see if a single entry can be encoded.

	 */

	tsize = rfs4_tsize(req);

	if (args->maxcount > tsize)

		args->maxcount = tsize;

	else if (args->maxcount < RFS4_MINLEN_RDDIR_BUF) {

		if (args->maxcount < RFS4_MINLEN_ENTRY4) {

			*cs->statusp = resp->status = NFS4ERR_TOOSMALL;

			return;

		}

	}

	/*

	 * How large should the mblk be for outgoing encoding.

	 */

	if (args->maxcount < MAXBSIZE)

		mpcount = MAXBSIZE;

	else

		mpcount = args->maxcount;

	/*

	 * mp will contain the data to be sent out in the readdir reply.

	 * It will be freed after the reply has been sent.

	 * Let's roundup the data to a BYTES_PER_XDR_UNIX multiple,

	 * so that the call to xdrmblk_putmblk() never fails.

	 */

	mp = allocb(RNDUP(mpcount), BPRI_MED);

	if (mp == NULL) {

		/*

		 * The allocation of the client's requested size has

		 * failed.  It may be that the size is too large for

		 * current system utilization; step down to a "common"

		 * size and wait for the allocation to occur.

		 */

		if (mpcount > MAXBSIZE)

			args->maxcount = mpcount = MAXBSIZE;

		mp = allocb_wait(RNDUP(mpcount), BPRI_MED,