/*

 * CDDL HEADER START

 *

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

 * Common Development and Distribution License (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 2006 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */

/* All Rights Reserved */

#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 <sys/cmn_err.h>

#include <sys/debug.h>

#include <sys/systeminfo.h>

#include <sys/flock.h>

#include <sys/nbmlock.h>

#include <sys/policy.h>

#include <rpc/types.h>

#include <rpc/auth.h>

#include <rpc/svc.h>

#include <nfs/nfs.h>

#include <nfs/export.h>

#include <sys/strsubr.h>

/*

 * These are the interface routines for the server side of the

 * Network File System.  See the NFS version 3 protocol specification

 * for a description of this interface.

 */

#ifdef DEBUG

int rfs3_do_pre_op_attr = 1;

int rfs3_do_post_op_attr = 1;

int rfs3_do_post_op_fh3 = 1;

#endif

static writeverf3 write3verf;

static int	sattr3_to_vattr(sattr3 *, struct vattr *);

static int	vattr_to_fattr3(struct vattr *, fattr3 *);

static int	vattr_to_wcc_attr(struct vattr *, wcc_attr *);

static void	vattr_to_pre_op_attr(struct vattr *, pre_op_attr *);

static void	vattr_to_wcc_data(struct vattr *, struct vattr *, wcc_data *);

/* ARGSUSED */

void

rfs3_getattr(GETATTR3args *args, GETATTR3res *resp, struct exportinfo *exi,

	struct svc_req *req, cred_t *cr)

{

	int error;

	vnode_t *vp;

	struct vattr va;

	vp = nfs3_fhtovp(&args->object, exi);

	if (vp == NULL) {

		error = ESTALE;

		goto out;

	}

	va.va_mask = AT_ALL;

	error = rfs4_delegated_getattr(vp, &va, 0, cr);

	VN_RELE(vp);

	if (!error) {

		/* overflow error if time or size is out of range */

		error = vattr_to_fattr3(&va, &resp->resok.obj_attributes);

		if (error)

			goto out;

		resp->status = NFS3_OK;

		return;

	}

out:

	if (curthread->t_flag & T_WOULDBLOCK) {

		curthread->t_flag &= ~T_WOULDBLOCK;

		resp->status = NFS3ERR_JUKEBOX;

	} else

		resp->status = puterrno3(error);

}

void *

rfs3_getattr_getfh(GETATTR3args *args)

{

	return (&args->object);

}

void

rfs3_setattr(SETATTR3args *args, SETATTR3res *resp, struct exportinfo *exi,

	struct svc_req *req, cred_t *cr)

{

	int error;

	vnode_t *vp;

	struct vattr *bvap;

	struct vattr bva;

	struct vattr *avap;

	struct vattr ava;

	int flag;

	int in_crit = 0;

	struct flock64 bf;

	bvap = NULL;

	avap = NULL;

	vp = nfs3_fhtovp(&args->object, exi);

	if (vp == NULL) {

		error = ESTALE;

		goto out;

	}

	error = sattr3_to_vattr(&args->new_attributes, &ava);

	if (error)

		goto out;

	/*

	 * We need to specially handle size changes because of

	 * possible conflicting NBMAND locks. Get into critical

	 * region before VOP_GETATTR, so the size attribute is

	 * valid when checking conflicts.

	 *

	 * Also, check to see if the v4 side of the server has

	 * delegated this file.  If so, then we return JUKEBOX to

	 * allow the client to retrasmit its request.

	 */

	if (vp->v_type == VREG && (ava.va_mask & AT_SIZE)) {

		if (rfs4_check_delegated(FWRITE, vp, TRUE)) {

			resp->status = NFS3ERR_JUKEBOX;

			goto out1;

		}

		if (nbl_need_check(vp)) {

			nbl_start_crit(vp, RW_READER);

			in_crit = 1;

		}

	}

	bva.va_mask = AT_ALL;

	error = rfs4_delegated_getattr(vp, &bva, 0, cr);

	/*

	 * If we can't get the attributes, then we can't do the

	 * right access checking.  So, we'll fail the request.

	 */

	if (error)

		goto out;

#ifdef DEBUG

	if (rfs3_do_pre_op_attr)

		bvap = &bva;

#else

	bvap = &bva;

#endif

	if (rdonly(exi, req) || vn_is_readonly(vp)) {

		resp->status = NFS3ERR_ROFS;

		goto out1;

	}

	if (args->guard.check &&

	    (args->guard.obj_ctime.seconds != bva.va_ctime.tv_sec ||

	    args->guard.obj_ctime.nseconds != bva.va_ctime.tv_nsec)) {

		resp->status = NFS3ERR_NOT_SYNC;

		goto out1;

	}

	if (args->new_attributes.mtime.set_it == SET_TO_CLIENT_TIME)

		flag = ATTR_UTIME;

	else

		flag = 0;

	/*

	 * If the filesystem is exported with nosuid, then mask off

	 * the setuid and setgid bits.

	 */

