/*
 * 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 2015 Nexenta Systems, Inc.  All rights reserved.
 */

/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/salib.h>
#include <rpc/types.h>
#include <rpc/xdr.h>
#include <rpc/rpc.h>
#include <rpcsvc/nfs4_prot.h>
#include "nfs_inet.h"

#define	dprintf if (boothowto & RB_DEBUG) printf

/*
 * XDR routines for NFSv4 ops.
 */
static bool_t
xdr_b_utf8string(XDR *xdrs, utf8string *objp)
{
	return (xdr_bytes(xdrs, (char **)&objp->utf8string_val,
	    (uint_t *)&objp->utf8string_len, NFS4_MAX_UTF8STRING));
}

static bool_t
xdr_nfs_bfh4(XDR *xdrs, struct nfs_bfh4 *objp)
{
	char *data = (char *)&objp->data;
	return (xdr_bytes(xdrs, (char **)&data, (uint_t *)&objp->len,
	    NFS4_FHSIZE));
}

static bool_t
xdr_b_putfh4_args(XDR *xdrs, putfh4arg_t *objp)
{
	if (!xdr_u_int(xdrs, (uint_t *)&objp->pf_opnum))
		return (FALSE);
	return (xdr_nfs_bfh4(xdrs, (struct nfs_bfh4 *)&objp->pf_filehandle));
}

/*
 * Common xdr routines for compound.  Let the specific op routines handle
 * op specific portions of the compound.
 */
static bool_t
xdr_b_compound_args(XDR *xdrs, b_compound_t *objp)
{
	if (!xdr_b_utf8string(xdrs, &objp->ca_tag)) {
		return (FALSE);
	}
	if (!xdr_u_int(xdrs, &objp->ca_minorversion))
		return (FALSE);
	if (!xdr_u_int(xdrs, &objp->ca_argarray_len))
		return (FALSE);
	if (objp->ca_isputrootfh)
		return (xdr_u_int(xdrs, &objp->ca_opputfh.pf_opnum));
	return (xdr_b_putfh4_args(xdrs, &objp->ca_opputfh));
}

static bool_t
xdr_b_compound_res(XDR *xdrs, b_compound_t *objp)
{
	if (!xdr_enum(xdrs, (enum_t *)&objp->cr_status))
		return (FALSE);
	if (!xdr_b_utf8string(xdrs, &objp->cr_tag))
		return (FALSE);
	if (!xdr_u_int(xdrs, &objp->cr_resarray_len))
		return (FALSE);
	if (!xdr_u_int(xdrs, &objp->cr_opputfh))
		return (FALSE);
	return (xdr_enum(xdrs, (enum_t *)&objp->cr_putfh_status));
}

static bool_t
xdr_b_bitmap4(XDR *xdrs, b_bitmap4_t *objp)
{
	char *arp = (char *)&objp->b_bitmap_val;
	return (xdr_array(xdrs, (char **)&arp,
	    (uint_t *)&objp->b_bitmap_len, ~0,
	    sizeof (uint_t), (xdrproc_t)xdr_u_int));
}

static bool_t
xdr_b_stateid4(XDR *xdrs, stateid4 *objp)
{
	if (!xdr_u_int(xdrs, (uint_t *)&objp->seqid))
		return (FALSE);
	return (xdr_opaque(xdrs, objp->other, NFS4_OTHER_SIZE));
}

bool_t
xdr_getattr4_args(XDR *xdrs, getattr4arg_t *objp)
{
	if (!xdr_b_compound_args(xdrs, (b_compound_t *)&objp->ga_arg))
		return (FALSE);
	if (!xdr_u_int(xdrs, (uint_t *)&objp->ga_opgetattr))
		return (FALSE);
	return (xdr_b_bitmap4(xdrs, (b_bitmap4_t *)&objp->ga_attr_req));
}

