/*
 * 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 2017 Joyent Inc
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/systm.h>
#include <sys/cmn_err.h>
#include <sys/kmem.h>
#include <sys/cred.h>
#include <sys/dirent.h>
#include <sys/debug.h>
#include <rpc/types.h>
#include <nfs/nfs.h>
#include <nfs/export.h>
#include <rpc/svc.h>
#include <rpc/xdr.h>
#include <rpc/rpcb_prot.h>
#include <rpc/clnt.h>
#include <nfs/nfs_log.h>

/*
 * nfsl_principal_name_get - extracts principal from transport struct.
 * Based on "uts/common/rpc/sec/sec_svc.c" function sec_svc_getcred.
 */
static char *
nfsl_principal_name_get(struct svc_req *req)
{
        char                            *principal_name = NULL;
        struct authdes_cred             *adc;
        rpc_gss_rawcred_t               *rcred;
        rpc_gss_ucred_t                 *ucred;
        void                            *cookie;

        switch (req->rq_cred.oa_flavor) {
        case AUTH_UNIX:
        case AUTH_NONE:
                /* no principal name provided */
                break;

        case AUTH_DES:
                adc = (struct authdes_cred *)req->rq_clntcred;
                CTASSERT(sizeof (struct authdes_cred) <= RQCRED_SIZE);
                principal_name = adc->adc_fullname.name;
                break;

        case RPCSEC_GSS:
                (void) rpc_gss_getcred(req, &rcred, &ucred, &cookie);
                principal_name = (caddr_t)rcred->client_principal;
                break;

        default:
                break;
        }
        return (principal_name);
}

bool_t
xdr_timestruc32_t(XDR *xdrs, timestruc32_t *objp)
{
        if (!xdr_int(xdrs, &objp->tv_sec))
                return (FALSE);
        return (xdr_int(xdrs, &objp->tv_nsec));
}

bool_t
xdr_nfsstat(XDR *xdrs, nfsstat *objp)
{
        return (xdr_enum(xdrs, (enum_t *)objp));
}

bool_t
xdr_nfslog_sharefsres(XDR *xdrs, nfslog_sharefsres *objp)
{
        return (xdr_nfsstat(xdrs, objp));
}

bool_t
xdr_nfsreadargs(XDR *xdrs, struct nfsreadargs *ra)
{
        if (xdr_fhandle(xdrs, &ra->ra_fhandle) &&
            xdr_u_int(xdrs, &ra->ra_offset) &&
            xdr_u_int(xdrs, &ra->ra_count) &&
            xdr_u_int(xdrs, &ra->ra_totcount)) {
                return (TRUE);
        }
        return (FALSE);
}

bool_t
xdr_nfslog_nfsreadargs(xdrs, objp)
        register XDR *xdrs;
        nfslog_nfsreadargs *objp;
{
        return (xdr_nfsreadargs(xdrs, objp));
}

/*
 * Current version (2 and up) xdr function for buffer header
 * uses 64-bit offset (relocated to an 8 byte boundary), version 1 uses 32.
 */
bool_t
xdr_nfslog_buffer_header(xdrs, objp)
        register XDR *xdrs;
        nfslog_buffer_header *objp;
{
        if (!xdr_u_int(xdrs, &objp->bh_length))
                return (FALSE);
        if (!xdr_rpcvers(xdrs, &objp->bh_version))
                return (FALSE);
        ASSERT(objp->bh_version > 1);
        if (!xdr_u_longlong_t(xdrs, &objp->bh_offset))
                return (FALSE);
        if (!xdr_u_int(xdrs, &objp->bh_flags))
                return (FALSE);
        return (xdr_timestruc32_t(xdrs, &objp->bh_timestamp));
}

/*
 * Hand coded xdr functions for the kernel ENCODE path
 */

