/*
 * 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 (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2013-2021 Tintri by DDN, Inc. All rights reserved.
 * Copyright 2023 RackTop Systems, Inc.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/uio.h>
#include <sys/statvfs.h>
#include <sys/vnode.h>
#include <sys/thread.h>
#include <sys/pathname.h>
#include <sys/cred.h>
#include <sys/extdirent.h>
#include <sys/nbmlock.h>
#include <sys/share.h>
#include <sys/fcntl.h>
#include <sys/priv_const.h>
#include <sys/policy.h>
#include <nfs/lm.h>

#include <smbsrv/smb_kproto.h>
#include <smbsrv/string.h>
#include <smbsrv/smb_vops.h>
#include <smbsrv/smb_fsops.h>

/*
 * CATIA support
 *
 * CATIA V4 is a UNIX product and uses characters in filenames that
 * are considered invalid by Windows. CATIA V5 is available on both
 * UNIX and Windows.  Thus, as CATIA customers migrate from V4 to V5,
 * some V4 files could become inaccessible to windows clients if the
 * filename contains the characters that are considered illegal in
 * Windows.  In order to address this issue an optional character
 * translation is applied to filenames at the smb_vop interface.
 *
 * Character Translation Table
 * ----------------------------------
 * Unix-char (v4) | Windows-char (v5)
 * ----------------------------------
 *        *       |  0x00a4  Currency Sign
 *        |       |  0x00a6  Broken Bar
 *        "       |  0x00a8  Diaeresis
 *        <       |  0x00ab  Left-Pointing Double Angle Quotation Mark
 *        >       |  0x00bb  Right-Pointing Double Angle Quotation Mark
 *        ?       |  0x00bf  Inverted Question mark
 *        :       |  0x00f7  Division Sign
 *        /       |  0x00f8  Latin Small Letter o with stroke
 *        \       |  0x00ff  Latin Small Letter Y with Diaeresis
 *
 *
 * Two lookup tables are used to perform the character translation:
 *
 * smb_catia_v5_lookup - provides the mapping between UNIX ASCII (v4)
 * characters and equivalent or translated wide characters.
 * It is indexed by the decimal value of the ASCII character (0-127).
 *
 * smb_catia_v4_lookup - provides the mapping between wide characters
 * in the range from 0x00A4 to 0x00FF and their UNIX (v4) equivalent
 * (in wide character format).  It is indexed by the decimal value of
 * the wide character (164-255) with an offset of -164.
 * If this translation produces a filename containing a '/' create, mkdir
 * or rename (to the '/' name)  operations will not be permitted. It is
 * not valid to create a filename with a '/' in it. However, if such a
 * file already exists other operations (e.g, lookup, delete, rename)
 * are permitted on it.
 */

/* number of characters mapped */
#define SMB_CATIA_NUM_MAPS              9

/* Windows Characters used in special character mapping */
#define SMB_CATIA_WIN_CURRENCY          0x00a4
#define SMB_CATIA_WIN_BROKEN_BAR        0x00a6
#define SMB_CATIA_WIN_DIAERESIS         0x00a8
#define SMB_CATIA_WIN_LEFT_ANGLE        0x00ab
#define SMB_CATIA_WIN_RIGHT_ANGLE       0x00bb
#define SMB_CATIA_WIN_INVERTED_QUESTION 0x00bf
#define SMB_CATIA_WIN_DIVISION          0x00f7
#define SMB_CATIA_WIN_LATIN_O           0x00f8
#define SMB_CATIA_WIN_LATIN_Y           0x00ff

#define SMB_CATIA_V4_LOOKUP_LOW         SMB_CATIA_WIN_CURRENCY
#define SMB_CATIA_V4_LOOKUP_UPPER       SMB_CATIA_WIN_LATIN_Y
#define SMB_CATIA_V4_LOOKUP_MAX         \
        (SMB_CATIA_V4_LOOKUP_UPPER - SMB_CATIA_V4_LOOKUP_LOW + 1)
#define SMB_CATIA_V5_LOOKUP_MAX         0x0080

typedef struct smb_catia_map
{
        unsigned char unixchar; /* v4 */
        smb_wchar_t winchar;    /* v5 */
} smb_catia_map_t;

smb_catia_map_t const catia_maps[SMB_CATIA_NUM_MAPS] =
{
        {'"',  SMB_CATIA_WIN_DIAERESIS},
        {'*',  SMB_CATIA_WIN_CURRENCY},
        {':',  SMB_CATIA_WIN_DIVISION},
        {'<',  SMB_CATIA_WIN_LEFT_ANGLE},
        {'>',  SMB_CATIA_WIN_RIGHT_ANGLE},
        {'?',  SMB_CATIA_WIN_INVERTED_QUESTION},
        {'\\', SMB_CATIA_WIN_LATIN_Y},
        {'/',  SMB_CATIA_WIN_LATIN_O},
        {'|',  SMB_CATIA_WIN_BROKEN_BAR}
};

static smb_wchar_t smb_catia_v5_lookup[SMB_CATIA_V5_LOOKUP_MAX];
static smb_wchar_t smb_catia_v4_lookup[SMB_CATIA_V4_LOOKUP_MAX];

static void smb_vop_setup_xvattr(smb_attr_t *smb_attr, xvattr_t *xvattr);
static void smb_sa_to_va_mask(uint_t sa_mask, uint_t *va_maskp);
static void smb_sa_to_va_mask_get(uint_t sa_mask, uint_t *va_maskp);
static callb_cpr_t *smb_lock_frlock_callback(flk_cb_when_t, void *);
static void smb_vop_catia_init();

extern sysid_t lm_alloc_sysidt();

#define SMB_AT_MAX      16
static const uint_t smb_attrmap[SMB_AT_MAX] = {
        0,
        AT_TYPE,
        AT_MODE,
        AT_UID,
        AT_GID,
        AT_FSID,
        AT_NODEID,
        AT_NLINK,
        AT_SIZE,
        AT_ATIME,
        AT_MTIME,
        AT_CTIME,
        AT_RDEV,
        AT_BLKSIZE,
        AT_NBLOCKS,
        AT_SEQ
};

static boolean_t        smb_vop_initialized = B_FALSE;
caller_context_t        smb_ct;

/*
 * smb_vop_init
 *
 * This function is not multi-thread safe. The caller must make sure only one
 * thread makes the call.
 */
int
smb_vop_init(void)
{
        if (smb_vop_initialized)
                return (0);
        /*
         * The caller_context will be used primarily for range locking.
         * Since the CIFS server is mapping its locks to POSIX locks,
         * only one pid is used for operations originating from the
         * CIFS server (to represent CIFS in the VOP_FRLOCK routines).
         *
         * XXX: Should smb_ct be per-zone?
         */
        smb_ct.cc_sysid = lm_alloc_sysidt();
        if (smb_ct.cc_sysid == LM_NOSYSID)
                return (ENOMEM);

        smb_ct.cc_caller_id = fs_new_caller_id();
        smb_ct.cc_pid = IGN_PID;
        smb_ct.cc_flags = 0;
        smb_vop_catia_init();

        smb_vop_initialized = B_TRUE;
        return (0);
}

/*
 * smb_vop_fini
 *
 * This function is not multi-thread safe. The caller must make sure only one
 * thread makes the call.
 */
void
smb_vop_fini(void)
{
        if (!smb_vop_initialized)
                return;

        lm_free_sysidt(smb_ct.cc_sysid);
        smb_ct.cc_pid = IGN_PID;
        smb_ct.cc_sysid = LM_NOSYSID;
        smb_vop_initialized = B_FALSE;
}

/*
 * The smb_ct will be used primarily for range locking.
 * Since the CIFS server is mapping its locks to POSIX locks,
 * only one pid is used for operations originating from the
 * CIFS server (to represent CIFS in the VOP_FRLOCK routines).
 */