static bool_t
xdr_b_getattr_res_common(XDR *xdrs, getattrres_cmn_t *objp)
{
	if (!xdr_u_int(xdrs, (uint_t *)&objp->gc_opgetattr))
		return (FALSE);
	if (!xdr_enum(xdrs, (enum_t *)&objp->gc_attr_status))
		return (FALSE);

	/*
	 * If the getattr suceeded, proceed and begin to decode the attributes.
	 */
	if (objp->gc_attr_status == NFS4_OK) {
		char		attrvals[sizeof (b_fattr4_t)];
		char		*ap = attrvals;

		if (!xdr_b_bitmap4(xdrs, (b_bitmap4_t *)&objp->gc_retattr))
			return (FALSE);

		bzero(&attrvals, sizeof (attrvals));
		if (!xdr_bytes(xdrs, (char **)&ap,
		    (uint_t *)&objp->gc_attrlist_len, sizeof (b_fattr4_t)))
			return (FALSE);
#ifdef DEBUG
		printf("xdr_b_getattr_res_common: attrlist_len = %d\n",
		    objp->gc_attrlist_len);
#endif
		/*
		 * Go through the bitmap and see if the server
		 * sent us anything.
		 */
		if (objp->gc_attrlist_len > 0) {
			XDR		mxdrs;
			b_fattr4_t	*fattrp = &objp->gc_attrs;
			attr4_bitmap1_t bitmap1;
			attr4_bitmap2_t bitmap2;
#ifdef DEBUG
			int i;

			printf("dumping contents of attr buffer\n");
			for (i = 0; i < objp->gc_attrlist_len; i++) {
				printf("[%d] = 0x%x\n", i, ap[i]);
			}
#endif
			bitmap1.word = objp->gc_retattr.b_bitmap_val[0];
			bitmap2.word = objp->gc_retattr.b_bitmap_val[1];

#ifdef DEBUG
			printf("xdr_b_getattr_res_common: bitmap1 = %d "
			    "			bitmap2 = %d\n",
			    bitmap1.word, bitmap2.word);
#endif
			xdrmem_create(&mxdrs, ap, objp->gc_attrlist_len,
			    XDR_DECODE);

			/*
			 * Start with the first bitmap
			 */
			if (bitmap1.word > 0) {
				if (bitmap1.bm_supported_attrs) {
					if (!xdr_b_bitmap4(&mxdrs,
					    (b_bitmap4_t *)&fattrp->
					    b_supported_attrs))
						return (FALSE);
				}

				if (bitmap1.bm_fattr4_type) {
					if (!xdr_enum(&mxdrs,
				(enum_t *)&fattrp->b_fattr4_type)) {
						return (FALSE);
					}
				}
				if (bitmap1.bm_fattr4_size) {
					if (!xdr_u_longlong_t(&mxdrs,
					    (u_longlong_t *)&fattrp->
					    b_fattr4_size))
						return (FALSE);
				}

				if (bitmap1.bm_fattr4_fsid) {
					if (!xdr_u_longlong_t(&mxdrs,
					    (u_longlong_t *)&fattrp->
					    b_fattr4_fsid.major))
						return (FALSE);

					if (!xdr_u_longlong_t(&mxdrs,
					    (u_longlong_t *)&fattrp->
					    b_fattr4_fsid.minor))
						return (FALSE);
				}
				if (bitmap1.bm_fattr4_filehandle) {
					if (!xdr_nfs_bfh4(&mxdrs,
					    (struct nfs_bfh4 *)&fattrp->
					    b_fattr4_filehandle))
						return (FALSE);
				}
				if (bitmap1.bm_fattr4_fileid) {
					if (!xdr_u_longlong_t(&mxdrs,
					    (u_longlong_t *)&fattrp->
					    b_fattr4_fileid))
						return (FALSE);
				}
			}

			/*
			 * Now the second bitmap
			 */
			if (bitmap2.word > 0) {
				if (bitmap2.bm_fattr4_mode) {
					if (!xdr_u_int(&mxdrs, (uint_t *)&objp->
					    gc_attrs.b_fattr4_mode))
						return (FALSE);
				}

				if (bitmap2.bm_fattr4_time_access) {
					if (!xdr_longlong_t(&mxdrs,
					    (longlong_t *)&objp->gc_attrs.
					    b_fattr4_time_access.seconds))
						return (FALSE);
					if (!xdr_u_int(&mxdrs,
					    (uint_t *)&objp->gc_attrs.
					    b_fattr4_time_access.nseconds))
						return (FALSE);
				}

				if (bitmap2.bm_fattr4_time_metadata) {
					if (!xdr_longlong_t(&mxdrs,
					    (longlong_t *)&objp->gc_attrs.
					    b_fattr4_time_metadata.seconds))
						return (FALSE);
					if (!xdr_u_int(&mxdrs,
					    (uint_t *)&objp->gc_attrs.
					    b_fattr4_time_metadata.nseconds))
						return (FALSE);
				}

				if (bitmap2.bm_fattr4_time_modify) {
					if (!xdr_longlong_t(&mxdrs,
					    (longlong_t *)&objp->gc_attrs.
					    b_fattr4_time_modify.seconds))
						return (FALSE);
					if (!xdr_u_int(&mxdrs,
					    (uint_t *)&objp->gc_attrs.
					    b_fattr4_time_modify.nseconds))
						return (FALSE);
				}
			}
		}
	}
	return (TRUE);
}

