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

#include <sys/time.h>
#include <sys/systm.h>

#include <nfs/nfs.h>
#include <nfs/nfs4.h>
#include <nfs/rnode4.h>
#include <nfs/nfs4_clnt.h>
#include <sys/cmn_err.h>

static int
timestruc_to_settime4(timestruc_t *tt, settime4 *tt4, int flags)
{
        int     error = 0;

        if (flags & ATTR_UTIME) {
                tt4->set_it = SET_TO_CLIENT_TIME4;
                error = nfs4_time_vton(tt, &tt4->time);
        } else {
                tt4->set_it = SET_TO_SERVER_TIME4;
        }
        return (error);
}


/*
 * nfs4_ver_fattr4_attr translates a vattr attribute into a fattr4 attribute
 * for use by nfsv4 verify.  For setting atime or mtime use the entry for
 * time_XX (XX == access or modify).
 * Return TRUE if arg was set (even if there was an error) and FALSE
 * otherwise. Also set error code. The caller should not continue
 * if error was set, whether or not the return is TRUE or FALSE. Returning
 * FALSE does not mean there was an error, only that the attr was not set.
 *
 * Note: For now we only have the options used by setattr. In the future
 * the switch statement below should cover all vattr attrs and possibly
 * sys attrs as well.
 */
/* ARGSUSED */
static bool_t
nfs4_ver_fattr4_attr(vattr_t *vap, struct nfs4_ntov_map *ntovp,
    union nfs4_attr_u *nap, int flags, int *errorp)
{
        bool_t  retval = TRUE;

        /*
         * Special case for time set: if setting the
         * time, ignore entry for time access/modify set (setattr)
         * and instead use that of time access/modify.
         */
        *errorp = 0;
        /*
         * Bit matches the mask
         */
        switch (ntovp->vbit & vap->va_mask) {
        case AT_SIZE:
                nap->size = vap->va_size;
                break;
        case AT_MODE:
                nap->mode = vap->va_mode;
                break;
        case AT_UID:
                /*
                 * if no mapping, uid could be mapped to a numeric string,
                 * e.g. 12345->"12345"
                 */
                if (*errorp = nfs_idmap_uid_str(vap->va_uid, &nap->owner,
                    FALSE))
                        retval = FALSE;
                break;
        case AT_GID:
                /*
                 * if no mapping, gid will be mapped to a number string,
                 * e.g. "12345"
                 */
                if (*errorp = nfs_idmap_gid_str(vap->va_gid, &nap->owner_group,
                    FALSE))
                        retval = FALSE;
                break;
        case AT_ATIME:
                if ((ntovp->nval != FATTR4_TIME_ACCESS) ||
                    (*errorp = nfs4_time_vton(&vap->va_ctime,
                    &nap->time_access))) {
                        /*
                         * either asked for FATTR4_TIME_ACCESS_SET -
                         *      not used for setattr
                         * or system time invalid for otw transfers
                         */
                        retval = FALSE;
                }
                break;
        case AT_MTIME:
                if ((ntovp->nval != FATTR4_TIME_MODIFY) ||
                    (*errorp = nfs4_time_vton(&vap->va_mtime,
                    &nap->time_modify))) {
                        /*
                         * either asked for FATTR4_TIME_MODIFY_SET -
                         *      not used for setattr
                         * or system time invalid for otw transfers
                         */
                        retval = FALSE;
                }
                break;
        case AT_CTIME:
                if (*errorp = nfs4_time_vton(&vap->va_ctime,
                    &nap->time_metadata)) {
                        /*
                         * system time invalid for otw transfers
                         */
                        retval = FALSE;
                }
                break;
        default:
                retval = FALSE;
        }
        return (retval);
}

/*
 * nfs4_set_fattr4_attr translates a vattr attribute into a fattr4 attribute
 * for use by nfs4_setattr.  For setting atime or mtime use the entry for
 * time_XX_set rather than time_XX (XX == access or modify).
 * Return TRUE if arg was set (even if there was an error) and FALSE
 * otherwise. Also set error code. The caller should not continue
 * if error was set, whether or not the return is TRUE or FALSE. Returning
 * FALSE does not mean there was an error, only that the attr was not set.
 */