int
smb_vop_open(vnode_t **vpp, int mode, cred_t *cred)
{
        return (VOP_OPEN(vpp, mode, cred, &smb_ct));
}

void
smb_vop_close(vnode_t *vp, int mode, cred_t *cred)
{
        (void) VOP_CLOSE(vp, mode, 1, (offset_t)0, cred, &smb_ct);
}

int
smb_vop_other_opens(vnode_t *vp, int mode)
{
        return (((mode & FWRITE) && vn_has_other_opens(vp, V_WRITE)) ||
            (((mode & FWRITE) == 0) && vn_is_opened(vp, V_WRITE)) ||
            ((mode & FREAD) && vn_has_other_opens(vp, V_READ)) ||
            (((mode & FREAD) == 0) && vn_is_opened(vp, V_READ)) ||
            vn_is_mapped(vp, V_RDORWR));
}

/*
 * The smb_vop_* functions have minimal knowledge of CIFS semantics and
 * serve as an interface to the VFS layer.
 *
 * Only smb_fsop_* layer functions should call smb_vop_* layer functions.
 * (Higher-level CIFS service code should never skip the smb_fsop_* layer
 * to call smb_vop_* layer functions directly.)
 */

/*
 * XXX - Extended attributes support in the file system assumed.
 * This is needed for full NT Streams functionality.
 */

int
smb_vop_read(vnode_t *vp, uio_t *uiop, int ioflag, cred_t *cr)
{
        int error;

        (void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, &smb_ct);
        error = VOP_READ(vp, uiop, ioflag, cr, &smb_ct);
        VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, &smb_ct);
        return (error);
}

int
smb_vop_write(vnode_t *vp, uio_t *uiop, int ioflag, uint32_t *lcount,
    cred_t *cr)
{
        int error;

        *lcount = uiop->uio_resid;

        uiop->uio_llimit = MAXOFFSET_T;

        (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, &smb_ct);
        error = VOP_WRITE(vp, uiop, ioflag, cr, &smb_ct);
        VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, &smb_ct);

        *lcount -= uiop->uio_resid;

        return (error);
}

int
smb_vop_ioctl(vnode_t *vp, int cmd, void *arg, cred_t *cr)
{
        int error, rval = 0;
        uint_t flags = 0;

#ifdef  FKIOCTL
        flags |= FKIOCTL;
#endif
        error = VOP_IOCTL(vp, cmd, (intptr_t)arg, (int)flags, cr,
            &rval, &smb_ct);
        if (error != 0)
                rval = error;

        return (rval);
}

/*
 * Support for zero-copy read/write
 * Request buffers and return them.
 */
int
smb_vop_reqzcbuf(vnode_t *vp, int ioflag, xuio_t *xuio, cred_t *cr)
{
        int error;

        error = VOP_REQZCBUF(vp, ioflag, xuio, cr, &smb_ct);
        return (error);
}

int
smb_vop_retzcbuf(vnode_t *vp, xuio_t *xuio, cred_t *cr)
{
        int error;

        error = VOP_RETZCBUF(vp, xuio, cr, &smb_ct);
        return (error);
}

#ifdef _KERNEL
/*
 * Determine whether this user's privileges can satisfy an ACL check.
 * Caller determines which privileges are needed.
 * srv_only determines whether all zone privileges are needed
 * (e.g. kcred/zone_kcred()).
 *
 * ZFS first checks the ACL to determine which permissions are granted.
 * It then uses privileges to satisfy any remaining permissions.
 * The ACL check can be surprisingly expensive (for example, it may require
 * going over the network if an FUID needs to be mapped to a posix ID).
 * The SMB server inverts this order for two special cases:
 * - When checking whether the SMB user has permission to traverse through a
 *   directory during lookup;
 * - When checking whether the server (kcred or zone_kcred) has permission to
 *   read attributes for internal purposes.
 * These checks happen frequently, in hot code, and nearly always succeed via
 * the privileges granted to these users. In these cases, we first check for the
 * specific privilege that would satisfy the required access, then skip the
 * access check when the caller has that privilege.
 * See zfs_zaccess() and its calls to secpolicy_vnode_access2() for how
 * v4 accesses are mapped onto privileges.
 */
boolean_t
smb_vop_priv_check(cred_t *cr, int priv, boolean_t srv_only, vnode_t *vp)
{
        return (PRIV_POLICY_ONLY(cr, priv, srv_only) &&
            vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS));
}
#endif

/*
 * smb_vop_getattr()
 *
 * smb_fsop_getattr()/smb_vop_getattr() should always be called from the CIFS
 * service (instead of calling VOP_GETATTR directly) to retrieve attributes
 * due to special processing needed for streams files.
 *
 * All attributes are retrieved.
 *
 * When vp denotes a named stream, then unnamed_vp should be passed in (denoting
 * the corresponding unnamed stream).
 * A named stream's attributes (as far as CIFS is concerned) are those of the
 * unnamed stream (minus the size attribute, and the type), plus  the size of
 * the named stream, and a type value of VREG.
 * Although the file system may store other attributes with the named stream,
 * these should not be used by CIFS for any purpose.
 *
 * File systems without VFSFT_XVATTR do not support DOS attributes or create
 * time (crtime). In this case the mtime is used as the crtime.
 * Likewise if VOP_GETATTR doesn't return any system attributes the dosattr
 * is 0 and the mtime is used as the crtime.
 */