bool_t
xdr_nfslog_request_record(
        XDR *xdrs,
        struct exportinfo *exi,
        struct svc_req *req,
        cred_t *cr,
        struct netbuf *pnb,
        unsigned int    reclen,
        unsigned int    record_id)
{
        char *netid = NULL;
        char *prin = NULL;
        unsigned int flavor;
        timestruc32_t ts;
        timestruc_t now;
        uid_t ruid;
        gid_t rgid;

        if (xdrs->x_op != XDR_ENCODE)
                return (FALSE);

        /*
         * First we do the encoding of the record header
         */
        if (!xdr_u_int(xdrs, &reclen))
                return (FALSE);
        if (!xdr_u_int(xdrs, &record_id))
                return (FALSE);
        if (!xdr_rpcprog(xdrs, &req->rq_prog))
                return (FALSE);
        if (!xdr_rpcproc(xdrs, &req->rq_proc))
                return (FALSE);
        if (!xdr_rpcvers(xdrs, &req->rq_vers))
                return (FALSE);
        flavor = req->rq_cred.oa_flavor;
        if (!xdr_u_int(xdrs, &flavor))
                return (FALSE);

        gethrestime(&now);
        TIMESPEC_TO_TIMESPEC32(&ts, &now);
        if (!xdr_timestruc32_t(xdrs, &ts))
                return (FALSE);

        /* This code depends on us doing XDR_ENCODE ops only */
        ruid = crgetruid(cr);
        if (!xdr_uid_t(xdrs, &ruid))
                return (FALSE);
        rgid = crgetrgid(cr);
        if (!xdr_gid_t(xdrs, &rgid))
                return (FALSE);

        /*
         * Now encode the rest of the request record (but not args/res)
         */
        prin = nfsl_principal_name_get(req);
        if (!xdr_string(xdrs, &prin, ~0))
                return (FALSE);
        if (req->rq_xprt)
                netid = svc_getnetid(req->rq_xprt);
        if (!xdr_string(xdrs, &netid, ~0))
                return (FALSE);
        if (!xdr_string(xdrs, &exi->exi_export.ex_tag, ~0))
                return (FALSE);
        return (xdr_netbuf(xdrs, pnb));
}

bool_t
xdr_nfslog_sharefsargs(XDR *xdrs, struct exportinfo *objp)
{

        if (xdrs->x_op != XDR_ENCODE)
                return (FALSE);

        if (!xdr_int(xdrs, &objp->exi_export.ex_flags))
                return (FALSE);
        if (!xdr_u_int(xdrs, &objp->exi_export.ex_anon))
                return (FALSE);
        if (!xdr_string(xdrs, &objp->exi_export.ex_path, ~0))
                return (FALSE);
        return (xdr_fhandle(xdrs, &objp->exi_fh));
}

bool_t
xdr_nfslog_getfhargs(XDR *xdrs, nfslog_getfhargs *objp)
{
        if (!xdr_fhandle(xdrs, &objp->gfh_fh_buf))
                return (FALSE);
        return (xdr_string(xdrs, &objp->gfh_path, ~0));
}

bool_t
xdr_nfslog_drok(XDR *xdrs, struct nfsdrok *objp)
{
        return (xdr_fhandle(xdrs, &objp->drok_fhandle));
}

bool_t
xdr_nfslog_diropres(XDR *xdrs, struct nfsdiropres *objp)
{
        if (!xdr_nfsstat(xdrs, &objp->dr_status))
                return (FALSE);
        switch (objp->dr_status) {
        case NFS_OK:
                if (!xdr_nfslog_drok(xdrs, &objp->dr_drok))
                        return (FALSE);
                break;
        }
        return (TRUE);
}

bool_t
xdr_nfslog_getattrres(XDR *xdrs, struct nfsattrstat *objp)
{
        return (xdr_nfsstat(xdrs, &objp->ns_status));
}

bool_t
xdr_nfslog_rrok(XDR *xdrs, struct nfsrrok *objp)
{
        if (!xdr_u_int(xdrs, &objp->rrok_attr.na_size))
                return (FALSE);
        return (xdr_u_int(xdrs, &objp->rrok_count));
}

bool_t
xdr_nfslog_rdresult(XDR *xdrs, struct nfsrdresult *objp)
{
        if (!xdr_nfsstat(xdrs, &objp->rr_status))
                return (FALSE);
        switch (objp->rr_status) {
        case NFS_OK:
                if (!xdr_nfslog_rrok(xdrs, &objp->rr_u.rr_ok_u))
                        return (FALSE);
                break;
        }
        return (TRUE);
}