bool_t
xdr_getattr4_res(XDR *xdrs, getattr4res_t *objp)
{
	if (!xdr_b_compound_res(xdrs, (b_compound_t *)&objp->gr_res))
		return (FALSE);
	return (xdr_b_getattr_res_common(xdrs,
	    (getattrres_cmn_t *)&objp->gr_cmn));
}

bool_t
xdr_lookup4_args(XDR *xdrs, lookup4arg_t *objp)
{
	if (!xdr_b_compound_args(xdrs, (b_compound_t *)&objp->la_arg))
		return (FALSE);
	if (!xdr_u_int(xdrs, (uint_t *)&objp->la_oplookup))
		return (FALSE);
	if (!xdr_b_utf8string(xdrs, (utf8string *)&objp->la_pathname))
		return (FALSE);
	if (!xdr_u_int(xdrs, (uint_t *)&objp->la_opgetattr))
		return (FALSE);
	return (xdr_b_bitmap4(xdrs, (b_bitmap4_t *)&objp->la_attr_req));
}

bool_t
xdr_lookup4_res(XDR *xdrs, lookup4res_t *objp)
{
	if (!xdr_b_compound_res(xdrs, (b_compound_t *)&objp->lr_res))
		return (FALSE);
	if (!xdr_u_int(xdrs, (uint_t *)&objp->lr_oplookup))
		return (FALSE);
	if (!xdr_enum(xdrs, (enum_t *)&objp->lr_lookup_status))
		return (FALSE);
	if (objp->lr_lookup_status == NFS4_OK) {
		return (xdr_b_getattr_res_common(xdrs,
		    (getattrres_cmn_t *)&objp->lr_gcmn));
	}
	return (TRUE);
}

bool_t
xdr_lookupp4_args(XDR *xdrs, lookupp4arg_t *objp)
{
	if (!xdr_b_compound_args(xdrs, (b_compound_t *)&objp->la_arg))
		return (FALSE);
	if (!xdr_u_int(xdrs, (uint_t *)&objp->la_oplookupp))
		return (FALSE);
	if (!xdr_u_int(xdrs, (uint_t *)&objp->la_opgetattr))
		return (FALSE);
	return (xdr_b_bitmap4(xdrs, (b_bitmap4_t *)&objp->la_attr_req));
}

bool_t
xdr_read4_args(XDR *xdrs, read4arg_t *objp)
{
	if (!xdr_b_compound_args(xdrs, (b_compound_t *)&objp->r_arg))
		return (FALSE);
	if (!xdr_u_int(xdrs, (uint_t *)&objp->r_opread))
		return (FALSE);
	if (!xdr_b_stateid4(xdrs, (stateid4 *)&objp->r_stateid))
		return (FALSE);
	if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->r_offset))
		return (FALSE);
	return (xdr_u_int(xdrs, (uint_t *)&objp->r_count));
}

bool_t
xdr_read4_res(XDR *xdrs, read4res_t *objp)
{
	if (!xdr_b_compound_res(xdrs, (b_compound_t *)&objp->r_res))
		return (FALSE);
	if (!xdr_u_int(xdrs, (uint_t *)&objp->r_opread))
		return (FALSE);
	if (!xdr_enum(xdrs, (enum_t *)&objp->r_status))
		return (FALSE);
	if (objp->r_status == NFS4_OK) {
		if (!xdr_bool(xdrs, (bool_t *)&objp->r_eof))
			return (FALSE);
		return (xdr_bytes(xdrs, (char **)&objp->r_data_val,
		    (uint_t *)&objp->r_data_len, ~0));
	}
	return (TRUE);
}