int
smb_vop_getattr(vnode_t *vp, vnode_t *unnamed_vp, smb_attr_t *ret_attr,
    int flags, cred_t *cr)
{
        int error;
        vnode_t *use_vp;
        xvattr_t tmp_xvattr;
        xoptattr_t *xoap = NULL;

        if (unnamed_vp)
                use_vp = unnamed_vp;
        else
                use_vp = vp;

#ifdef _KERNEL
        /* Avoid potentially expensive access checks for non-client queries. */
        if (smb_vop_priv_check(cr, PRIV_FILE_DAC_READ, B_TRUE, use_vp))
                flags |= ATTR_NOACLCHECK;
#endif

        if (vfs_has_feature(use_vp->v_vfsp, VFSFT_XVATTR)) {
                xva_init(&tmp_xvattr);
                xoap = xva_getxoptattr(&tmp_xvattr);
                ASSERT(xoap);

                smb_sa_to_va_mask_get(ret_attr->sa_mask,
                    &tmp_xvattr.xva_vattr.va_mask);

                XVA_SET_REQ(&tmp_xvattr, XAT_READONLY);
                XVA_SET_REQ(&tmp_xvattr, XAT_HIDDEN);
                XVA_SET_REQ(&tmp_xvattr, XAT_SYSTEM);
                XVA_SET_REQ(&tmp_xvattr, XAT_ARCHIVE);
                XVA_SET_REQ(&tmp_xvattr, XAT_CREATETIME);
                XVA_SET_REQ(&tmp_xvattr, XAT_REPARSE);
                XVA_SET_REQ(&tmp_xvattr, XAT_OFFLINE);
                XVA_SET_REQ(&tmp_xvattr, XAT_SPARSE);

                error = VOP_GETATTR(use_vp, &tmp_xvattr.xva_vattr, flags,
                    cr, &smb_ct);
                if (error != 0)
                        return (error);

                ret_attr->sa_vattr = tmp_xvattr.xva_vattr;
                ret_attr->sa_dosattr = 0;

                if (tmp_xvattr.xva_vattr.va_mask & AT_XVATTR) {
                        xoap = xva_getxoptattr(&tmp_xvattr);
                        ASSERT(xoap);

                        if ((XVA_ISSET_RTN(&tmp_xvattr, XAT_READONLY)) &&
                            (xoap->xoa_readonly)) {
                                ret_attr->sa_dosattr |= FILE_ATTRIBUTE_READONLY;
                        }

                        if ((XVA_ISSET_RTN(&tmp_xvattr, XAT_HIDDEN)) &&
                            (xoap->xoa_hidden)) {
                                ret_attr->sa_dosattr |= FILE_ATTRIBUTE_HIDDEN;
                        }

                        if ((XVA_ISSET_RTN(&tmp_xvattr, XAT_SYSTEM)) &&
                            (xoap->xoa_system)) {
                                ret_attr->sa_dosattr |= FILE_ATTRIBUTE_SYSTEM;
                        }

                        if ((XVA_ISSET_RTN(&tmp_xvattr, XAT_ARCHIVE)) &&
                            (xoap->xoa_archive)) {
                                ret_attr->sa_dosattr |= FILE_ATTRIBUTE_ARCHIVE;
                        }

                        if ((XVA_ISSET_RTN(&tmp_xvattr, XAT_REPARSE)) &&
                            (xoap->xoa_reparse)) {
                                ret_attr->sa_dosattr |=
                                    FILE_ATTRIBUTE_REPARSE_POINT;
                        }

                        if ((XVA_ISSET_RTN(&tmp_xvattr, XAT_OFFLINE)) &&
                            (xoap->xoa_offline)) {
                                ret_attr->sa_dosattr |= FILE_ATTRIBUTE_OFFLINE;
                        }

                        if ((XVA_ISSET_RTN(&tmp_xvattr, XAT_SPARSE)) &&
                            (xoap->xoa_sparse)) {
                                ret_attr->sa_dosattr |=
                                    FILE_ATTRIBUTE_SPARSE_FILE;
                        }

                        ret_attr->sa_crtime = xoap->xoa_createtime;
                } else {
                        ret_attr->sa_crtime = ret_attr->sa_vattr.va_mtime;
                }
        } else {
                /*
                 * Support for file systems without VFSFT_XVATTR
                 */
                smb_sa_to_va_mask_get(ret_attr->sa_mask,
                    &ret_attr->sa_vattr.va_mask);

                error = VOP_GETATTR(use_vp, &ret_attr->sa_vattr,
                    flags, cr, &smb_ct);
                if (error != 0)
                        return (error);

                ret_attr->sa_dosattr = 0;
                ret_attr->sa_crtime = ret_attr->sa_vattr.va_mtime;
        }

        if (unnamed_vp) {
                /*
                 * vp is a named stream under "unnamed_vp"
                 * Need to get the size from vp (not use_vp)
                 */
                smb_attr_t tmp_attr;
                ret_attr->sa_vattr.va_type = VREG;

                if (ret_attr->sa_mask &
                    (SMB_AT_SIZE | SMB_AT_NBLOCKS | SMB_AT_ALLOCSZ)) {
                        tmp_attr.sa_vattr.va_mask = AT_SIZE | AT_NBLOCKS;

                        /*
                         * Keep ATTR_NOACLCHECK from use_vp; if it's good for
                         * the file, it's good for the xattr.
                         */
                        error = VOP_GETATTR(vp, &tmp_attr.sa_vattr,
                            flags, cr, &smb_ct);
                        if (error != 0)
                                return (error);

                        ret_attr->sa_vattr.va_size = tmp_attr.sa_vattr.va_size;
                        ret_attr->sa_vattr.va_nblocks =
                            tmp_attr.sa_vattr.va_nblocks;
                }
        }

        /*
         * Override a few things so they're as SMB expects.
         * SMB allocsz is always zero for directories.
         * For plain files, allocsz is the larger of:
         * size, allocsize  (See smb_node_getattr)
         */
        if (ret_attr->sa_vattr.va_type == VDIR) {
                ret_attr->sa_dosattr |= FILE_ATTRIBUTE_DIRECTORY;
                /* SMB expectes directories to have... */
                ret_attr->sa_vattr.va_nlink = 1;
                ret_attr->sa_vattr.va_size = 0;
                ret_attr->sa_allocsz = 0;
        } else {
                if (ret_attr->sa_dosattr == 0)
                        ret_attr->sa_dosattr = FILE_ATTRIBUTE_NORMAL;
                if ((ret_attr->sa_mask & SMB_AT_ALLOCSZ) != 0) {
                        /*
                         * ZFS includes meta-data in va_nblocks.
                         * Special case zero to keep tests happy.
                         */
                        if (ret_attr->sa_vattr.va_size == 0 &&
                            ret_attr->sa_vattr.va_nblocks == 1)
                                ret_attr->sa_allocsz = 0;
                        else
                                ret_attr->sa_allocsz =
                                    ret_attr->sa_vattr.va_nblocks * DEV_BSIZE;
                        if (ret_attr->sa_allocsz < ret_attr->sa_vattr.va_size) {
                                ret_attr->sa_allocsz = P2ROUNDUP(
                                    ret_attr->sa_vattr.va_size, DEV_BSIZE);
                        }
                }
        }

        return (error);
}

/*
 * smb_vop_setattr()
 *
 * smb_fsop_setattr()/smb_vop_setattr() should always be used instead of
 * VOP_SETATTR() when calling from the CIFS service, due to special processing
 * for streams files.
 *
 * Streams have a size but otherwise do not have separate attributes from
 * the (unnamed stream) file, i.e., the security and ownership of the file
 * applies to the stream.  In contrast, extended attribute files, which are
 * used to implement streams, are independent objects with their own
 * attributes.
 *
 * For compatibility with streams, we set the size on the extended attribute
 * file and apply other attributes to the (unnamed stream) file.  The one
 * exception is that the UID and GID can be set on the stream by passing a
 * NULL unnamed_vp, which allows callers to synchronize stream ownership
 * with the (unnamed stream) file.
 */
int
smb_vop_setattr(vnode_t *vp, vnode_t *unnamed_vp, smb_attr_t *attr,
    int flags, cred_t *cr)
{
        int error = 0;
        int at_size = 0;
        vnode_t *use_vp;
        xvattr_t xvattr;
        vattr_t *vap;

        if (attr->sa_mask & SMB_AT_DOSATTR) {
                attr->sa_dosattr &=
                    (FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_READONLY |
                    FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM |
                    FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_SPARSE_FILE);
        }

        if (unnamed_vp) {
                use_vp = unnamed_vp;
                if (attr->sa_mask & SMB_AT_SIZE) {
                        at_size = 1;
                        attr->sa_mask &= ~SMB_AT_SIZE;
                }
        } else {
                use_vp = vp;
        }

        /*
         * The caller should not be setting sa_vattr.va_mask,
         * but rather sa_mask.
         */

        attr->sa_vattr.va_mask = 0;

        if (vfs_has_feature(use_vp->v_vfsp, VFSFT_XVATTR)) {
                smb_vop_setup_xvattr(attr, &xvattr);
                vap = &xvattr.xva_vattr;
        } else {
                smb_sa_to_va_mask(attr->sa_mask,
                    &attr->sa_vattr.va_mask);
                vap = &attr->sa_vattr;
        }

        if ((error = VOP_SETATTR(use_vp, vap, flags, cr, &smb_ct)) != 0)
                return (error);

        if (at_size) {
                attr->sa_vattr.va_mask = AT_SIZE;
                error = VOP_SETATTR(vp, &attr->sa_vattr, flags,
                    zone_kcred(), &smb_ct);
        }

        return (error);
}

int
smb_vop_space(vnode_t *vp, int cmd, flock64_t *bfp, int flags,
    offset_t offset, cred_t *cr)
{
        int error;

        error = VOP_SPACE(vp, cmd, bfp, flags, offset, cr, &smb_ct);

        return (error);
}