	if ((ava.va_mask & AT_MODE) && vp->v_type == VREG &&

	    (exi->exi_export.ex_flags & EX_NOSUID))

		ava.va_mode &= ~(VSUID | VSGID);

	/*

	 * We need to specially handle size changes because it is

	 * possible for the client to create a file with modes

	 * which indicate read-only, but with the file opened for

	 * writing.  If the client then tries to set the size of

	 * the file, then the normal access checking done in

	 * VOP_SETATTR would prevent the client from doing so,

	 * although it should be legal for it to do so.  To get

	 * around this, we do the access checking for ourselves

	 * and then use VOP_SPACE which doesn't do the access

	 * checking which VOP_SETATTR does. VOP_SPACE can only

	 * operate on VREG files, let VOP_SETATTR handle the other

	 * extremely rare cases.

	 * Also the client should not be allowed to change the

	 * size of the file if there is a conflicting non-blocking

	 * mandatory lock in the region the change.

	 */

	if (vp->v_type == VREG && (ava.va_mask & AT_SIZE)) {

		if (in_crit) {

			u_offset_t offset;

			ssize_t length;

			if (ava.va_size < bva.va_size) {

				offset = ava.va_size;

				length = bva.va_size - ava.va_size;

			} else {

				offset = bva.va_size;

				length = ava.va_size - bva.va_size;

			}

			if (nbl_conflict(vp, NBL_WRITE, offset, length, 0)) {

				error = EACCES;

				goto out;

			}

		}

		if (crgetuid(cr) == bva.va_uid && ava.va_size != bva.va_size) {

			ava.va_mask &= ~AT_SIZE;

			bf.l_type = F_WRLCK;

			bf.l_whence = 0;

			bf.l_start = (off64_t)ava.va_size;

			bf.l_len = 0;

			bf.l_sysid = 0;

			bf.l_pid = 0;

			error = VOP_SPACE(vp, F_FREESP, &bf, FWRITE,

			    (offset_t)ava.va_size, cr, NULL);

		}

	}

	if (!error && ava.va_mask)

		error = VOP_SETATTR(vp, &ava, flag, cr, NULL);

#ifdef DEBUG

	if (rfs3_do_post_op_attr) {

		ava.va_mask = AT_ALL;

		avap = rfs4_delegated_getattr(vp, &ava, 0, cr) ? NULL : &ava;

	} else

		avap = NULL;

#else

	ava.va_mask = AT_ALL;

	avap = rfs4_delegated_getattr(vp, &ava, 0, cr) ? NULL : &ava;

#endif

	/*

	 * Force modified metadata out to stable storage.

	 */

	(void) VOP_FSYNC(vp, FNODSYNC, cr);

	if (error)

		goto out;

	if (in_crit)

		nbl_end_crit(vp);

	VN_RELE(vp);

	resp->status = NFS3_OK;

	vattr_to_wcc_data(bvap, avap, &resp->resok.obj_wcc);

	return;

out:

	if (curthread->t_flag & T_WOULDBLOCK) {

		curthread->t_flag &= ~T_WOULDBLOCK;

		resp->status = NFS3ERR_JUKEBOX;

	} else

		resp->status = puterrno3(error);

out1:

	if (vp != NULL) {

		if (in_crit)

			nbl_end_crit(vp);

		VN_RELE(vp);

	}

	vattr_to_wcc_data(bvap, avap, &resp->resfail.obj_wcc);

}

void *

rfs3_setattr_getfh(SETATTR3args *args)

{

	return (&args->object);

}

/* ARGSUSED */

void

rfs3_lookup(LOOKUP3args *args, LOOKUP3res *resp, struct exportinfo *exi,

	struct svc_req *req, cred_t *cr)

{

	int error;

	vnode_t *vp;

	vnode_t *dvp;

	struct vattr *vap;

	struct vattr va;

	struct vattr *dvap;

	struct vattr dva;

	nfs_fh3 *fhp;

	struct sec_ol sec = {0, 0};

	bool_t publicfh_flag = FALSE, auth_weak = FALSE;

	dvap = NULL;

	/*

	 * Allow lookups from the root - the default

	 * location of the public filehandle.

	 */

	if (exi != NULL && (exi->exi_export.ex_flags & EX_PUBLIC)) {

		dvp = rootdir;

		VN_HOLD(dvp);

	} else {

		dvp = nfs3_fhtovp(&args->what.dir, exi);

		if (dvp == NULL) {

			error = ESTALE;

			goto out;

		}

	}

#ifdef DEBUG

	if (rfs3_do_pre_op_attr) {

		dva.va_mask = AT_ALL;

		dvap = VOP_GETATTR(dvp, &dva, 0, cr) ? NULL : &dva;

	}

#else

	dva.va_mask = AT_ALL;

	dvap = VOP_GETATTR(dvp, &dva, 0, cr) ? NULL : &dva;

#endif

	if (args->what.name == nfs3nametoolong) {

		resp->status = NFS3ERR_NAMETOOLONG;

		goto out1;

	}

	if (args->what.name == NULL || *(args->what.name) == '\0') {

		resp->status = NFS3ERR_ACCES;

		goto out1;

	}