static bool_t
nfs4_set_fattr4_attr(vattr_t *vap, vsecattr_t *vsap,
    struct nfs4_ntov_map *ntovp, union nfs4_attr_u *nap, int flags,
    int *errorp)
{
        bool_t  retval = TRUE;

        /*
         * Special case for time set: if setting the
         * time, ignore entry for time access/modify
         * and instead use that of time access/modify set.
         */
        *errorp = 0;
        /*
         * Bit matches the mask
         */
        switch (ntovp->vbit & vap->va_mask) {
        case AT_SIZE:
                nap->size = vap->va_size;
                break;
        case AT_MODE:
                nap->mode = vap->va_mode;
                break;
        case AT_UID:
                /*
                 * if no mapping, uid will be mapped to a number string,
                 * e.g. "12345"
                 */
                if (*errorp = nfs_idmap_uid_str(vap->va_uid, &nap->owner,
                    FALSE))
                        retval = FALSE;
                break;
        case AT_GID:
                /*
                 * if no mapping, gid will be mapped to a number string,
                 * e.g. "12345"
                 */
                if (*errorp = nfs_idmap_gid_str(vap->va_gid, &nap->owner_group,
                    FALSE))
                        retval = FALSE;
                break;
        case AT_ATIME:
                if ((ntovp->nval != FATTR4_TIME_ACCESS_SET) ||
                    (*errorp = timestruc_to_settime4(&vap->va_atime,
                    &nap->time_access_set, flags))) {
                        /* FATTR4_TIME_ACCESS - not used for verify */
                        retval = FALSE;
                }
                break;
        case AT_MTIME:
                if ((ntovp->nval != FATTR4_TIME_MODIFY_SET) ||
                    (*errorp = timestruc_to_settime4(&vap->va_mtime,
                    &nap->time_modify_set, flags))) {
                        /* FATTR4_TIME_MODIFY - not used for verify */
                        retval = FALSE;
                }
                break;
        default:
                /*
                 * If the ntovp->vbit == 0 this is most likely the ACL.
                 */
                if (ntovp->vbit == 0 && ntovp->fbit == FATTR4_ACL_MASK) {
                        ASSERT(vsap->vsa_mask == (VSA_ACE | VSA_ACECNT));
                        nap->acl.fattr4_acl_len = vsap->vsa_aclcnt;
                        nap->acl.fattr4_acl_val = vsap->vsa_aclentp;
                } else
                        retval = FALSE;
        }

        return (retval);
}

/*
 * XXX - This is a shorter version of vattr_to_fattr4 which only takes care
 * of setattr args - size, mode, uid/gid, times. Eventually we should generalize
 * by using nfs4_ntov_map and the same functions used by the server.
 * Here we just hardcoded the setattr attributes. Note that the order is
 * important - it should follow the order of the bits in the mask.
 */
int
vattr_to_fattr4(vattr_t *vap, vsecattr_t *vsap, fattr4 *fattrp, int flags,
    enum nfs_opnum4 op, bitmap4 supp)
{
        int i, j;
        union nfs4_attr_u *na = NULL;
        int attrcnt;
        int uid_attr = -1;
        int gid_attr = -1;
        int acl_attr = -1;
        XDR xdr;
        ulong_t xdr_size;
        char *xdr_attrs;
        int error = 0;
        uint8_t amap[NFS4_MAXNUM_ATTRS];
        uint_t va_mask = vap->va_mask;
        bool_t (*attrfunc)();

#ifndef lint
        /*
         * Make sure that maximum attribute number can be expressed as an
         * 8 bit quantity.
         */
        ASSERT(NFS4_MAXNUM_ATTRS <= (UINT8_MAX + 1));
#endif
        fattrp->attrmask = 0;
        fattrp->attrlist4_len = 0;
        fattrp->attrlist4 = NULL;
        na = kmem_zalloc(sizeof (union nfs4_attr_u) * nfs4_ntov_map_size,
            KM_SLEEP);