/*
 * smb_vop_access
 *
 * This is a wrapper round VOP_ACCESS. VOP_ACCESS checks the given mode
 * against file's ACL or Unix permissions. CIFS on the other hand needs to
 * know if the requested operation can succeed for the given object, this
 * requires more checks in case of DELETE bit since permissions on the parent
 * directory are important as well. Based on Windows rules if parent's ACL
 * grant FILE_DELETE_CHILD a file can be delete regardless of the file's
 * permissions.
 */
int
smb_vop_access(vnode_t *vp, int mode, int flags, vnode_t *dir_vp, cred_t *cr)
{
        int error = 0;

        if (mode == 0)
                return (0);

        error = VOP_ACCESS(vp, mode, flags, cr, NULL);

        if (error == 0)
                return (0);

        if ((mode & (ACE_DELETE|ACE_READ_ATTRIBUTES)) == 0 ||
            flags != V_ACE_MASK || dir_vp == NULL)
                return (error);

        if ((mode & ACE_DELETE) != 0) {
                error = VOP_ACCESS(dir_vp, ACE_DELETE_CHILD, flags,
                    cr, NULL);

                if (error == 0)
                        mode &= ~ACE_DELETE;
        }
        if ((mode & ACE_READ_ATTRIBUTES) != 0) {
                error = VOP_ACCESS(dir_vp, ACE_LIST_DIRECTORY, flags,
                    cr, NULL);

                if (error == 0)
                        mode &= ~ACE_READ_ATTRIBUTES;
        }

        if (mode != 0)
                error = VOP_ACCESS(vp, mode, flags, cr, NULL);

        return (error);
}

/*
 * smb_vop_lookup
 *
 * dvp:         directory vnode (in)
 * name:        name of file to be looked up (in)
 * vpp:         looked-up vnode (out)
 * od_name:     on-disk name of file (out).
 *              This parameter is optional.  If a pointer is passed in, it
 *              must be allocated with MAXNAMELEN bytes
 * rootvp:      vnode of the tree root (in)
 *              This parameter is always passed in non-NULL except at the time
 *              of share set up.
 * direntflags: dirent flags returned from VOP_LOOKUP
 */
int
smb_vop_lookup(
    vnode_t             *dvp,
    char                *name,
    vnode_t             **vpp,
    char                *od_name,
    int                 flags,
    int                 *direntflags,
    vnode_t             *rootvp,
    smb_attr_t          *attr,
    cred_t              *cr)
{
        int error = 0;
        int option_flags = 0;
        pathname_t rpn;
        char *np = name;
        char namebuf[MAXNAMELEN];

        if (*name == '\0') {
                /*
                 * This happens creating named streams at the share root.
                 */
                VN_HOLD(dvp);
                *vpp = dvp;
                goto attr_out;
        }

        ASSERT(vpp);
        *vpp = NULL;
        *direntflags = 0;

        if ((name[0] == '.') && (name[1] == '.') && (name[2] == 0)) {
                if (rootvp && (dvp == rootvp)) {
                        VN_HOLD(dvp);
                        *vpp = dvp;
                        goto attr_out;
                }

                if (dvp->v_flag & VROOT) {
                        vfs_t *vfsp;
                        vnode_t *cvp = dvp;

                        /*
                         * Set dvp and check for races with forced unmount
                         * (see lookuppnvp())
                         */

                        vfsp = cvp->v_vfsp;
                        vfs_rlock_wait(vfsp);
                        if (((dvp = cvp->v_vfsp->vfs_vnodecovered) == NULL) ||
                            (cvp->v_vfsp->vfs_flag & VFS_UNMOUNTED)) {
                                vfs_unlock(vfsp);
                                return (EIO);
                        }
                        vfs_unlock(vfsp);
                }
        }

        if (flags & SMB_IGNORE_CASE)
                option_flags = FIGNORECASE;

        if (flags & SMB_CATIA)
                np = smb_vop_catia_v5tov4(name, namebuf, sizeof (namebuf));

#ifdef _KERNEL
        /*
         * The SMB server enables BYPASS_TRAVERSE_CHECKING by default.
         * This grants PRIV_FILE_DAC_SEARCH to all users.
         * If the user has this privilege, we'll always succeed ACE_EXECUTE
         * checks on directories, so skip the (potentially expensive)
         * ACL check.
         */
        if (smb_vop_priv_check(cr, PRIV_FILE_DAC_SEARCH, B_FALSE, dvp))
                option_flags |= LOOKUP_NOACLCHECK;
#endif
        pn_alloc(&rpn);

        /*
         * Easier to not have junk in rpn, as not every FS type
         * will necessarily fill that in for us.
         */
        bzero(rpn.pn_buf, rpn.pn_bufsize);

        error = VOP_LOOKUP(dvp, np, vpp, NULL, option_flags, NULL, cr,
            &smb_ct, direntflags, &rpn);

        if (error == 0 && od_name != NULL) {
                bzero(od_name, MAXNAMELEN);
                if ((option_flags & FIGNORECASE) != 0 &&
                    rpn.pn_buf[0] != '\0')
                        np = rpn.pn_buf;
                else
                        np = name;
                if (flags & SMB_CATIA)
                        smb_vop_catia_v4tov5(np, od_name, MAXNAMELEN);
                else
                        (void) strlcpy(od_name, np, MAXNAMELEN);
        }
        pn_free(&rpn);

attr_out:
        if (error == 0 && attr != NULL) {
                attr->sa_mask = SMB_AT_ALL;
                (void) smb_vop_getattr(*vpp, NULL, attr, 0,
                    zone_kcred());
        }

        return (error);
}

int
smb_vop_create(vnode_t *dvp, char *name, smb_attr_t *attr, vnode_t **vpp,
    int flags, cred_t *cr, vsecattr_t *vsap)
{
        int error;
        int option_flags = 0;
        xvattr_t xvattr;
        vattr_t *vap;
        char *np = name;
        char namebuf[MAXNAMELEN];

        if (flags & SMB_IGNORE_CASE)
                option_flags = FIGNORECASE;

        attr->sa_vattr.va_mask = 0;

        if (vfs_has_feature(dvp->v_vfsp, VFSFT_XVATTR)) {
                smb_vop_setup_xvattr(attr, &xvattr);
                vap = &xvattr.xva_vattr;
        } else {
                smb_sa_to_va_mask(attr->sa_mask, &attr->sa_vattr.va_mask);
                vap = &attr->sa_vattr;
        }

        if (flags & SMB_CATIA) {
                np = smb_vop_catia_v5tov4(name, namebuf, sizeof (namebuf));
                if (strchr(np, '/') != NULL)
                        return (EILSEQ);
        }

        error = VOP_CREATE(dvp, np, vap, EXCL, attr->sa_vattr.va_mode,
            vpp, cr, option_flags, &smb_ct, vsap);

        /*
         * One could argue that filesystems should obey the size
         * if specified in the create attributes.  Unfortunately,
         * they only appear to let you truncate the size to zero.
         * SMB needs to set a non-zero size, so work-around.
         */
        if (error == 0 && *vpp != NULL &&
            (vap->va_mask & AT_SIZE) != 0 &&
            vap->va_size > 0) {
                vattr_t ta = *vap;
                ta.va_mask = AT_SIZE;
                (void) VOP_SETATTR(*vpp, &ta, 0, cr, &smb_ct);
        }

        return (error);
}

int
smb_vop_remove(vnode_t *dvp, char *name, int flags, cred_t *cr)
{
        int error;
        int option_flags = 0;
        char *np = name;
        char namebuf[MAXNAMELEN];

        if (flags & SMB_IGNORE_CASE)
                option_flags = FIGNORECASE;

        if (flags & SMB_CATIA)
                np = smb_vop_catia_v5tov4(name, namebuf, sizeof (namebuf));

        error = VOP_REMOVE(dvp, np, cr, &smb_ct, option_flags);

        return (error);
}