	fhp = &args->what.dir;

	if (strcmp(args->what.name, "..") == 0 &&

	    EQFID(&exi->exi_fid, FH3TOFIDP(fhp))) {

		resp->status = NFS3ERR_NOENT;

		goto out1;

	}

	/*

	 * If the public filehandle is used then allow

	 * a multi-component lookup

	 */

	if (PUBLIC_FH3(&args->what.dir)) {

		publicfh_flag = TRUE;

		error = rfs_publicfh_mclookup(args->what.name, dvp, cr, &vp,

					&exi, &sec);

		if (error && exi != NULL)

			exi_rele(exi);  /* See the comment below */

	} else {

		error = VOP_LOOKUP(dvp, args->what.name, &vp,

				NULL, 0, NULL, cr);

	}

#ifdef DEBUG

	if (rfs3_do_post_op_attr) {

		dva.va_mask = AT_ALL;

		dvap = VOP_GETATTR(dvp, &dva, 0, cr) ? NULL : &dva;

	} else

		dvap = NULL;

#else

	dva.va_mask = AT_ALL;

	dvap = VOP_GETATTR(dvp, &dva, 0, cr) ? NULL : &dva;

#endif

	if (error)

		goto out;

	if (sec.sec_flags & SEC_QUERY) {

		error = makefh3_ol(&resp->resok.object, exi, sec.sec_index);

	} else {

		error = makefh3(&resp->resok.object, vp, exi);

		if (!error && publicfh_flag && !chk_clnt_sec(exi, req))

			auth_weak = TRUE;

	}

	if (error) {

		VN_RELE(vp);

		goto out;

	}

	/*

	 * If publicfh_flag is true then we have called rfs_publicfh_mclookup

	 * and have obtained a new exportinfo in exi which needs to be

	 * released. Note the the original exportinfo pointed to by exi

	 * will be released by the caller, common_dispatch.

	 */

	if (publicfh_flag)

		exi_rele(exi);

	VN_RELE(dvp);

#ifdef DEBUG

	if (rfs3_do_post_op_attr) {

		va.va_mask = AT_ALL;

		vap = rfs4_delegated_getattr(vp, &va, 0, cr) ? NULL : &va;

	} else

		vap = NULL;

#else

	va.va_mask = AT_ALL;

	vap = rfs4_delegated_getattr(vp, &va, 0, cr) ? NULL : &va;

#endif

	VN_RELE(vp);

	resp->status = NFS3_OK;

	vattr_to_post_op_attr(vap, &resp->resok.obj_attributes);

	vattr_to_post_op_attr(dvap, &resp->resok.dir_attributes);

	/*

	 * If it's public fh, no 0x81, and client's flavor is

	 * invalid, set WebNFS status to WNFSERR_CLNT_FLAVOR now.

	 * Then set RPC status to AUTH_TOOWEAK in common_dispatch.

	 */

	if (auth_weak)

		resp->status = (enum nfsstat3)WNFSERR_CLNT_FLAVOR;

	return;

out:

	if (curthread->t_flag & T_WOULDBLOCK) {

		curthread->t_flag &= ~T_WOULDBLOCK;

		resp->status = NFS3ERR_JUKEBOX;

	} else

		resp->status = puterrno3(error);

out1:

	if (dvp != NULL)

		VN_RELE(dvp);

	vattr_to_post_op_attr(dvap, &resp->resfail.dir_attributes);

}

void *

rfs3_lookup_getfh(LOOKUP3args *args)

{

	return (&args->what.dir);

}

/* ARGSUSED */

void

rfs3_access(ACCESS3args *args, ACCESS3res *resp, struct exportinfo *exi,

	struct svc_req *req, cred_t *cr)

{

	int error;

	vnode_t *vp;

	struct vattr *vap;

	struct vattr va;

	int checkwriteperm;

	vap = NULL;

	vp = nfs3_fhtovp(&args->object, exi);

	if (vp == NULL) {

		error = ESTALE;

		goto out;

	}

	/*

	 * If the file system is exported read only, it is not appropriate

	 * to check write permissions for regular files and directories.

	 * Special files are interpreted by the client, so the underlying

	 * permissions are sent back to the client for interpretation.

	 */

	if (rdonly(exi, req) && (vp->v_type == VREG || vp->v_type == VDIR))

		checkwriteperm = 0;

	else

		checkwriteperm = 1;

	/*

	 * We need the mode so that we can correctly determine access

	 * permissions relative to a mandatory lock file.  Access to

	 * mandatory lock files is denied on the server, so it might

	 * as well be reflected to the server during the open.

	 */

	va.va_mask = AT_MODE;

	error = VOP_GETATTR(vp, &va, 0, cr);

	if (error)

		goto out;

#ifdef DEBUG

	if (rfs3_do_post_op_attr)

		vap = &va;

#else

	vap = &va;

#endif

	resp->resok.access = 0;

	if (args->access & ACCESS3_READ) {

		error = VOP_ACCESS(vp, VREAD, 0, cr);

		if (error) {