        if (op == OP_SETATTR || op == OP_CREATE || op == OP_OPEN) {
                /*
                 * Note we need to set the attrmask for set operations.
                 * In particular mtime and atime will be set to the
                 * servers time.
                 */
                nfs4_vmask_to_nmask_set(va_mask, &fattrp->attrmask);
                if (vsap != NULL)
                        fattrp->attrmask |= FATTR4_ACL_MASK;
                attrfunc = nfs4_set_fattr4_attr;
        } else {        /* verify/nverify */
                /*
                 * Verfy/nverify use the "normal vmask_to_nmask
                 * this routine knows how to handle all vmask bits
                 */
                nfs4_vmask_to_nmask(va_mask, &fattrp->attrmask);
                /*
                 * XXX verify/nverify only works for a subset of attrs that
                 * directly map to vattr_t attrs.  So, verify/nverify is
                 * broken for servers that only support mandatory attrs.
                 * Mask out change attr for now and fix verify op to
                 * work with mandonly servers later.  nfs4_vmask_to_nmask
                 * sets change whenever it sees request for ctime/mtime,
                 * so we must turn off change because nfs4_ver_fattr4_attr
                 * will not generate args for change.  This is a bug
                 * that will be fixed later.
                 * XXX
                 */
                fattrp->attrmask &= ~FATTR4_CHANGE_MASK;
                attrfunc = nfs4_ver_fattr4_attr;
        }

        /* Mask out any rec attrs unsupported by server */
        fattrp->attrmask &= supp;

        attrcnt = 0;
        xdr_size = 0;
        for (i = 0; i < nfs4_ntov_map_size; i++) {
                /*
                 * In the case of FATTR4_ACL_MASK, the vbit will be 0 (zero)
                 * so we must also check if the fbit is FATTR4_ACL_MASK before
                 * skipping over this attribute.
                 */
                if (!(nfs4_ntov_map[i].vbit & vap->va_mask)) {
                        if (nfs4_ntov_map[i].fbit != FATTR4_ACL_MASK)
                                continue;
                        if (vsap == NULL)
                                continue;
                }

                if (attrfunc == nfs4_set_fattr4_attr) {
                        if (!(*attrfunc)(vap, vsap, &nfs4_ntov_map[i],
                            &na[attrcnt], flags, &error))
                                continue;
                } else if (attrfunc == nfs4_ver_fattr4_attr) {
                        if (!(*attrfunc)(vap, &nfs4_ntov_map[i], &na[attrcnt],
                            flags, &error))
                                continue;
                }

                if (error)
                        goto done;      /* Exit! */

                /*
                 * Calculate XDR size
                 */
                if (nfs4_ntov_map[i].xdr_size != 0) {
                        /*
                         * If we are setting attributes (attrfunc is
                         * nfs4_set_fattr4_attr) and are setting the
                         * mtime or atime, adjust the xdr size down by
                         * 3 words, since we are using the server's
                         * time as the current time.  Exception: if
                         * ATTR_UTIME is set, the client sends the
                         * time, so leave the xdr size alone.
                         */
                        xdr_size += nfs4_ntov_map[i].xdr_size;
                        if ((nfs4_ntov_map[i].nval == FATTR4_TIME_ACCESS_SET ||
                            nfs4_ntov_map[i].nval == FATTR4_TIME_MODIFY_SET) &&
                            attrfunc == nfs4_set_fattr4_attr &&
                            !(flags & ATTR_UTIME)) {
                                xdr_size -= 3 * BYTES_PER_XDR_UNIT;
                        }
                } else {
                        /*
                         * The only zero xdr_sizes we should see
                         * are AT_UID, AT_GID and FATTR4_ACL_MASK
                         */
                        ASSERT(nfs4_ntov_map[i].vbit == AT_UID ||
                            nfs4_ntov_map[i].vbit == AT_GID ||
                            nfs4_ntov_map[i].fbit == FATTR4_ACL_MASK);
                        if (nfs4_ntov_map[i].vbit == AT_UID) {
                                uid_attr = attrcnt;
                                xdr_size += BYTES_PER_XDR_UNIT; /* length */
                                xdr_size +=
                                    RNDUP(na[attrcnt].owner.utf8string_len);
                        } else if (nfs4_ntov_map[i].vbit == AT_GID) {
                                gid_attr = attrcnt;
                                xdr_size += BYTES_PER_XDR_UNIT; /* length */
                                xdr_size +=
                                    RNDUP(
                                    na[attrcnt].owner_group.utf8string_len);
                        } else if (nfs4_ntov_map[i].fbit == FATTR4_ACL_MASK) {
                                nfsace4 *tmpacl = (nfsace4 *)vsap->vsa_aclentp;

                                acl_attr = attrcnt;
                                /* fattr4_acl_len */
                                xdr_size += BYTES_PER_XDR_UNIT;
                                /* fattr4_acl_val */
                                xdr_size += RNDUP((vsap->vsa_aclcnt *
                                    (sizeof (acetype4) + sizeof (aceflag4)
                                    + sizeof (acemask4))));

                                for (j = 0; j < vsap->vsa_aclcnt; j++) {
                                        /* who - utf8string_len */
                                        xdr_size += BYTES_PER_XDR_UNIT;
                                        /* who - utf8string_val */
                                        xdr_size +=
                                            RNDUP(tmpacl[j].who.utf8string_len);
                                }
                        }
                }

                /*
                 * This attr is going otw
                 */
                amap[attrcnt] = (uint8_t)nfs4_ntov_map[i].nval;
                attrcnt++;

                /*
                 * Clear this bit from test mask so we stop
                 * as soon as all requested attrs are done.
                 */
                va_mask &= ~nfs4_ntov_map[i].vbit;
                if (va_mask == 0 &&
                    (vsap == NULL || (vsap != NULL && acl_attr != -1)))
                        break;
        }