/*
 * smb_vop_link(target-dir-vp, source-file-vp, target-name)
 *
 * Create a link - same tree (identical TID) only.
 */
int
smb_vop_link(vnode_t *to_dvp, vnode_t *from_vp, char *to_name,
    int flags, cred_t *cr)
{
        int option_flags = 0;
        char *np, *buf;
        int rc;

        if (flags & SMB_IGNORE_CASE)
                option_flags = FIGNORECASE;

        if (flags & SMB_CATIA) {
                buf = kmem_zalloc(MAXNAMELEN, KM_SLEEP);
                np = smb_vop_catia_v5tov4(to_name, buf, MAXNAMELEN);
                if (strchr(np, '/') != NULL) {
                        kmem_free(buf, MAXNAMELEN);
                        return (EILSEQ);
                }

                rc = VOP_LINK(to_dvp, from_vp, np, cr, &smb_ct, option_flags);
                kmem_free(buf, MAXNAMELEN);
                return (rc);
        }

        rc = VOP_LINK(to_dvp, from_vp, to_name, cr, &smb_ct, option_flags);
        return (rc);
}

/*
 * smb_vop_rename()
 *
 * The rename is for files in the same tree (identical TID) only.
 */
int
smb_vop_rename(vnode_t *from_dvp, char *from_name, vnode_t *to_dvp,
    char *to_name, int flags, cred_t *cr)
{
        int error;
        int option_flags = 0;
        char *from, *to, *fbuf, *tbuf;

        if (flags & SMB_IGNORE_CASE)
                option_flags = FIGNORECASE;

        if (flags & SMB_CATIA) {
                tbuf = kmem_zalloc(MAXNAMELEN, KM_SLEEP);
                to = smb_vop_catia_v5tov4(to_name, tbuf, MAXNAMELEN);
                if (strchr(to, '/') != NULL) {
                        kmem_free(tbuf, MAXNAMELEN);
                        return (EILSEQ);
                }

                fbuf = kmem_zalloc(MAXNAMELEN, KM_SLEEP);
                from = smb_vop_catia_v5tov4(from_name, fbuf, MAXNAMELEN);

                error = VOP_RENAME(from_dvp, from, to_dvp, to, cr,
                    &smb_ct, option_flags);

                kmem_free(tbuf, MAXNAMELEN);
                kmem_free(fbuf, MAXNAMELEN);
                return (error);
        }

        error = VOP_RENAME(from_dvp, from_name, to_dvp, to_name, cr,
            &smb_ct, option_flags);

        return (error);
}

int
smb_vop_mkdir(vnode_t *dvp, char *name, smb_attr_t *attr, vnode_t **vpp,
    int flags, cred_t *cr, vsecattr_t *vsap)
{
        int error;
        int option_flags = 0;
        xvattr_t xvattr;
        vattr_t *vap;
        char *np = name;
        char namebuf[MAXNAMELEN];

        if (flags & SMB_IGNORE_CASE)
                option_flags = FIGNORECASE;

        attr->sa_vattr.va_mask = 0;

        if (vfs_has_feature(dvp->v_vfsp, VFSFT_XVATTR)) {
                smb_vop_setup_xvattr(attr, &xvattr);
                vap = &xvattr.xva_vattr;
        } else {
                smb_sa_to_va_mask(attr->sa_mask, &attr->sa_vattr.va_mask);
                vap = &attr->sa_vattr;
        }

        if (flags & SMB_CATIA) {
                np = smb_vop_catia_v5tov4(name, namebuf, sizeof (namebuf));
                if (strchr(np, '/') != NULL)
                        return (EILSEQ);
        }

        error = VOP_MKDIR(dvp, np, vap, vpp, cr, &smb_ct, option_flags, vsap);

        return (error);
}

/*
 * smb_vop_rmdir()
 *
 * Only simple rmdir supported, consistent with NT semantics
 * (can only remove an empty directory).
 *
 * The third argument to VOP_RMDIR  is the current directory of
 * the process.  It allows rmdir wants to EINVAL if one tries to
 * remove ".".  Since SMB servers do not know what their clients'
 * current directories are, we fake it by supplying a vnode known
 * to exist and illegal to remove (rootdir).
 */
int
smb_vop_rmdir(vnode_t *dvp, char *name, int flags, cred_t *cr)
{
        int error;
        int option_flags = 0;
        char *np = name;
        char namebuf[MAXNAMELEN];

        if (flags & SMB_IGNORE_CASE)
                option_flags = FIGNORECASE;

        if (flags & SMB_CATIA)
                np = smb_vop_catia_v5tov4(name, namebuf, sizeof (namebuf));

        error = VOP_RMDIR(dvp, np, rootdir, cr, &smb_ct, option_flags);
        return (error);
}

int
smb_vop_commit(vnode_t *vp, cred_t *cr)
{
        return (VOP_FSYNC(vp, 1, cr, &smb_ct));
}

/*
 * Some code in smb_node.c needs to know which DOS attributes
 * we can actually store.  Let's define a mask here of all the
 * DOS attribute flags supported by the following function.
 */
const uint32_t
smb_vop_dosattr_settable =
        FILE_ATTRIBUTE_ARCHIVE |
        FILE_ATTRIBUTE_SYSTEM |
        FILE_ATTRIBUTE_HIDDEN |
        FILE_ATTRIBUTE_READONLY |
        FILE_ATTRIBUTE_OFFLINE |
        FILE_ATTRIBUTE_SPARSE_FILE;

static void
smb_vop_setup_xvattr(smb_attr_t *smb_attr, xvattr_t *xvattr)
{
        xoptattr_t *xoap = NULL;
        uint_t xva_mask;

        /*
         * Initialize xvattr, including bzero
         */
        xva_init(xvattr);
        xoap = xva_getxoptattr(xvattr);

        ASSERT(xoap);

        /*
         * Copy caller-specified classic attributes to xvattr.
         * First save xvattr's mask (set in xva_init()), which
         * contains AT_XVATTR.  This is |'d in later if needed.
         */

        xva_mask = xvattr->xva_vattr.va_mask;
        xvattr->xva_vattr = smb_attr->sa_vattr;

        smb_sa_to_va_mask(smb_attr->sa_mask, &xvattr->xva_vattr.va_mask);

        /*
         * Do not set ctime (only the file system can do it)
         */

        xvattr->xva_vattr.va_mask &= ~AT_CTIME;

        if (smb_attr->sa_mask & SMB_AT_DOSATTR) {

                /*
                 * "|" in the original xva_mask, which contains
                 * AT_XVATTR
                 */

                xvattr->xva_vattr.va_mask |= xva_mask;

                XVA_SET_REQ(xvattr, XAT_ARCHIVE);
                XVA_SET_REQ(xvattr, XAT_SYSTEM);
                XVA_SET_REQ(xvattr, XAT_READONLY);
                XVA_SET_REQ(xvattr, XAT_HIDDEN);
                XVA_SET_REQ(xvattr, XAT_OFFLINE);
                XVA_SET_REQ(xvattr, XAT_SPARSE);

                /*
                 * smb_attr->sa_dosattr: If a given bit is not set,
                 * that indicates that the corresponding field needs
                 * to be updated with a "0" value.  This is done
                 * implicitly as the xoap->xoa_* fields were bzero'd.
                 */

                if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_ARCHIVE)
                        xoap->xoa_archive = 1;

                if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_SYSTEM)
                        xoap->xoa_system = 1;

                if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_READONLY)
                        xoap->xoa_readonly = 1;

                if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_HIDDEN)
                        xoap->xoa_hidden = 1;

                if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_OFFLINE)
                        xoap->xoa_offline = 1;

                if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_SPARSE_FILE)
                        xoap->xoa_sparse = 1;
        }

        if (smb_attr->sa_mask & SMB_AT_CRTIME) {
                /*
                 * "|" in the original xva_mask, which contains
                 * AT_XVATTR
                 */

                xvattr->xva_vattr.va_mask |= xva_mask;
                XVA_SET_REQ(xvattr, XAT_CREATETIME);
                xoap->xoa_createtime = smb_attr->sa_crtime;
        }
}