bool_t
xdr_readdir4_args(XDR *xdrs, readdir4arg_t *objp)
{
	if (!xdr_b_compound_args(xdrs, (b_compound_t *)&objp->rd_arg))
		return (FALSE);
	if (!xdr_u_int(xdrs, (uint_t *)&objp->rd_opreaddir))
		return (FALSE);
	if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->rd_cookie))
		return (FALSE);
	if (!xdr_opaque(xdrs, objp->rd_cookieverf, NFS4_VERIFIER_SIZE))
		return (FALSE);
	if (!xdr_u_int(xdrs, (uint_t *)&objp->rd_dircount))
		return (FALSE);
	if (!xdr_u_int(xdrs, (uint_t *)&objp->rd_maxcount))
		return (FALSE);
	return (xdr_b_bitmap4(xdrs, (b_bitmap4_t *)&objp->rd_attr_req));
}

static bool_t
xdr_b_entry4(XDR *xdrs, b_entry4_t *objp)
{
	uint_t		attrlen;
	char		attrvals[sizeof (b_fattr4_t)];
	char		*ap = attrvals;
	XDR		mxdrs;

	if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->b_cookie))
		return (FALSE);
	if (!xdr_b_utf8string(xdrs, &objp->b_name))
		return (FALSE);

	bzero(&attrvals, sizeof (attrvals));
	if (!xdr_bytes(xdrs, (char **)&ap, (uint_t *)&attrlen,
	    sizeof (b_fattr4_t)))
		return (FALSE);

	/*
	 * We are *only* interested in the fileid, so just extract that.
	 */
	if (attrlen < sizeof (uint64_t))
		return (FALSE);

	xdrmem_create(&mxdrs, ap, attrlen, XDR_DECODE);

	if (!xdr_u_longlong_t(&mxdrs, (u_longlong_t *)&objp->b_fileid))
		return (FALSE);
	return (xdr_pointer(xdrs, (char **)&objp->b_nextentry,
	    sizeof (b_entry4_t), (xdrproc_t)xdr_b_entry4));
}

bool_t
xdr_readdir4_res(XDR *xdrs, readdir4res_t *objp)
{
	if (!xdr_b_compound_res(xdrs, (b_compound_t *)&objp->rd_res))
		return (FALSE);
	if (!xdr_u_int(xdrs, (uint_t *)&objp->rd_opreaddir))
		return (FALSE);
	if (!xdr_enum(xdrs, (enum_t *)&objp->rd_status))
		return (FALSE);
	if (objp->rd_status == NFS4_OK) {
		if (!xdr_opaque(xdrs, objp->rd_cookieverf, NFS4_VERIFIER_SIZE))
			return (FALSE);
		if (!xdr_pointer(xdrs, (char **)&objp->rd_entries,
		    sizeof (b_entry4_t), (xdrproc_t)xdr_b_entry4))
			return (FALSE);
		return (xdr_bool(xdrs, &objp->rd_eof));
	}
	return (TRUE);
}

bool_t
xdr_readlink4_args(XDR *xdrs, readlink4arg_t *objp)
{
	if (!xdr_b_compound_args(xdrs, (b_compound_t *)&objp->rl_arg))
		return (FALSE);
	return (xdr_u_int(xdrs, (uint_t *)&objp->rl_opreadlink));
}

bool_t
xdr_readlink4_res(XDR *xdrs, readlink4res_t *objp)
{
	if (!xdr_b_compound_res(xdrs, (b_compound_t *)&objp->rl_res))
		return (FALSE);
	if (!xdr_u_int(xdrs, (uint_t *)&objp->rl_opreadlink))
		return (FALSE);
	if (!xdr_enum(xdrs, (enum_t *)&objp->rl_status))
		return (FALSE);
	if (objp->rl_status == NFS4_OK)
		return (xdr_b_utf8string(xdrs, (utf8string *)&objp->rl_link));
	return (TRUE);
}