        if (attrcnt == 0) {
                goto done;
        }

        fattrp->attrlist4 = xdr_attrs = kmem_alloc(xdr_size, KM_SLEEP);
        fattrp->attrlist4_len = xdr_size;
        xdrmem_create(&xdr, xdr_attrs, xdr_size, XDR_ENCODE);
        for (i = 0; i < attrcnt; i++) {
                if ((*nfs4_ntov_map[amap[i]].xfunc)(&xdr, &na[i]) == FALSE) {
                        cmn_err(CE_WARN, "vattr_to_fattr4: xdr encode of "
                            "attribute failed\n");
                        error = EINVAL;
                        break;
                }
        }
done:
        /*
         * Free any malloc'd attrs, can only be uid or gid
         */
        if (uid_attr != -1 && na[uid_attr].owner.utf8string_val != NULL) {
                kmem_free(na[uid_attr].owner.utf8string_val,
                    na[uid_attr].owner.utf8string_len);
        }
        if (gid_attr != -1 && na[gid_attr].owner_group.utf8string_val != NULL) {
                kmem_free(na[gid_attr].owner_group.utf8string_val,
                    na[gid_attr].owner_group.utf8string_len);
        }

        /* xdrmem_destroy(&xdrs); */    /* NO-OP */
        kmem_free(na, sizeof (union nfs4_attr_u) * nfs4_ntov_map_size);
        if (error)
                nfs4_fattr4_free(fattrp);
        return (error);
}

void
nfs4_fattr4_free(fattr4 *attrp)
{
        /*
         * set attrlist4val/len to 0 because...
         *
         * op_readdir resfree function could call us again
         * for last entry4 if it was able to encode the name
         * and cookie but couldn't encode the attrs because
         * of maxcount violation (from rddir args).  In that
         * case, the last/partial entry4's fattr4 has already
         * been free'd, but the entry4 remains on the end of
         * the list.
         */
        attrp->attrmask = 0;

        if (attrp->attrlist4) {
                kmem_free(attrp->attrlist4, attrp->attrlist4_len);
                attrp->attrlist4 = NULL;
                attrp->attrlist4_len = 0;
        }
}

/*
 * Translate a vattr_t mask to a fattr4 type bitmap, caller is
 * responsible for zeroing bitsval if needed.
 */