/*
 * smb_vop_readdir()
 *
 * Collects an SMB_MINLEN_RDDIR_BUF "page" of directory entries.
 * The directory entries are returned in an fs-independent format by the
 * underlying file system.  That is, the "page" of information returned is
 * not literally stored on-disk in the format returned.
 * If the file system supports extended directory entries (has features
 * VFSFT_DIRENTFLAGS), set V_RDDIR_ENTFLAGS to cause the buffer to be
 * filled with edirent_t structures, instead of dirent64_t structures.
 * If the file system supports access based enumeration (abe), set
 * V_RDDIR_ACCFILTER to filter directory entries based on user cred.
 */
int
smb_vop_readdir(vnode_t *vp, uint32_t offset,
    void *buf, int *count, int *eof, uint32_t rddir_flag, cred_t *cr)
{
        int error = 0;
        int flags = 0;
        int rdirent_size;
        struct uio auio;
        struct iovec aiov;

        if (vp->v_type != VDIR)
                return (ENOTDIR);

        if ((rddir_flag & SMB_EDIRENT) != 0 &&
            vfs_has_feature(vp->v_vfsp, VFSFT_DIRENTFLAGS)) {
                flags |= V_RDDIR_ENTFLAGS;
                rdirent_size = sizeof (edirent_t);
        } else {
                rdirent_size = sizeof (dirent64_t);
        }

        if (*count < rdirent_size)
                return (EINVAL);

        if (rddir_flag & SMB_ABE)
                flags |= V_RDDIR_ACCFILTER;

        aiov.iov_base = buf;
        aiov.iov_len = *count;
        auio.uio_iov = &aiov;
        auio.uio_iovcnt = 1;
        auio.uio_loffset = (uint64_t)offset;
        auio.uio_segflg = UIO_SYSSPACE;
        auio.uio_extflg = UIO_COPY_DEFAULT;
        auio.uio_resid = *count;
        auio.uio_fmode = 0;

        (void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, &smb_ct);
        error = VOP_READDIR(vp, &auio, cr, eof, &smb_ct, flags);
        VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, &smb_ct);

        if (error == 0)
                *count = *count - auio.uio_resid;

        return (error);
}

/*
 * smb_sa_to_va_mask
 *
 * Set va_mask by running through the SMB_AT_* #define's and
 * setting those bits that correspond to the SMB_AT_* bits
 * set in sa_mask.
 */
void
smb_sa_to_va_mask(uint_t sa_mask, uint_t *va_maskp)
{
        int i;
        uint_t smask;

        smask = (sa_mask);
        for (i = SMB_AT_TYPE; (i < SMB_AT_MAX) && (smask != 0); ++i) {
                if (smask & 1)
                        *(va_maskp) |= smb_attrmap[i];

                smask >>= 1;
        }
}

/*
 * Variant of smb_sa_to_va_mask for vop_getattr,
 * adding some bits for SMB_AT_ALLOCSZ etc.
 */
void
smb_sa_to_va_mask_get(uint_t sa_mask, uint_t *va_maskp)
{
        smb_sa_to_va_mask(sa_mask, va_maskp);

        *va_maskp |= AT_TYPE;
        if ((sa_mask & SMB_AT_ALLOCSZ) != 0) {
                *va_maskp |= (AT_SIZE | AT_NBLOCKS);
        }
}

/*
 * smb_vop_stream_lookup()
 *
 * The name returned in od_name is the on-disk name of the stream with the
 * SMB_STREAM_PREFIX stripped off.  od_name should be allocated to MAXNAMELEN
 * by the caller.
 */
int
smb_vop_stream_lookup(
    vnode_t             *fvp,
    char                *stream_name,
    vnode_t             **vpp,
    char                *od_name,
    vnode_t             **xattrdirvpp,
    int                 flags,
    vnode_t             *rootvp,
    cred_t              *cr)
{
        char *solaris_stream_name;
        char *name;
        int error, tmpflgs;

        if ((error = smb_vop_lookup_xattrdir(fvp, xattrdirvpp,
            LOOKUP_XATTR | CREATE_XATTR_DIR, cr)) != 0)
                return (error);

        /*
         * Prepend SMB_STREAM_PREFIX to stream name
         */

        solaris_stream_name = kmem_alloc(MAXNAMELEN, KM_SLEEP);
        (void) snprintf(solaris_stream_name, MAXNAMELEN,
            "%s%s", SMB_STREAM_PREFIX, stream_name);

        /*
         * "name" will hold the on-disk name returned from smb_vop_lookup
         * for the stream, including the SMB_STREAM_PREFIX.
         */

        name = kmem_zalloc(MAXNAMELEN, KM_SLEEP);

        if ((error = smb_vop_lookup(*xattrdirvpp, solaris_stream_name, vpp,
            name, flags, &tmpflgs, rootvp, NULL, cr)) != 0) {
                VN_RELE(*xattrdirvpp);
        } else {
                (void) strlcpy(od_name, &(name[SMB_STREAM_PREFIX_LEN]),
                    MAXNAMELEN);
        }

        kmem_free(solaris_stream_name, MAXNAMELEN);
        kmem_free(name, MAXNAMELEN);

        return (error);
}

int
smb_vop_stream_create(vnode_t *fvp, char *stream_name, smb_attr_t *attr,
    vnode_t **vpp, vnode_t **xattrdirvpp, int flags, cred_t *cr)
{
        char *solaris_stream_name;
        int error;

        if ((error = smb_vop_lookup_xattrdir(fvp, xattrdirvpp,
            LOOKUP_XATTR | CREATE_XATTR_DIR, cr)) != 0)
                return (error);

        /*
         * Prepend SMB_STREAM_PREFIX to stream name
         */

        solaris_stream_name = kmem_alloc(MAXNAMELEN, KM_SLEEP);
        (void) snprintf(solaris_stream_name, MAXNAMELEN,
            "%s%s", SMB_STREAM_PREFIX, stream_name);

        if ((error = smb_vop_create(*xattrdirvpp, solaris_stream_name, attr,
            vpp, flags, cr, NULL)) != 0)
                VN_RELE(*xattrdirvpp);

        kmem_free(solaris_stream_name, MAXNAMELEN);

        return (error);
}

int
smb_vop_stream_remove(vnode_t *vp, char *stream_name, int flags, cred_t *cr)
{
        char *solaris_stream_name;
        vnode_t *xattrdirvp;
        int error;

        error = smb_vop_lookup_xattrdir(vp, &xattrdirvp, LOOKUP_XATTR, cr);
        if (error != 0)
                return (error);

        /*
         * Prepend SMB_STREAM_PREFIX to stream name
         */

        solaris_stream_name = kmem_alloc(MAXNAMELEN, KM_SLEEP);
        (void) snprintf(solaris_stream_name, MAXNAMELEN,
            "%s%s", SMB_STREAM_PREFIX, stream_name);

        /* XXX might have to use kcred */
        error = smb_vop_remove(xattrdirvp, solaris_stream_name, flags, cr);

        kmem_free(solaris_stream_name, MAXNAMELEN);
        VN_RELE(xattrdirvp);

        return (error);
}

int
smb_vop_lookup_xattrdir(vnode_t *fvp, vnode_t **xattrdirvpp, int flags,
    cred_t *cr)
{
        int error;

        error = VOP_LOOKUP(fvp, "", xattrdirvpp, NULL, flags, NULL, cr,
            &smb_ct, NULL, NULL);
        return (error);
}