bool_t
xdr_nfslog_writeargs(XDR *xdrs, struct nfswriteargs *objp)
{
        if (!xdr_fhandle(xdrs, &objp->wa_args->otw_wa_fhandle))
                return (FALSE);
        if (!xdr_u_int(xdrs, &objp->wa_args->otw_wa_begoff))
                return (FALSE);
        if (!xdr_u_int(xdrs, &objp->wa_args->otw_wa_offset))
                return (FALSE);
        if (!xdr_u_int(xdrs, &objp->wa_args->otw_wa_totcount))
                return (FALSE);
        return (xdr_u_int(xdrs, &objp->wa_count));
}

bool_t
xdr_nfslog_writeresult(XDR *xdrs, struct nfsattrstat *objp)
{
        if (!xdr_nfsstat(xdrs, &objp->ns_status))
                return (FALSE);
        switch (objp->ns_status) {
        case NFS_OK:
                if (!xdr_u_int(xdrs, &objp->ns_u.ns_attr_u.na_size))
                        return (FALSE);
                break;
        }
        return (TRUE);
}

bool_t
xdr_nfslog_diropargs(XDR *xdrs, struct nfsdiropargs *objp)
{
        if (!xdr_fhandle(xdrs, objp->da_fhandle))
                return (FALSE);
        return (xdr_string(xdrs, &objp->da_name, ~0));
}

bool_t
xdr_nfslog_sattr(XDR *xdrs, struct nfssattr *objp)
{
        if (!xdr_u_int(xdrs, &objp->sa_mode))
                return (FALSE);
        if (!xdr_u_int(xdrs, &objp->sa_uid))
                return (FALSE);
        if (!xdr_u_int(xdrs, &objp->sa_gid))
                return (FALSE);
        if (!xdr_u_int(xdrs, &objp->sa_size))
                return (FALSE);
        if (!xdr_nfs2_timeval(xdrs, (nfs2_timeval *)&objp->sa_atime))
                return (FALSE);
        return (xdr_nfs2_timeval(xdrs, (nfs2_timeval *)&objp->sa_mtime));
}

bool_t
xdr_nfslog_createargs(XDR *xdrs, struct nfscreatargs *objp)
{
        if (!xdr_nfslog_sattr(xdrs, objp->ca_sa))
                return (FALSE);
        return (xdr_nfslog_diropargs(xdrs, &objp->ca_da));
}

bool_t
xdr_nfslog_setattrargs(XDR *xdrs, struct nfssaargs *objp)
{
        if (!xdr_fhandle(xdrs, &objp->saa_fh))
                return (FALSE);
        return (xdr_nfslog_sattr(xdrs, &objp->saa_sa));
}

bool_t
xdr_nfslog_rdlnres(XDR *xdrs, struct nfsrdlnres *objp)
{
        caddr_t lnres = NULL;
        int count;

        if (!xdr_nfsstat(xdrs, &objp->rl_status))
                return (FALSE);
        switch (objp->rl_status) {
        case NFS_OK:
                if ((count = objp->rl_u.rl_srok_u.srok_count) != 0) {
                        /*
                         * allocate extra element for terminating NULL
                         */
                        lnres = kmem_alloc(count + 1, KM_SLEEP);
                        bcopy(objp->rl_u.rl_srok_u.srok_data, lnres, count);
                        lnres[count] = '\0';
                }
                if (!xdr_string(xdrs, &lnres, ~0)) {
                        if (lnres != NULL)
                                kmem_free(lnres, count + 1);
                        return (FALSE);
                }
                if (lnres != NULL)
                        kmem_free(lnres, count + 1);
                break;
        }
        return (TRUE);
}

bool_t
xdr_nfslog_rnmargs(XDR *xdrs, struct nfsrnmargs *objp)
{
        if (!xdr_nfslog_diropargs(xdrs, &objp->rna_from))
                return (FALSE);
        return (xdr_nfslog_diropargs(xdrs, &objp->rna_to));
}

bool_t
xdr_nfslog_linkargs(XDR *xdrs, struct nfslinkargs *objp)
{
        if (!xdr_fhandle(xdrs, objp->la_from))
                return (FALSE);
        return (xdr_nfslog_diropargs(xdrs, &objp->la_to));
}