void
nfs4_vmask_to_nmask(uint_t vmask, bitmap4 *bitsval)
{
        if (vmask == AT_ALL || vmask == NFS4_VTON_ATTR_MASK) {
                *bitsval |= NFS4_NTOV_ATTR_MASK;
                return;
        }

        vmask &= NFS4_VTON_ATTR_MASK;
        if (vmask == 0) {
                return;
        }

        if (vmask & AT_TYPE)
                *bitsval |= FATTR4_TYPE_MASK;
        if (vmask & AT_MODE)
                *bitsval |= FATTR4_MODE_MASK;
        if (vmask & AT_UID)
                *bitsval |= FATTR4_OWNER_MASK;
        if (vmask & AT_GID)
                *bitsval |= FATTR4_OWNER_GROUP_MASK;
        if (vmask & AT_FSID)
                *bitsval |= FATTR4_FSID_MASK;
        /* set mounted_on_fileid when AT_NODEID requested */
        if (vmask & AT_NODEID)
                *bitsval |= FATTR4_FILEID_MASK | FATTR4_MOUNTED_ON_FILEID_MASK;
        if (vmask & AT_NLINK)
                *bitsval |= FATTR4_NUMLINKS_MASK;
        if (vmask & AT_SIZE)
                *bitsval |= FATTR4_SIZE_MASK;
        if (vmask & AT_ATIME)
                *bitsval |= FATTR4_TIME_ACCESS_MASK;
        if (vmask & AT_MTIME)
                *bitsval |= FATTR4_TIME_MODIFY_MASK;
        /* also set CHANGE whenever AT_CTIME requested */
        if (vmask & AT_CTIME)
                *bitsval |= FATTR4_TIME_METADATA_MASK | FATTR4_CHANGE_MASK;
        if (vmask & AT_NBLOCKS)
                *bitsval |= FATTR4_SPACE_USED_MASK;
        if (vmask & AT_RDEV)
                *bitsval |= FATTR4_RAWDEV_MASK;
}

/*
 * nfs4_vmask_to_nmask_set is used for setattr. A separate function needed
 * because of special treatment to timeset.
 */
void
nfs4_vmask_to_nmask_set(uint_t vmask, bitmap4 *bitsval)
{
        vmask &= NFS4_VTON_ATTR_MASK_SET;

        if (vmask == 0) {
                return;
        }

        if (vmask & AT_MODE)
                *bitsval |= FATTR4_MODE_MASK;
        if (vmask & AT_UID)
                *bitsval |= FATTR4_OWNER_MASK;
        if (vmask & AT_GID)
                *bitsval |= FATTR4_OWNER_GROUP_MASK;
        if (vmask & AT_SIZE)
                *bitsval |= FATTR4_SIZE_MASK;
        if (vmask & AT_ATIME)
                *bitsval |= FATTR4_TIME_ACCESS_SET_MASK;
        if (vmask & AT_MTIME)
                *bitsval |= FATTR4_TIME_MODIFY_SET_MASK;
}

/*
 * Convert NFS Version 4 over the network attributes to the local
 * virtual attributes.
 */
vtype_t nf4_to_vt[] = {
        VBAD, VREG, VDIR, VBLK, VCHR, VLNK, VSOCK, VFIFO, VDIR, VREG
};


/*
 *      { fbit, vbit, vfsstat, mandatory,
 *              nval, xdr_size, xfunc,
 *              sv_getit, prtstr },
 */
struct nfs4_ntov_map nfs4_ntov_map[] = {
        { FATTR4_SUPPORTED_ATTRS_MASK, 0, FALSE, TRUE,
                FATTR4_SUPPORTED_ATTRS, 2 * BYTES_PER_XDR_UNIT, xdr_bitmap4,
                NULL, "fattr4_supported_attrs" },

        { FATTR4_TYPE_MASK, AT_TYPE, FALSE, TRUE,
                FATTR4_TYPE, BYTES_PER_XDR_UNIT, xdr_int,
                NULL, "fattr4_type" },

        { FATTR4_FH_EXPIRE_TYPE_MASK, 0, FALSE, TRUE,
                FATTR4_FH_EXPIRE_TYPE, BYTES_PER_XDR_UNIT, xdr_u_int,
                NULL, "fattr4_fh_expire_type" },

        { FATTR4_CHANGE_MASK, 0, FALSE, TRUE,
                FATTR4_CHANGE, 2 * BYTES_PER_XDR_UNIT, xdr_u_longlong_t,
                NULL, "fattr4_change" },

        { FATTR4_SIZE_MASK, AT_SIZE, FALSE, TRUE,
                FATTR4_SIZE,  2 * BYTES_PER_XDR_UNIT, xdr_u_longlong_t,
                NULL, "fattr4_size" },

        { FATTR4_LINK_SUPPORT_MASK, 0, FALSE, TRUE,
                FATTR4_LINK_SUPPORT, BYTES_PER_XDR_UNIT, xdr_bool,
                NULL, "fattr4_link_support" },