/*
 * smb_vop_traverse_check()
 *
 * This function checks to see if the passed-in vnode has a file system
 * mounted on it.  If it does, the mount point is "traversed" and the
 * vnode for the root of the file system is returned.
 */
int
smb_vop_traverse_check(vnode_t **vpp)
{
        int error;

        if (vn_mountedvfs(*vpp) == 0)
                return (0);

        /*
         * traverse() may return a different held vnode, even in the error case.
         * If it returns a different vnode, it will have released the original.
         */

        error = traverse(vpp);

        return (error);
}

int /*ARGSUSED*/
smb_vop_statfs(vnode_t *vp, struct statvfs64 *statp, cred_t *cr)
{
        int error;

        error = VFS_STATVFS(vp->v_vfsp, statp);

        return (error);
}

/*
 * smb_vop_acl_read
 *
 * Reads the ACL of the specified file into 'aclp'.
 * acl_type is the type of ACL which the filesystem supports.
 *
 * Caller has to free the allocated memory for aclp by calling
 * acl_free().
 */
int
smb_vop_acl_read(vnode_t *vp, acl_t **aclp, int flags, acl_type_t acl_type,
    cred_t *cr)
{
        int error;
        vsecattr_t vsecattr;

        ASSERT(vp);
        ASSERT(aclp);

        *aclp = NULL;
        bzero(&vsecattr, sizeof (vsecattr_t));

        switch (acl_type) {
        case ACLENT_T:
                vsecattr.vsa_mask = VSA_ACL | VSA_ACLCNT | VSA_DFACL |
                    VSA_DFACLCNT;
                break;

        case ACE_T:
                vsecattr.vsa_mask = VSA_ACE | VSA_ACECNT | VSA_ACE_ACLFLAGS;
                break;

        default:
                return (EINVAL);
        }

        if ((error = VOP_GETSECATTR(vp, &vsecattr, flags, cr, &smb_ct)) != 0)
                return (error);

        *aclp = smb_fsacl_from_vsa(&vsecattr, acl_type);
        if (vp->v_type == VDIR)
                (*aclp)->acl_flags |= ACL_IS_DIR;

        return (0);
}

/*
 * smb_vop_acl_write
 *
 * Writes the given ACL in aclp for the specified file.
 */
int
smb_vop_acl_write(vnode_t *vp, acl_t *aclp, int flags, cred_t *cr)
{
        int error;
        vsecattr_t vsecattr;
        int aclbsize;

        ASSERT(vp);
        ASSERT(aclp);

        error = smb_fsacl_to_vsa(aclp, &vsecattr, &aclbsize);

        if (error == 0) {
                (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, &smb_ct);
                error = VOP_SETSECATTR(vp, &vsecattr, flags, cr, &smb_ct);
                VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, &smb_ct);
        }

        if (aclbsize && vsecattr.vsa_aclentp)
                kmem_free(vsecattr.vsa_aclentp, aclbsize);

        return (error);
}

/*
 * smb_vop_acl_type
 *
 * Determines the ACL type for the given vnode.
 * ACLENT_T is a Posix ACL and ACE_T is a ZFS ACL.
 */
acl_type_t
smb_vop_acl_type(vnode_t *vp)
{
        int error;
        ulong_t whichacl;

        error = VOP_PATHCONF(vp, _PC_ACL_ENABLED, &whichacl,
            zone_kcred(), NULL);
        if (error != 0) {
                /*
                 * If we got an error, then the filesystem
                 * likely does not understand the _PC_ACL_ENABLED
                 * pathconf.  In this case, we fall back to trying
                 * POSIX-draft (aka UFS-style) ACLs.
                 */
                whichacl = _ACL_ACLENT_ENABLED;
        }

        if (!(whichacl & (_ACL_ACE_ENABLED | _ACL_ACLENT_ENABLED))) {
                /*
                 * If the file system supports neither ACE nor
                 * ACLENT ACLs we will fall back to UFS-style ACLs
                 * like we did above if there was an error upon
                 * calling VOP_PATHCONF.
                 *
                 * ACE and ACLENT type ACLs are the only interfaces
                 * supported thus far.  If any other bits are set on
                 * 'whichacl' upon return from VOP_PATHCONF, we will
                 * ignore them.
                 */
                whichacl = _ACL_ACLENT_ENABLED;
        }

        if (whichacl == _ACL_ACLENT_ENABLED)
                return (ACLENT_T);

        return (ACE_T);
}

static const int zfs_perms[] = {
        ACE_READ_DATA, ACE_WRITE_DATA, ACE_APPEND_DATA, ACE_READ_NAMED_ATTRS,
        ACE_WRITE_NAMED_ATTRS, ACE_EXECUTE, ACE_DELETE_CHILD,
        ACE_READ_ATTRIBUTES, ACE_WRITE_ATTRIBUTES, ACE_DELETE, ACE_READ_ACL,
        ACE_WRITE_ACL, ACE_WRITE_OWNER, ACE_SYNCHRONIZE
};

static const int unix_perms[] = { VREAD, VWRITE, VEXEC };
/*
 * smb_vop_eaccess
 *
 * Returns the effective permission of the given credential for the
 * specified object.
 *
 * This is just a workaround. We need VFS/FS support for this.
 */
void
smb_vop_eaccess(vnode_t *vp, int *mode, int flags, vnode_t *dir_vp, cred_t *cr)
{
        int error, i;
        int pnum;

        *mode = 0;

        if (flags == V_ACE_MASK) {
                pnum = sizeof (zfs_perms) / sizeof (int);

                for (i = 0; i < pnum; i++) {
                        error = smb_vop_access(vp, zfs_perms[i], flags,
                            dir_vp, cr);
                        if (error == 0)
                                *mode |= zfs_perms[i];
                }
        } else {
                pnum = sizeof (unix_perms) / sizeof (int);

                for (i = 0; i < pnum; i++) {
                        error = smb_vop_access(vp, unix_perms[i], flags,
                            dir_vp, cr);
                        if (error == 0)
                                *mode |= unix_perms[i];
                }
        }
}

/*
 * See comments for smb_fsop_shrlock()
 */
int
smb_vop_shrlock(vnode_t *vp, uint32_t uniq_fid, uint32_t desired_access,
    uint32_t share_access, cred_t *cr)
{
        struct shrlock shr;
        struct shr_locowner shr_own;
        short new_access = 0;
        short deny = 0;
        int flag = 0;
        int cmd;

        /*
         * share locking is not supported for non-regular
         * objects in NBMAND mode.
         */
        if (nbl_need_check(vp)) {
                if (vp->v_type != VREG)
                        return (0);

                cmd = F_SHARE_NBMAND;
        } else {
                cmd = F_SHARE;
        }

        if ((desired_access & FILE_DATA_ALL) == 0) {
                /* metadata access only */
                new_access |= F_MDACC;
        } else {
                if (desired_access & (ACE_READ_DATA | ACE_EXECUTE)) {
                        new_access |= F_RDACC;
                        flag |= FREAD;
                }

                if (desired_access & (ACE_WRITE_DATA | ACE_APPEND_DATA |
                    ACE_ADD_FILE)) {
                        new_access |= F_WRACC;
                        flag |= FWRITE;
                }

                if (SMB_DENY_READ(share_access)) {
                        deny |= F_RDDNY;
                }

                if (SMB_DENY_WRITE(share_access)) {
                        deny |= F_WRDNY;
                }

                if (cmd == F_SHARE_NBMAND) {
                        if (desired_access & ACE_DELETE)
                                new_access |= F_RMACC;

                        if (SMB_DENY_DELETE(share_access)) {
                                deny |= F_RMDNY;
                        }
                }
        }

        shr.s_access = new_access;
        shr.s_deny = deny;
        shr.s_sysid = smb_ct.cc_sysid;
        shr.s_pid = uniq_fid;
        shr.s_own_len = sizeof (shr_own);
        shr.s_owner = (caddr_t)&shr_own;
        shr_own.sl_id = shr.s_sysid;
        shr_own.sl_pid = shr.s_pid;

        return (VOP_SHRLOCK(vp, cmd, &shr, flag, cr, NULL));
}