bool_t
xdr_nfslog_symlinkargs(XDR *xdrs, struct nfsslargs *objp)
{
        if (!xdr_nfslog_diropargs(xdrs, &objp->sla_from))
                return (FALSE);
        if (!xdr_string(xdrs, &objp->sla_tnm, ~0))
                return (FALSE);
        return (xdr_nfslog_sattr(xdrs, objp->sla_sa));
}

bool_t
xdr_nfslog_statfs(XDR *xdrs, struct nfsstatfs *objp)
{
        return (xdr_nfsstat(xdrs, &objp->fs_status));
}

bool_t
xdr_nfslog_rddirargs(XDR *xdrs, struct nfsrddirargs *objp)
{
        if (!xdr_fhandle(xdrs, &objp->rda_fh))
                return (FALSE);
        if (!xdr_u_int(xdrs, &objp->rda_offset))
                return (FALSE);
        return (xdr_u_int(xdrs, &objp->rda_count));
}

bool_t
xdr_nfslog_rdok(XDR *xdrs, struct nfsrdok *objp)
{
        if (!xdr_u_int(xdrs, &objp->rdok_offset))
                return (FALSE);
        if (!xdr_u_int(xdrs, &objp->rdok_size))
                return (FALSE);
        return (xdr_bool(xdrs, &objp->rdok_eof));
}

bool_t
xdr_nfslog_rddirres(XDR *xdrs, struct nfsrddirres *objp)
{
        if (!xdr_nfsstat(xdrs, &objp->rd_status))
                return (FALSE);
        switch (objp->rd_status) {
        case NFS_OK:
                if (!xdr_nfslog_rdok(xdrs, &objp->rd_u.rd_rdok_u))
                        return (FALSE);
                break;
        }
        return (TRUE);
}

bool_t
xdr_nfslog_diropargs3(XDR *xdrs, diropargs3 *objp)
{
        char *name;

        if (!xdr_nfslog_nfs_fh3(xdrs, &objp->dir))
                return (FALSE);
        if (objp->name != nfs3nametoolong)
                name = objp->name;
        else {
                /*
                 * The name is not defined, set it to the
                 * zero length string.
                 */
                name = NULL;
        }
        return (xdr_string(xdrs, &name, ~0));
}

bool_t
xdr_nfslog_LOOKUP3res(XDR *xdrs, LOOKUP3res *objp)
{
        if (!xdr_enum(xdrs, (enum_t *)&objp->status))
                return (FALSE);
        switch (objp->status) {
        case NFS3_OK:
                if (!xdr_nfslog_nfs_fh3(xdrs, &objp->res_u.ok.object))
                        return (FALSE);
                break;
        }
        return (TRUE);
}

bool_t
xdr_set_size3(XDR *xdrs, set_size3 *objp)
{
        if (!xdr_bool(xdrs, &objp->set_it))
                return (FALSE);
        switch (objp->set_it) {
        case TRUE:
                if (!xdr_uint64(xdrs, &objp->size))
                        return (FALSE);
                break;
        }
        return (TRUE);
}

bool_t
xdr_nfslog_createhow3(XDR *xdrs, createhow3 *objp)
{
        if (!xdr_enum(xdrs, (enum_t *)&objp->mode))
                return (FALSE);
        switch (objp->mode) {
        case UNCHECKED:
        case GUARDED:
                if (!xdr_set_size3(xdrs,
                        &objp->createhow3_u.obj_attributes.size))
                        return (FALSE);
                break;
        case EXCLUSIVE:
                break;
        default:
                return (FALSE);
        }
        return (TRUE);
}

bool_t
xdr_nfslog_CREATE3args(XDR *xdrs, CREATE3args *objp)
{
        if (!xdr_nfslog_diropargs3(xdrs, &objp->where))
                return (FALSE);
        return (xdr_nfslog_createhow3(xdrs, &objp->how));
}

bool_t
xdr_nfslog_CREATE3resok(XDR *xdrs, CREATE3resok *objp)
{
        return (xdr_post_op_fh3(xdrs, &objp->obj));
}

bool_t
xdr_nfslog_CREATE3res(XDR *xdrs, CREATE3res *objp)
{
        if (!xdr_enum(xdrs, (enum_t *)&objp->status))
                return (FALSE);
        switch (objp->status) {
        case NFS3_OK:
                if (!xdr_nfslog_CREATE3resok(xdrs, &objp->res_u.ok))
                        return (FALSE);
                break;
        }
        return (TRUE);
}