        { FATTR4_SYMLINK_SUPPORT_MASK, 0, FALSE, TRUE,
                FATTR4_SYMLINK_SUPPORT, BYTES_PER_XDR_UNIT, xdr_bool,
                NULL, "fattr4_symlink_support" },

        { FATTR4_NAMED_ATTR_MASK, 0, FALSE, TRUE,
                FATTR4_NAMED_ATTR, BYTES_PER_XDR_UNIT, xdr_bool,
                NULL, "fattr4_named_attr" },

        { FATTR4_FSID_MASK, AT_FSID, FALSE, TRUE,
                FATTR4_FSID, 4 * BYTES_PER_XDR_UNIT, xdr_fattr4_fsid,
                NULL, "fattr4_fsid" },

        { FATTR4_UNIQUE_HANDLES_MASK, 0, FALSE, TRUE,
                FATTR4_UNIQUE_HANDLES, BYTES_PER_XDR_UNIT, xdr_bool,
                NULL, "fattr4_unique_handles" },

        { FATTR4_LEASE_TIME_MASK, 0, FALSE, TRUE,
                FATTR4_LEASE_TIME, BYTES_PER_XDR_UNIT, xdr_u_int,
                NULL, "fattr4_lease_time" },

        { FATTR4_RDATTR_ERROR_MASK, 0, FALSE, TRUE,
                FATTR4_RDATTR_ERROR, BYTES_PER_XDR_UNIT, xdr_int,
                NULL, "fattr4_rdattr_error" },

        { FATTR4_ACL_MASK, 0, FALSE, FALSE,
                FATTR4_ACL, 0, xdr_fattr4_acl,
                NULL, "fattr4_acl" },

        { FATTR4_ACLSUPPORT_MASK, 0, FALSE, FALSE,
                FATTR4_ACLSUPPORT, BYTES_PER_XDR_UNIT, xdr_u_int,
                NULL, "fattr4_aclsupport" },

        { FATTR4_ARCHIVE_MASK, 0, FALSE, FALSE,
                FATTR4_ARCHIVE, BYTES_PER_XDR_UNIT, xdr_bool,
                NULL, "fattr4_archive" },

        { FATTR4_CANSETTIME_MASK, 0, FALSE, FALSE,
                FATTR4_CANSETTIME, BYTES_PER_XDR_UNIT, xdr_bool,
                NULL, "fattr4_cansettime" },

        { FATTR4_CASE_INSENSITIVE_MASK, 0, FALSE, FALSE,
                FATTR4_CASE_INSENSITIVE, BYTES_PER_XDR_UNIT, xdr_bool,
                NULL, "fattr4_case_insensitive" },

        { FATTR4_CASE_PRESERVING_MASK, 0, FALSE, FALSE,
                FATTR4_CASE_PRESERVING, BYTES_PER_XDR_UNIT, xdr_bool,
                NULL, "fattr4_case_preserving" },

        { FATTR4_CHOWN_RESTRICTED_MASK, 0, FALSE, FALSE,
                FATTR4_CHOWN_RESTRICTED, BYTES_PER_XDR_UNIT, xdr_bool,
                NULL, "fattr4_chown_restricted" },

        { FATTR4_FILEHANDLE_MASK, 0, FALSE, TRUE,
                FATTR4_FILEHANDLE, 0, xdr_nfs_fh4,
                NULL, "fattr4_filehandle" },

        { FATTR4_FILEID_MASK, AT_NODEID, FALSE, FALSE,
                FATTR4_FILEID, 2 * BYTES_PER_XDR_UNIT, xdr_u_longlong_t,
                NULL, "fattr4_fileid" },

        { FATTR4_FILES_AVAIL_MASK, 0, TRUE, FALSE,
                FATTR4_FILES_AVAIL, 2 * BYTES_PER_XDR_UNIT, xdr_u_longlong_t,
                NULL, "fattr4_files_avail" },

        { FATTR4_FILES_FREE_MASK, 0, TRUE, FALSE,
                FATTR4_FILES_FREE, 2 * BYTES_PER_XDR_UNIT, xdr_u_longlong_t,
                NULL, "fattr4_files_free" },

        { FATTR4_FILES_TOTAL_MASK, 0, TRUE, FALSE,
                FATTR4_FILES_TOTAL, 2 * BYTES_PER_XDR_UNIT, xdr_u_longlong_t,
                NULL, "fattr4_files_total" },