int
smb_vop_unshrlock(vnode_t *vp, uint32_t uniq_fid, cred_t *cr)
{
        struct shrlock shr;
        struct shr_locowner shr_own;

        /*
         * share locking is not supported for non-regular
         * objects in NBMAND mode.
         */
        if (nbl_need_check(vp) && (vp->v_type != VREG))
                return (0);

        /*
         * For s_access and s_deny, we do not need to pass in the original
         * values.
         */
        shr.s_access = 0;
        shr.s_deny = 0;
        shr.s_sysid = smb_ct.cc_sysid;
        shr.s_pid = uniq_fid;
        shr.s_own_len = sizeof (shr_own);
        shr.s_owner = (caddr_t)&shr_own;
        shr_own.sl_id = shr.s_sysid;
        shr_own.sl_pid = shr.s_pid;

        return (VOP_SHRLOCK(vp, F_UNSHARE, &shr, 0, cr, NULL));
}

/*
 * Note about mandatory vs advisory locks:
 *
 * The SMB server really should always request mandatory locks, and
 * if the file system does not support them, the SMB server should
 * just tell the client it could not get the lock. If we were to
 * tell the SMB client "you got the lock" when what they really
 * got was only an advisory lock, we would be lying to the client
 * about their having exclusive access to the locked range, which
 * could easily lead to data corruption.  If someone really wants
 * the (dangerous) behavior they can set: smb_allow_advisory_locks
 */
int
smb_vop_frlock(vnode_t *vp, cred_t *cr, int flag, flock64_t *bf)
{
        flk_callback_t flk_cb;
        int cmd = F_SETLK_NBMAND;

        if (smb_allow_advisory_locks != 0 && !nbl_need_check(vp)) {
                /*
                 * The file system does not support nbmand, and
                 * smb_allow_advisory_locks is enabled. (danger!)
                 */
                cmd = F_SETLK;
        }

        flk_init_callback(&flk_cb, smb_lock_frlock_callback, NULL);

        return (VOP_FRLOCK(vp, cmd, bf, flag, 0, &flk_cb, cr, &smb_ct));
}

static callb_cpr_t *
/* ARGSUSED */
smb_lock_frlock_callback(flk_cb_when_t when, void *error)
{
        return (0);
}

/*
 * smb_vop_catia_init_v4_lookup
 * Initialize  mapping between wide characters in the range from
 * 0x00A4 to 0x00FF and their UNIX (v4) equivalent (wide character).
 * Indexed by the decimal value of the wide character (164-255)
 * with an offset of -164.
 */
static void
smb_vop_catia_init_v4_lookup()
{
        int i, idx, offset = SMB_CATIA_V4_LOOKUP_LOW;

        for (i = 0; i < SMB_CATIA_V4_LOOKUP_MAX; i++)
                smb_catia_v4_lookup[i] = (smb_wchar_t)(i + offset);

        for (i = 0; i < SMB_CATIA_NUM_MAPS; i++) {
                idx = (int)catia_maps[i].winchar - offset;
                smb_catia_v4_lookup[idx] = (smb_wchar_t)catia_maps[i].unixchar;
        }
}

/*
 * smb_vop_catia_init_v5_lookup
 * Initialize mapping between UNIX ASCII (v4) characters and equivalent
 * or translated wide characters.
 * Indexed by the decimal value of the ASCII character (0-127).
 */
static void
smb_vop_catia_init_v5_lookup()
{
        int i, idx;

        for (i = 0; i < SMB_CATIA_V5_LOOKUP_MAX; i++)
                smb_catia_v5_lookup[i] = (smb_wchar_t)i;

        for (i = 0; i < SMB_CATIA_NUM_MAPS; i++) {
                idx = (int)catia_maps[i].unixchar;
                smb_catia_v5_lookup[idx] = catia_maps[i].winchar;
        }
}

static void
smb_vop_catia_init()
{
        smb_vop_catia_init_v4_lookup();
        smb_vop_catia_init_v5_lookup();
}

/*
 * smb_vop_catia_v5tov4
 * (windows (v5) to unix (v4))
 *
 * Traverse each character in the given source filename and convert the
 * multibyte that is equivalent to any special Windows character listed
 * in the catia_maps table to the Unix ASCII character if any is
 * encountered in the filename. The translated name is returned in buf.
 *
 * If an error occurs the conversion terminates and name is returned,
 * otherwise buf is returned.
 */
char *
smb_vop_catia_v5tov4(char *name, char *buf, int buflen)
{
        int v4_idx, numbytes, inc;
        int space_left = buflen - 1; /* one byte reserved for null */
        uint32_t wc;
        char mbstring[MTS_MB_CHAR_MAX];
        char *p, *src = name, *dst = buf;

        ASSERT(name);
        ASSERT(buf);

        if (!buf || !name)
                return (name);

        bzero(buf, buflen);

        while (*src) {
                if ((numbytes = smb_mbtowc(&wc, src, MTS_MB_CHAR_MAX)) < 0)
                        return (name);

                if (wc < SMB_CATIA_V4_LOOKUP_LOW ||
                    wc > SMB_CATIA_V4_LOOKUP_UPPER) {
                        inc = numbytes;
                        p = src;
                } else {
                        /* Lookup required. */
                        v4_idx = (int)wc - SMB_CATIA_V4_LOOKUP_LOW;
                        inc = smb_wctomb(mbstring, smb_catia_v4_lookup[v4_idx]);
                        p = mbstring;
                }

                if (space_left < inc)
                        return (name);

                (void) strncpy(dst, p, inc);
                dst += inc;
                space_left -= inc;
                src += numbytes;
        }

        return (buf);
}

/*
 * smb_vop_catia_v4tov5
 * (unix (v4) to windows (v5))
 *
 * Traverse each character in the given filename 'srcbuf' and convert
 * the special Unix character that is listed in the catia_maps table to
 * the UTF-8 encoding of the corresponding Windows character if any is
 * encountered in the filename.
 *
 * The translated name is returned in buf.
 * If an error occurs the conversion terminates and the original name
 * is returned in buf.
 */
void
smb_vop_catia_v4tov5(char *name, char *buf, int buflen)
{
        int v5_idx, numbytes;
        int space_left = buflen - 1; /* one byte reserved for null */
        uint32_t wc;
        char mbstring[MTS_MB_CHAR_MAX];
        char *src = name, *dst = buf;

        ASSERT(name);
        ASSERT(buf);

        if (!buf || !name)
                return;

        (void) bzero(buf, buflen);
        while (*src) {
                if (smb_isascii(*src)) {
                        /* Lookup required */
                        v5_idx = (int)*src++;
                        numbytes = smb_wctomb(mbstring,
                            smb_catia_v5_lookup[v5_idx]);
                        if (space_left < numbytes)
                                break;
                        (void) strncpy(dst, mbstring, numbytes);
                } else {
                        if ((numbytes = smb_mbtowc(&wc, src,
                            MTS_MB_CHAR_MAX)) < 0)
                                break;
                        if (space_left < numbytes)
                                break;
                        (void) strncpy(dst, src, numbytes);
                        src += numbytes;
                }

                dst += numbytes;
                space_left -= numbytes;
        }

        if (*src)
                (void) strlcpy(buf, name, buflen);
}