bool_t
xdr_nfslog_GETATTR3res(XDR *xdrs, GETATTR3res *objp)
{
        return (xdr_enum(xdrs, (enum_t *)&objp->status));
}

bool_t
xdr_nfslog_ACCESS3args(XDR *xdrs, ACCESS3args *objp)
{
        return (xdr_nfslog_nfs_fh3(xdrs, &objp->object));
}

bool_t
xdr_nfslog_ACCESS3res(XDR *xdrs, ACCESS3res *objp)
{
        return (xdr_enum(xdrs, (enum_t *)&objp->status));
}

bool_t
xdr_nfslog_SETATTR3args(XDR *xdrs, SETATTR3args *objp)
{
        if (!xdr_nfslog_nfs_fh3(xdrs, &objp->object))
                return (FALSE);
        return (xdr_set_size3(xdrs, &objp->new_attributes.size));
}

bool_t
xdr_nfslog_SETATTR3res(XDR *xdrs, SETATTR3res *objp)
{
        return (xdr_enum(xdrs, (enum_t *)&objp->status));
}

bool_t
xdr_nfslog_READLINK3res(XDR *xdrs, READLINK3res *objp)
{
        if (!xdr_enum(xdrs, (enum_t *)&objp->status))
                return (FALSE);
        switch (objp->status) {
        case NFS3_OK:
                if (!xdr_string(xdrs, &objp->res_u.ok.data, ~0))
                        return (FALSE);
                break;
        }
        return (TRUE);
}

bool_t
xdr_nfslog_READ3args(XDR *xdrs, READ3args *objp)
{
        if (!xdr_nfslog_nfs_fh3(xdrs, &objp->file))
                return (FALSE);
        if (!xdr_uint64(xdrs, &objp->offset))
                return (FALSE);
        return (xdr_uint32(xdrs, &objp->count));
}

bool_t
xdr_nfslog_READ3resok(XDR *xdrs, READ3resok *objp)
{
        if (!xdr_uint64(xdrs, &objp->file_attributes.attr.size))
                return (FALSE);
        if (!xdr_uint32(xdrs, &objp->count))
                return (FALSE);
        if (!xdr_bool(xdrs, &objp->eof))
                return (FALSE);
        return (xdr_u_int(xdrs, &objp->size));
}

bool_t
xdr_nfslog_READ3res(XDR *xdrs, READ3res *objp)
{
        if (!xdr_enum(xdrs, (enum_t *)&objp->status))
                return (FALSE);
        switch (objp->status) {
        case NFS3_OK:
                if (!xdr_nfslog_READ3resok(xdrs, &objp->res_u.ok))
                        return (FALSE);
                break;
        }
        return (TRUE);
}

bool_t
xdr_nfslog_WRITE3args(XDR *xdrs, WRITE3args *objp)
{
        if (!xdr_nfslog_nfs_fh3(xdrs, &objp->file))
                return (FALSE);
        if (!xdr_uint64(xdrs, &objp->offset))
                return (FALSE);
        if (!xdr_uint32(xdrs, &objp->count))
                return (FALSE);
        return (xdr_enum(xdrs, (enum_t *)&objp->stable));
}

bool_t
xdr_nfslog_WRITE3resok(XDR *xdrs, WRITE3resok *objp)
{
        if (!xdr_uint64(xdrs, &objp->file_wcc.after.attr.size))
                return (FALSE);
        if (!xdr_uint32(xdrs, &objp->count))
                return (FALSE);
        return (xdr_enum(xdrs, (enum_t *)&objp->committed));
}

bool_t
xdr_nfslog_WRITE3res(XDR *xdrs, WRITE3res *objp)
{
        if (!xdr_enum(xdrs, (enum_t *)&objp->status))
                return (FALSE);
        switch (objp->status) {
        case NFS3_OK:
                if (!xdr_nfslog_WRITE3resok(xdrs, &objp->res_u.ok))
                        return (FALSE);
                break;
        }
        return (TRUE);
}