        { FATTR4_FS_LOCATIONS_MASK, 0, FALSE, FALSE,
                FATTR4_FS_LOCATIONS, 0, xdr_fattr4_fs_locations,
                NULL, "fattr4_fs_locations" },

        { FATTR4_HIDDEN_MASK, 0, FALSE, FALSE,
                FATTR4_HIDDEN, BYTES_PER_XDR_UNIT, xdr_bool,
                NULL, "fattr4_hidden" },

        { FATTR4_HOMOGENEOUS_MASK, 0, FALSE, FALSE,
                FATTR4_HOMOGENEOUS, BYTES_PER_XDR_UNIT, xdr_bool,
                NULL, "fattr4_homogeneous" },

        { FATTR4_MAXFILESIZE_MASK, 0, FALSE, FALSE,
                FATTR4_MAXFILESIZE, 2 * BYTES_PER_XDR_UNIT, xdr_u_longlong_t,
                NULL, "fattr4_maxfilesize" },

        { FATTR4_MAXLINK_MASK, 0, FALSE, FALSE,
                FATTR4_MAXLINK, BYTES_PER_XDR_UNIT, xdr_u_int,
                NULL, "fattr4_maxlink" },

        { FATTR4_MAXNAME_MASK, 0, FALSE, FALSE,
                FATTR4_MAXNAME, BYTES_PER_XDR_UNIT, xdr_u_int,
                NULL, "fattr4_maxname" },

        { FATTR4_MAXREAD_MASK, 0, FALSE, FALSE,
                FATTR4_MAXREAD, 2 * BYTES_PER_XDR_UNIT, xdr_u_longlong_t,
                NULL, "fattr4_maxread" },

        { FATTR4_MAXWRITE_MASK, 0, FALSE, FALSE,
                FATTR4_MAXWRITE, 2 * BYTES_PER_XDR_UNIT, xdr_u_longlong_t,
                NULL, "fattr4_maxwrite" },

        { FATTR4_MIMETYPE_MASK, 0, FALSE, FALSE,
                FATTR4_MIMETYPE, 0, xdr_utf8string,
                NULL, "fattr4_mimetype" },

        { FATTR4_MODE_MASK, AT_MODE, FALSE, FALSE,
                FATTR4_MODE, BYTES_PER_XDR_UNIT, xdr_u_int,
                NULL, "fattr4_mode" },

        { FATTR4_NO_TRUNC_MASK, 0, FALSE, FALSE,
                FATTR4_NO_TRUNC, BYTES_PER_XDR_UNIT, xdr_bool,
                NULL, "fattr4_no_trunc" },

        { FATTR4_NUMLINKS_MASK, AT_NLINK, FALSE, FALSE,
                FATTR4_NUMLINKS, BYTES_PER_XDR_UNIT, xdr_u_int,
                NULL, "fattr4_numlinks" },

        { FATTR4_OWNER_MASK, AT_UID, FALSE, FALSE,
                FATTR4_OWNER, 0, xdr_utf8string,
                NULL, "fattr4_owner" },

        { FATTR4_OWNER_GROUP_MASK, AT_GID, FALSE, FALSE,
                FATTR4_OWNER_GROUP, 0, xdr_utf8string,
                NULL, "fattr4_owner_group" },

        { FATTR4_QUOTA_AVAIL_HARD_MASK, 0, FALSE, FALSE,
                FATTR4_QUOTA_AVAIL_HARD, 2 * BYTES_PER_XDR_UNIT,
                xdr_u_longlong_t,
                NULL, "fattr4_quota_avail_hard" },

        { FATTR4_QUOTA_AVAIL_SOFT_MASK, 0, FALSE, FALSE,
                FATTR4_QUOTA_AVAIL_SOFT, 2 * BYTES_PER_XDR_UNIT,
                xdr_u_longlong_t,
                NULL, "fattr4_quota_avail_soft" },

        { FATTR4_QUOTA_USED_MASK, 0, FALSE, FALSE,
                FATTR4_QUOTA_USED, 2 * BYTES_PER_XDR_UNIT, xdr_u_longlong_t,
                NULL, "fattr4_quota_used" },

        { FATTR4_RAWDEV_MASK, AT_RDEV, FALSE, FALSE,
                FATTR4_RAWDEV, 2 * BYTES_PER_XDR_UNIT, xdr_fattr4_rawdev,
                NULL, "fattr4_rawdev" },