bool_t
xdr_nfslog_MKDIR3args(XDR *xdrs, MKDIR3args *objp)
{
        return (xdr_nfslog_diropargs3(xdrs, &objp->where));
}

bool_t
xdr_nfslog_MKDIR3res(XDR *xdrs, MKDIR3res *objp)
{
        if (!xdr_enum(xdrs, (enum_t *)&objp->status))
                return (FALSE);
        switch (objp->status) {
        case NFS3_OK:
                if (!xdr_post_op_fh3(xdrs, &objp->res_u.ok.obj))
                        return (FALSE);
                break;
        }
        return (TRUE);
}

bool_t
xdr_nfslog_SYMLINK3args(XDR *xdrs, SYMLINK3args *objp)
{
        if (!xdr_nfslog_diropargs3(xdrs, &objp->where))
                return (FALSE);
        return (xdr_string(xdrs, &objp->symlink.symlink_data, ~0));
}

bool_t
xdr_nfslog_SYMLINK3res(XDR *xdrs, SYMLINK3res *objp)
{
        if (!xdr_enum(xdrs, (enum_t *)&objp->status))
                return (FALSE);
        switch (objp->status) {
        case NFS3_OK:
                if (!xdr_post_op_fh3(xdrs, &objp->res_u.ok.obj))
                        return (FALSE);
                break;
        }
        return (TRUE);
}

bool_t
xdr_nfslog_MKNOD3args(XDR *xdrs, MKNOD3args *objp)
{
        if (!xdr_nfslog_diropargs3(xdrs, &objp->where))
                return (FALSE);
        return (xdr_enum(xdrs, (enum_t *)&objp->what.type));
}

bool_t
xdr_nfslog_MKNOD3res(XDR *xdrs, MKNOD3res *objp)
{
        if (!xdr_enum(xdrs, (enum_t *)&objp->status))
                return (FALSE);
        switch (objp->status) {
        case NFS3_OK:
                if (!xdr_post_op_fh3(xdrs, &objp->res_u.ok.obj))
                        return (FALSE);
                break;
        }
        return (TRUE);
}

bool_t
xdr_nfslog_REMOVE3args(XDR *xdrs, REMOVE3args *objp)
{
        return (xdr_nfslog_diropargs3(xdrs, &objp->object));
}

bool_t
xdr_nfslog_REMOVE3res(XDR *xdrs, REMOVE3res *objp)
{
        return (xdr_enum(xdrs, (enum_t *)&objp->status));
}

bool_t
xdr_nfslog_RMDIR3args(XDR *xdrs, RMDIR3args *objp)
{
        return (xdr_nfslog_diropargs3(xdrs, &objp->object));
}

bool_t
xdr_nfslog_RMDIR3res(XDR *xdrs, RMDIR3res *objp)
{
        return (xdr_enum(xdrs, (enum_t *)&objp->status));
}

bool_t
xdr_nfslog_RENAME3args(XDR *xdrs, RENAME3args *objp)
{
        if (!xdr_nfslog_diropargs3(xdrs, &objp->from))
                return (FALSE);
        return (xdr_nfslog_diropargs3(xdrs, &objp->to));
}

bool_t
xdr_nfslog_RENAME3res(XDR *xdrs, RENAME3res *objp)
{
        return (xdr_enum(xdrs, (enum_t *)&objp->status));
}

bool_t
xdr_nfslog_LINK3args(XDR *xdrs, LINK3args *objp)
{
        if (!xdr_nfslog_nfs_fh3(xdrs, &objp->file))
                return (FALSE);
        return (xdr_nfslog_diropargs3(xdrs, &objp->link));
}

bool_t
xdr_nfslog_LINK3res(XDR *xdrs, LINK3res *objp)
{
        return (xdr_enum(xdrs, (enum_t *)&objp->status));
}

bool_t
xdr_nfslog_READDIR3args(XDR *xdrs, READDIR3args *objp)
{
        return (xdr_nfslog_nfs_fh3(xdrs, &objp->dir));
}

bool_t
xdr_nfslog_READDIR3res(XDR *xdrs, READDIR3res *objp)
{
        return (xdr_enum(xdrs, (enum_t *)&objp->status));
}