        { FATTR4_SPACE_AVAIL_MASK, 0, TRUE, FALSE,
                FATTR4_SPACE_AVAIL, 2 * BYTES_PER_XDR_UNIT, xdr_u_longlong_t,
                NULL, "fattr4_space_avail" },

        { FATTR4_SPACE_FREE_MASK, 0, TRUE, FALSE,
                FATTR4_SPACE_FREE, 2 * BYTES_PER_XDR_UNIT, xdr_u_longlong_t,
                NULL, "fattr4_space_free" },

        { FATTR4_SPACE_TOTAL_MASK, 0, TRUE, FALSE,
                FATTR4_SPACE_TOTAL, 2 * BYTES_PER_XDR_UNIT, xdr_u_longlong_t,
                NULL, "fattr4_space_total" },

        { FATTR4_SPACE_USED_MASK, AT_NBLOCKS, FALSE, FALSE,
                FATTR4_SPACE_USED, 2 * BYTES_PER_XDR_UNIT, xdr_u_longlong_t,
                NULL, "fattr4_space_used" },

        { FATTR4_SYSTEM_MASK, 0, FALSE, FALSE,
                FATTR4_SYSTEM, BYTES_PER_XDR_UNIT, xdr_bool,
                NULL, "fattr4_system" },

        { FATTR4_TIME_ACCESS_MASK, AT_ATIME, FALSE, FALSE,
                FATTR4_TIME_ACCESS, 3 * BYTES_PER_XDR_UNIT, xdr_nfstime4,
                NULL, "fattr4_time_access" },

        { FATTR4_TIME_ACCESS_SET_MASK, AT_ATIME, FALSE, FALSE,
                FATTR4_TIME_ACCESS_SET, 4 * BYTES_PER_XDR_UNIT, xdr_settime4,
                NULL, "fattr4_time_access_set" },

        { FATTR4_TIME_BACKUP_MASK, 0, FALSE, FALSE,
                FATTR4_TIME_BACKUP, 3 * BYTES_PER_XDR_UNIT, xdr_nfstime4,
                NULL, "fattr4_time_backup" },

        { FATTR4_TIME_CREATE_MASK, 0, FALSE, FALSE,
                FATTR4_TIME_CREATE, 3 * BYTES_PER_XDR_UNIT, xdr_nfstime4,
                NULL, "fattr4_time_create" },

        { FATTR4_TIME_DELTA_MASK, 0, FALSE, FALSE,
                FATTR4_TIME_DELTA, 3 * BYTES_PER_XDR_UNIT, xdr_nfstime4,
                NULL, "fattr4_time_delta" },

        { FATTR4_TIME_METADATA_MASK, AT_CTIME, FALSE, FALSE,
                FATTR4_TIME_METADATA, 3 * BYTES_PER_XDR_UNIT, xdr_nfstime4,
                NULL, "fattr4_time_metadata" },

        { FATTR4_TIME_MODIFY_MASK, AT_MTIME, FALSE, FALSE,
                FATTR4_TIME_MODIFY, 3 * BYTES_PER_XDR_UNIT, xdr_nfstime4,
                NULL, "fattr4_time_modify" },

        { FATTR4_TIME_MODIFY_SET_MASK, AT_MTIME, FALSE, FALSE,
                FATTR4_TIME_MODIFY_SET, 4 * BYTES_PER_XDR_UNIT, xdr_settime4,
                NULL, "fattr4_time_modify_set" },

        { FATTR4_MOUNTED_ON_FILEID_MASK, AT_NODEID, FALSE, FALSE,
                FATTR4_MOUNTED_ON_FILEID, 2 * BYTES_PER_XDR_UNIT,
                xdr_u_longlong_t,
                NULL, "fattr4_mounted_on_fileid" },

        { FATTR4_SUPPATTR_EXCLCREAT_MASK_LOCAL, 0, FALSE, FALSE,
                FATTR4_MOUNTED_ON_FILEID + 1, 0, xdr_bitmap4,
                NULL, "fattr4_suppattr_exclcreat" },
};

uint_t nfs4_ntov_map_size = sizeof (nfs4_ntov_map) /
        sizeof (struct nfs4_ntov_map);