bool_t
xdr_nfslog_READDIRPLUS3args(XDR *xdrs, READDIRPLUS3args *objp)
{
        if (!xdr_nfslog_nfs_fh3(xdrs, &objp->dir))
                return (FALSE);
        if (!xdr_uint32(xdrs, &objp->dircount))
                return (FALSE);
        return (xdr_uint32(xdrs, &objp->maxcount));
}

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

bool_t
xdr_nfslog_READDIRPLUS3resok(XDR *xdrs, READDIRPLUS3resok *objp)
{
        struct dirent64 *dp;
        bool_t true = TRUE;
        bool_t false = FALSE;
        int nents;
        char *name;
        entryplus3_info *infop;

        dp = (struct dirent64 *)objp->reply.entries;
        nents = objp->size;
        infop = objp->infop;
        while (nents > 0) {
                if (dp->d_reclen == 0)
                        return (FALSE);
                if (dp->d_ino == 0) {
                        dp = nextdp(dp);
                        infop++;
                        nents--;
                        continue;
                }
                name = dp->d_name;

                if (!xdr_bool(xdrs, &true) ||
                    !xdr_post_op_fh3(xdrs, &infop->fh) ||
                    !xdr_string(xdrs, &name, ~0)) {
                        return (FALSE);
                }
                dp = nextdp(dp);
                infop++;
                nents--;
        }
        if (!xdr_bool(xdrs, &false))
                return (FALSE);

        return (xdr_bool(xdrs, &objp->reply.eof));
}

bool_t
xdr_nfslog_READDIRPLUS3res(XDR *xdrs, READDIRPLUS3res *objp)
{
        if (!xdr_enum(xdrs, (enum_t *)&objp->status))
                return (FALSE);
        switch (objp->status) {
        case NFS3_OK:
                if (!xdr_nfslog_READDIRPLUS3resok(xdrs, &objp->res_u.ok))
                        return (FALSE);
                break;
        }
        return (TRUE);
}

bool_t
xdr_nfslog_FSSTAT3args(XDR *xdrs, FSSTAT3args *objp)
{
        return (xdr_nfslog_nfs_fh3(xdrs, &objp->fsroot));
}

bool_t
xdr_nfslog_FSSTAT3res(XDR *xdrs, FSSTAT3res *objp)
{
        return (xdr_enum(xdrs, (enum_t *)&objp->status));
}

bool_t
xdr_nfslog_FSINFO3args(XDR *xdrs, FSINFO3args *objp)
{
        return (xdr_nfslog_nfs_fh3(xdrs, &objp->fsroot));
}

bool_t
xdr_nfslog_FSINFO3res(XDR *xdrs, FSINFO3res *objp)
{
        return (xdr_enum(xdrs, (enum_t *)&objp->status));
}

bool_t
xdr_nfslog_PATHCONF3args(XDR *xdrs, PATHCONF3args *objp)
{
        return (xdr_nfslog_nfs_fh3(xdrs, &objp->object));
}

bool_t
xdr_nfslog_PATHCONF3res(XDR *xdrs, PATHCONF3res *objp)
{
        return (xdr_enum(xdrs, (enum_t *)&objp->status));
}

bool_t
xdr_nfslog_COMMIT3args(XDR *xdrs, COMMIT3args *objp)
{
        if (!xdr_nfslog_nfs_fh3(xdrs, &objp->file))
                return (FALSE);
        if (!xdr_uint64(xdrs, &objp->offset))
                return (FALSE);
        return (xdr_uint32(xdrs, &objp->count));
}

bool_t
xdr_nfslog_COMMIT3res(XDR *xdrs, COMMIT3res *objp)
{
        return (xdr_enum(xdrs, (enum_t *)&objp->status));
}

bool_t
xdr_nfslog_nfs_fh3(XDR *xdrs, nfs_fh3 *objp)
{
        nfs_fh3 fh;

        if (objp->fh3_len > NFS_FHMAXDATA || objp->fh3_xlen > NFS_FHMAXDATA) {
                fh = *objp;
                fh.fh3_len = NFS_FHMAXDATA;
                fh.fh3_xlen = NFS_FHMAXDATA;
                fh.fh3_length = NFS3_OLDFHSIZE;
                return (xdr_nfs_fh3_server(xdrs, &fh));
        }
        return (xdr_nfs_fh3_server(xdrs, objp));
}