xref: /illumos-gate/usr/src/uts/common/fs/smbsrv/smb_vops.c (revision da6c28aa)

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

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#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 <acl/acl_common.h>
#include <smbsrv/smb_vops.h>
#include <smbsrv/string.h>
#include <smbsrv/lmshare.h>
#include <smbsrv/smbtrans.h>
#include <smbsrv/smb_incl.h>
#include <smbsrv/smb_fsops.h>

static int
smb_vop_readdir_readpage(vnode_t *vp, void *buf, uint32_t offset, int *count,
    cred_t *cr, caller_context_t *ct, int flags);

static int
smb_vop_readdir_entry(vnode_t *dvp, uint32_t *cookiep, char *name, int *namelen,
    ino64_t *inop, vnode_t **vpp, char *od_name, int flags, cred_t *cr,
    caller_context_t *ct, char *dirbuf, int num_bytes);

static int
smb_vop_getdents_entries(smb_node_t *dir_snode, uint32_t *cookiep,
    int32_t *dircountp, char *arg, uint32_t flags, struct smb_request *sr,
    cred_t *cr, caller_context_t *ct, char *dirbuf, int *maxentries,
    int num_bytes, char *);

extern int
smb_gather_dents_info(char *args, ino_t fileid, int namelen,
    char *name, uint32_t cookie, int32_t *countp,
    smb_attr_t *attr, struct smb_node *snode,
    char *shortname, char *name83);

static void
smb_sa_to_va_mask(uint_t sa_mask, uint_t *va_maskp);

#define	SMB_AT_MAX	16
static 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
};

int
smb_vop_open(vnode_t **vpp, int mode, cred_t *cred, caller_context_t *ct)
{
	return (VOP_OPEN(vpp, mode, cred, ct));
}

int
smb_vop_close(vnode_t *vp, int mode, cred_t *cred, caller_context_t *ct)
{
	return (VOP_CLOSE(vp, mode, 1, (offset_t)0, cred, ct));
}

/*
 * 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, cred_t *cr, caller_context_t *ct)
{
	int error;

	(void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, NULL);
	error = VOP_READ(vp, uiop, 0, cr, ct);
	VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, NULL);
	return (error);
}

int
smb_vop_write(vnode_t *vp, uio_t *uiop, uint32_t *flag, uint32_t *lcount,
    cred_t *cr, caller_context_t *ct)
{
	int error;
	int ioflag = 0;

	*lcount = uiop->uio_resid;

	if (*flag == FSSTAB_FILE_SYNC)
		ioflag = FSYNC;

	uiop->uio_llimit = MAXOFFSET_T;

	(void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, NULL);
	error = VOP_WRITE(vp, uiop, ioflag, cr, ct);
	VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL);

	*lcount -= uiop->uio_resid;

	return (error);
}

/*
 * 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.
 *
 * A named stream's attributes (as far as CIFS is concerned) are those of the
 * unnamed (i.e. data) stream (minus the size attribute), and the size of the
 * named stream.  Though the file system may store attributes other than size
 * with the named stream, these should not be used by CIFS for any purpose.
 *
 * When vp denotes a named stream, then unnamed_vp should be passed in (denoting
 * the corresponding unnamed stream).
 */

int
smb_vop_getattr(vnode_t *vp, vnode_t *unnamed_vp, smb_attr_t *ret_attr,
    int flags, cred_t *cr, caller_context_t *ct)
{
	int error;
	vnode_t *use_vp;
	smb_attr_t tmp_attr;
	xvattr_t tmp_xvattr;
	xoptattr_t *xoap = NULL;

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

	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(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);

		if ((error = VOP_GETATTR(use_vp, (vattr_t *)&tmp_xvattr, flags,
		    cr, ct)) != 0)
			return (error);

		ret_attr->sa_vattr = tmp_xvattr.xva_vattr;

		/*
		 * Copy special attributes to ret_attr parameter
		 */

		ret_attr->sa_dosattr = 0;

		ASSERT(tmp_xvattr.xva_vattr.va_mask & AT_XVATTR);

		xoap = xva_getxoptattr(&tmp_xvattr);
		ASSERT(xoap);

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

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

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

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

		ret_attr->sa_crtime = xoap->xoa_createtime;

		if (unnamed_vp && (ret_attr->sa_mask & SMB_AT_SIZE)) {
			/*
			 * Retrieve stream size attribute into temporary
			 * structure, in case the underlying file system
			 * returns attributes other than the size (we do not
			 * want to have ret_attr's other fields get
			 * overwritten).
			 *
			 * Note that vp is used here, and not use_vp.
			 * Also, only AT_SIZE is needed.
			 */

			tmp_xvattr.xva_vattr.va_mask = AT_SIZE;

			if ((error = VOP_GETATTR(vp, (vattr_t *)&tmp_xvattr,
			    flags, cr, ct)) != 0)
				return (error);

			ret_attr->sa_vattr.va_size =
			    tmp_xvattr.xva_vattr.va_size;

		}

		if (ret_attr->sa_vattr.va_type == VDIR) {
			ret_attr->sa_dosattr |= FILE_ATTRIBUTE_DIRECTORY;
		}

		return (error);
	}

	/*
	 * Support for file systems without VFSFT_XVATTR
	 */

	smb_sa_to_va_mask(ret_attr->sa_mask,
	    &ret_attr->sa_vattr.va_mask);

	error = VOP_GETATTR(use_vp, &ret_attr->sa_vattr, flags, cr, ct);

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

	/*
	 * "Fake" DOS attributes and create time, filesystem doesn't support
	 * them.
	 */

	ret_attr->sa_dosattr = 0;
	ret_attr->sa_crtime = ret_attr->sa_vattr.va_ctime;

	if (unnamed_vp && (ret_attr->sa_mask & SMB_AT_SIZE)) {
		/*
		 * Retrieve stream size attribute into temporary structure,
		 * in case the underlying file system returns attributes
		 * other than the size (we do not want to have ret_attr's
		 * other fields get overwritten).
		 *
		 * Note that vp is used here, and not use_vp.
		 * Also, only AT_SIZE is needed.
		 */

		tmp_attr.sa_vattr.va_mask = AT_SIZE;
		error = VOP_GETATTR(vp, &tmp_attr.sa_vattr, flags, cr, ct);

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


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

	if (ret_attr->sa_vattr.va_type == VDIR) {
		ret_attr->sa_dosattr |= FILE_ATTRIBUTE_DIRECTORY;
	}

	return (error);
}

/*
 * smb_vop_setattr()
 *
 * smb_fsop_setattr()/smb_vop_setattr() should always be called from the CIFS
 * service to set attributes due to special processing for streams files.
 *
 * When smb_vop_setattr() is called on a named stream file, all indicated
 * attributes except the size are set on the unnamed stream file.  The size
 * (if indicated) is set on the named stream file.
 */

int
smb_vop_setattr(vnode_t *vp, vnode_t *unnamed_vp, smb_attr_t *set_attr,
    int flags, cred_t *cr, caller_context_t *ct)
{
	int error = 0;
	int at_size = 0;
	vnode_t *use_vp;
	xvattr_t tmp_xvattr;
	xoptattr_t *xoap = NULL;
	uint_t xva_mask;

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

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

	set_attr->sa_vattr.va_mask = 0;

	if (vfs_has_feature(use_vp->v_vfsp, VFSFT_XVATTR)) {
		/*
		 * Initialize xvattr, including bzero
		 */
		xva_init(&tmp_xvattr);
		xoap = xva_getxoptattr(&tmp_xvattr);

		ASSERT(xoap);

		/*
		 * Copy caller-specified classic attributes to tmp_xvattr.
		 * First save tmp_xvattr's mask (set in xva_init()).
		 * This is |'d in later.
		 */

		xva_mask = tmp_xvattr.xva_vattr.va_mask;
		tmp_xvattr.xva_vattr = set_attr->sa_vattr;

		smb_sa_to_va_mask(set_attr->sa_mask,
		    &tmp_xvattr.xva_vattr.va_mask);

		/*
		 * "|" in the original xva_mask.
		 */

		tmp_xvattr.xva_vattr.va_mask |= xva_mask;

		if (set_attr->sa_mask & SMB_AT_DOSATTR) {
			XVA_SET_REQ(&tmp_xvattr, XAT_ARCHIVE);
			XVA_SET_REQ(&tmp_xvattr, XAT_SYSTEM);
			XVA_SET_REQ(&tmp_xvattr, XAT_READONLY);
			XVA_SET_REQ(&tmp_xvattr, XAT_HIDDEN);

			/*
			 * set_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 (set_attr->sa_dosattr & FILE_ATTRIBUTE_ARCHIVE)
				xoap->xoa_archive = 1;

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

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

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

		if (set_attr->sa_mask & SMB_AT_CRTIME) {
			XVA_SET_REQ(&tmp_xvattr, XAT_CREATETIME);
			xoap->xoa_createtime = set_attr->sa_crtime;
		}

		if ((error = VOP_SETATTR(use_vp, (vattr_t *)&tmp_xvattr, flags,
		    cr, ct)) != 0)
			return (error);

		/*
		 * If the size of the stream needs to be set, set it on
		 * the stream file directly.  (All other indicated attributes
		 * are set on the stream's unnamed stream, above.)
		 */

		if (at_size) {
			/*
			 * set_attr->sa_vattr.va_size already contains the
			 * size as set by the caller
			 *
			 * Note that vp is used here, and not use_vp.
			 * Also, only AT_SIZE is needed.
			 */

			set_attr->sa_vattr.va_mask = AT_SIZE;
			error = VOP_SETATTR(vp, &set_attr->sa_vattr, flags,
			    cr, ct);
		}

		return (error);
	}

	/*
	 * Support for file systems without VFSFT_XVATTR
	 */

	smb_sa_to_va_mask(set_attr->sa_mask, &set_attr->sa_vattr.va_mask);

	/*
	 * set_attr->sa_vattr already contains new values
	 * as set by the caller
	 */

	error = VOP_SETATTR(use_vp, &set_attr->sa_vattr, flags, cr, ct);

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

	if (at_size) {
		/*
		 * set_attr->sa_vattr.va_size already contains the
		 * size as set by the caller
		 *
		 * Note that vp is used here, and not use_vp.
		 * Also, only AT_SIZE is needed.
		 */

		set_attr->sa_vattr.va_mask = AT_SIZE;
		error = VOP_SETATTR(vp, &set_attr->sa_vattr, flags, cr, 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);

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

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

	if (mode) {
		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.
 */

int
smb_vop_lookup(vnode_t *dvp, char *name, vnode_t **vpp, char *od_name,
    int flags, vnode_t *rootvp, cred_t *cr, caller_context_t *ct)
{
	int error = 0;
	int option_flags = 0;
	pathname_t rpn;

	if (*name == '\0')
		return (EINVAL);

	ASSERT(vpp);
	*vpp = NULL;

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

		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;

	pn_alloc(&rpn);

	error = VOP_LOOKUP(dvp, name, vpp, NULL, option_flags, NULL, cr,
	    ct, NULL, &rpn);

	if ((error == 0) && od_name) {
		bzero(od_name, MAXNAMELEN);
		if (option_flags == FIGNORECASE)
			(void) strlcpy(od_name, rpn.pn_buf, MAXNAMELEN);
		else
			(void) strlcpy(od_name, name, MAXNAMELEN);
	}

	pn_free(&rpn);
	return (error);
}

int
smb_vop_create(vnode_t *dvp, char *name, smb_attr_t *attr, vnode_t **vpp,
    int flags, cred_t *cr, caller_context_t *ct, vsecattr_t *vsap)
{
	int error;
	int option_flags = 0;

	if (flags & SMB_IGNORE_CASE)
		option_flags = FIGNORECASE;

	smb_sa_to_va_mask(attr->sa_mask, &attr->sa_vattr.va_mask);

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

	return (error);
}

int
smb_vop_remove(vnode_t *dvp, char *name, int flags, cred_t *cr,
    caller_context_t *ct)
{
	int error;
	int option_flags = 0;

	if (flags & SMB_IGNORE_CASE)
		option_flags = FIGNORECASE;

	error = VOP_REMOVE(dvp, name, cr, ct, option_flags);

	return (error);
}

/*
 * 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, caller_context_t *ct)
{
	int error;
	int option_flags = 0;


	if (flags & SMB_IGNORE_CASE)
		option_flags = FIGNORECASE;

	error = VOP_RENAME(from_dvp, from_name, to_dvp, to_name, cr,
	    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, caller_context_t *ct, vsecattr_t *vsap)
{
	int error;
	int option_flags = 0;



	if (flags & SMB_IGNORE_CASE)
		option_flags = FIGNORECASE;

	smb_sa_to_va_mask(attr->sa_mask, &attr->sa_vattr.va_mask);

	error = VOP_MKDIR(dvp, name, &attr->sa_vattr, vpp, cr, ct,
	    option_flags, vsap);

	return (error);
}

/*
 * smb_vop_rmdir()
 *
 * Only simple rmdir supported, consistent with NT semantics
 * (can only remove an empty directory).
 *
 */

int
smb_vop_rmdir(vnode_t *dvp, char *name, int flags, cred_t *cr,
    caller_context_t *ct)
{
	int error;
	int option_flags = 0;

	if (flags & SMB_IGNORE_CASE)
		option_flags = FIGNORECASE;

	/*
	 * Comments adapted from rfs_rmdir().
	 *
	 * VOP_RMDIR now takes a new third argument (the current
	 * directory of the process).  That's because rmdir
	 * wants to return EINVAL if one tries to remove ".".
	 * Of course, 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.
	 */

	error = VOP_RMDIR(dvp, name, rootdir, cr, ct, option_flags);
	return (error);
}

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

/*
 * smb_vop_readdir()
 *
 * Upon return, the "name" field will contain either the on-disk name or, if
 * it needs mangling or has a case-insensitive collision, the mangled
 * "shortname."
 *
 * vpp is an optional parameter.  If non-NULL, it will contain a pointer to
 * the vnode for the name that is looked up (the vnode will be returned held).
 *
 * od_name is an optional parameter (NULL can be passed if the on-disk name
 * is not needed by the caller).
 */

int
smb_vop_readdir(vnode_t *dvp, uint32_t *cookiep, char *name, int *namelen,
    ino64_t *inop, vnode_t **vpp, char *od_name, int flags, cred_t *cr,
    caller_context_t *ct)
{
	int num_bytes;
	int error = 0;
	char *dirbuf = NULL;

	ASSERT(dvp);
	ASSERT(cookiep);
	ASSERT(name);
	ASSERT(namelen);
	ASSERT(inop);
	ASSERT(cr);
	ASSERT(ct);

	if (dvp->v_type != VDIR) {
		*namelen = 0;
		return (ENOTDIR);
	}

	if (vpp)
		*vpp = NULL;

	dirbuf = kmem_zalloc(SMB_MINLEN_RDDIR_BUF, KM_SLEEP);
	num_bytes = SMB_MINLEN_RDDIR_BUF;

	/*
	 * The goal is to retrieve the first valid entry from *cookiep
	 * forward.  smb_vop_readdir_readpage() collects an
	 * SMB_MINLEN_RDDIR_BUF-size "page" of directory entry information.
	 * smb_vop_readdir_entry() attempts to find the first valid entry
	 * in that page.
	 */

	while ((error = smb_vop_readdir_readpage(dvp, dirbuf, *cookiep,
	    &num_bytes, cr, ct, flags)) == 0) {

		if (num_bytes <= 0)
			break;

		name[0] = '\0';

		error = smb_vop_readdir_entry(dvp, cookiep, name, namelen,
		    inop, vpp, od_name, flags, cr, ct, dirbuf,
		    num_bytes);

		if (error)
			break;

		if (*name)
			break;

		bzero(dirbuf, SMB_MINLEN_RDDIR_BUF);
		num_bytes = SMB_MINLEN_RDDIR_BUF;
	}


	if (error) {
		kmem_free(dirbuf, SMB_MINLEN_RDDIR_BUF);
		*namelen = 0;
		return (error);
	}

	if (num_bytes == 0) { /* EOF */
		kmem_free(dirbuf, SMB_MINLEN_RDDIR_BUF);
		*cookiep = SMB_EOF;
		*namelen = 0;
		return (0);
	}

	kmem_free(dirbuf, SMB_MINLEN_RDDIR_BUF);
	return (0);
}

/*
 * smb_vop_readdir_readpage()
 *
 * 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.)
 *
 * Much of the following is borrowed from getdents64()
 *
 * MAXGETDENTS_SIZE is defined in getdents.c
 */

#define	MAXGETDENTS_SIZE	(64 * 1024)

static int
smb_vop_readdir_readpage(vnode_t *vp, void *buf, uint32_t offset, int *count,
    cred_t *cr, caller_context_t *ct, int flags)
{
	int error = 0;
	int rdirent_flags = 0;
	int sink;
	struct uio auio;
	struct iovec aiov;

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

	/* entflags not working for streams so don't try to use them */
	if (!(flags & SMB_STREAM_RDDIR) &&
	    (vfs_has_feature(vp->v_vfsp, VFSFT_DIRENTFLAGS))) {
		/*
		 * Setting V_RDDIR_ENTFLAGS will cause the buffer to
		 * be filled with edirent_t structures (instead of
		 * dirent64_t structures).
		 */
		rdirent_flags = V_RDDIR_ENTFLAGS;

		if (*count < sizeof (edirent_t))
			return (EINVAL);
	} else {
		if (*count < sizeof (dirent64_t))
			return (EINVAL);
	}

	if (*count > MAXGETDENTS_SIZE)
		*count = MAXGETDENTS_SIZE;

	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_resid = *count;
	auio.uio_fmode = 0;

	(void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, NULL);
	error = VOP_READDIR(vp, &auio, cr, &sink, ct, rdirent_flags);
	VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, NULL);

	if (error) {
		if (error == ENOENT) {
			/* Fake EOF if offset is bad due to dropping of lock */
			*count = 0;
			return (0);
		} else {
			return (error);
		}
	}

	/*
	 * Windows cannot handle an offset > SMB_EOF.
	 * Pretend we are at EOF.
	 */

	if (auio.uio_loffset > SMB_EOF) {
		*count = 0;
		return (0);
	}

	*count = *count - auio.uio_resid;
	return (0);
}

/*
 * smb_vop_readdir_entry()
 *
 * This function retrieves the first valid entry from the
 * SMB_MINLEN_RDDIR_BUF-sized buffer returned by smb_vop_readdir_readpage()
 * to smb_vop_readdir().
 *
 * Both dirent64_t and edirent_t structures need to be handled.  The former is
 * needed for file systems that do not support VFSFT_DIRENTFLAGS.  The latter
 * is required for proper handling of case collisions on file systems that
 * support case-insensitivity.  edirent_t structures are also used for
 * case-sensitive file systems if VFSFT_DIRENTFLAGS is supported.
 */

static int
smb_vop_readdir_entry(vnode_t *dvp, uint32_t *cookiep, char *name, int *namelen,
    ino64_t *inop, vnode_t **vpp, char *od_name, int flags, cred_t *cr,
    caller_context_t *ct, char *dirbuf, int num_bytes)
{
	uint32_t next_cookie;
	int ebufsize;
	int error = 0;
	int len;
	int rc;
	char shortname[MANGLE_NAMELEN];
	char name83[MANGLE_NAMELEN];
	char *ebuf = NULL;
	edirent_t *edp;
	dirent64_t *dp = NULL;
	vnode_t *vp = NULL;

	ASSERT(dirbuf);

	/*
	 * Use edirent_t structure for both
	 * entflags not working for streams so don't try to use them
	 */
	if (!(flags & SMB_STREAM_RDDIR) &&
	    (vfs_has_feature(dvp->v_vfsp, VFSFT_DIRENTFLAGS))) {
		/*LINTED E_BAD_PTR_CAST_ALIGN*/
		edp = (edirent_t *)dirbuf;
	} else {
		/*LINTED E_BAD_PTR_CAST_ALIGN*/
		dp = (dirent64_t *)dirbuf;
		ebufsize = EDIRENT_RECLEN(MAXNAMELEN);
		ebuf = kmem_zalloc(ebufsize, KM_SLEEP);
		/*LINTED E_BAD_PTR_CAST_ALIGN*/
		edp = (edirent_t *)ebuf;
	}

	while (edp) {
		if (dp)
			DP_TO_EDP(dp, edp);

		next_cookie = (uint32_t)edp->ed_off;
		if (edp->ed_ino == 0) {
			*cookiep = next_cookie;

			if (dp) {
				/*LINTED E_BAD_PTR_CAST_ALIGN*/
				DP_ADVANCE(dp, dirbuf, num_bytes);
				if (dp == NULL)
					edp = NULL;
			} else {
				/*LINTED E_BAD_PTR_CAST_ALIGN*/
				EDP_ADVANCE(edp, dirbuf, num_bytes);
			}
			continue;
		}

		len = strlen(edp->ed_name);

		if (*namelen < len) {
			*namelen = 0;

			if (ebuf)
				kmem_free(ebuf, ebufsize);

			return (EOVERFLOW);
		}

		/*
		 * Do not pass SMB_IGNORE_CASE to smb_vop_lookup
		 */

		error = smb_vop_lookup(dvp, edp->ed_name, vpp ? vpp : &vp,
		    od_name, 0, NULL, cr, ct);

		if (error) {
			if (error == ENOENT) {
				*cookiep = (uint32_t)next_cookie;

				if (dp) {
					/*LINTED E_BAD_PTR_CAST_ALIGN*/
					DP_ADVANCE(dp, dirbuf, num_bytes);
					if (dp == NULL)
						edp = NULL;
				} else {
					/*LINTED E_BAD_PTR_CAST_ALIGN*/
					EDP_ADVANCE(edp, dirbuf, num_bytes);
				}
				continue;
			}


			*namelen = 0;

			if (ebuf)
				kmem_free(ebuf, ebufsize);

			return (error);
		}

		if ((flags & SMB_IGNORE_CASE) && ED_CASE_CONFLICTS(edp)) {
			rc = smb_mangle_name(edp->ed_ino, edp->ed_name,
			    shortname, name83, 1);

			if (rc == 1) { /* success */
				(void) strlcpy(name, shortname, *namelen + 1);
				*namelen = strlen(shortname);
			} else {
				(void) strlcpy(name, edp->ed_name,
				    *namelen + 1);
				name[*namelen] = '\0';
			}

		} else {
			(void) strlcpy(name, edp->ed_name, *namelen + 1);
				*namelen = len;
		}

		if (vpp == NULL)
			VN_RELE(vp);

		if (inop)
			*inop = edp->ed_ino;

		*cookiep = (uint32_t)next_cookie;
		break;
	}

	if (ebuf)
		kmem_free(ebuf, ebufsize);

	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;
	}
}

/*
 * smb_vop_getdents()
 *
 * Upon success, the smb_node corresponding to each entry returned will
 * have a reference taken on it.  These will be released in
 * smb_trans2_find_get_dents().
 *
 * If an error is returned from this routine, a list of already processed
 * entries will be returned.  The smb_nodes corresponding to these entries
 * will be referenced, and will be released in smb_trans2_find_get_dents().
 *
 * The returned dp->d_name field will contain either the on-disk name or, if
 * it needs mangling or has a case-insensitive collision, the mangled
 * "shortname."  In this case, the on-disk name can be retrieved from the
 * smb_node's od_name (the smb_node is passed to smb_gather_dents_info()).
 */

int /*ARGSUSED*/
smb_vop_getdents(
    smb_node_t		*dir_snode,
    uint32_t		*cookiep,
    uint64_t		*verifierp,
    int32_t		*dircountp,
    char		*arg,
    char		*pattern,
    uint32_t		flags,
    smb_request_t	*sr,
    cred_t		*cr,
    caller_context_t	*ct)
{
	int		error = 0;
	int		maxentries;
	int		num_bytes;
	int		resid;
	char		*dirbuf = NULL;
	vnode_t		*dvp;
	/*LINTED E_BAD_PTR_CAST_ALIGN*/
	smb_dent_info_hdr_t *ihdr = (smb_dent_info_hdr_t *)arg;

	dvp = dir_snode->vp;

	resid = ihdr->uio.uio_resid;
	maxentries = resid / SMB_MAX_DENT_INFO_SIZE;

	bzero(ihdr->iov->iov_base, resid);

	dirbuf = kmem_alloc(SMB_MINLEN_RDDIR_BUF, KM_SLEEP);

	while (maxentries) {

		bzero(dirbuf, SMB_MINLEN_RDDIR_BUF);

		num_bytes = SMB_MINLEN_RDDIR_BUF;
		error = smb_vop_readdir_readpage(dvp, dirbuf, *cookiep,
		    &num_bytes, cr, ct, flags);

		if (error || (num_bytes <= 0))
			break;

		error = smb_vop_getdents_entries(dir_snode, cookiep, dircountp,
		    arg, flags, sr, cr, ct, dirbuf, &maxentries, num_bytes,
		    pattern);

		if (error)
			goto out;
	}

	if (num_bytes < 0) {
		error = -1;
	} else if (num_bytes == 0) {
		*cookiep = SMB_EOF;
		error = 0;
	} else {
		error = 0;
	}

out:
	if (dirbuf)
		kmem_free(dirbuf, SMB_MINLEN_RDDIR_BUF);

	return (error);
}

/*
 * smb_vop_getdents_entries()
 *
 * This function retrieves names from the SMB_MINLEN_RDDIR_BUF-sized buffer
 * returned by smb_vop_readdir_readpage() to smb_vop_getdents().
 *
 * Both dirent64_t and edirent_t structures need to be handled.  The former is
 * needed for file systems that do not support VFSFT_DIRENTFLAGS.  The latter
 * is required for properly handling case collisions on file systems that
 * support case-insensitivity.  edirent_t is also used on case-sensitive
 * file systems where VFSFT_DIRENTFLAGS is available.
 */

static int
smb_vop_getdents_entries(
    smb_node_t		*dir_snode,
    uint32_t		*cookiep,
    int32_t		*dircountp,
    char		*arg,
    uint32_t		flags,
    struct smb_request	*sr,
    cred_t		*cr,
    caller_context_t	*ct,
    char		*dirbuf,
    int			*maxentries,
    int			num_bytes,
    char		*pattern)
{
	uint32_t	next_cookie;
	int		ebufsize;
	char		*tmp_name;
	int		error;
	int		rc;
	char		shortname[MANGLE_NAMELEN];
	char		name83[MANGLE_NAMELEN];
	char		*ebuf = NULL;
	dirent64_t	*dp = NULL;
	edirent_t	*edp;
	smb_node_t	*ret_snode;
	smb_attr_t	ret_attr;
	vnode_t		*dvp;
	vnode_t		*fvp;

	ASSERT(dirbuf);

	dvp = dir_snode->vp;

	if (vfs_has_feature(dvp->v_vfsp, VFSFT_DIRENTFLAGS)) {
		/*LINTED E_BAD_PTR_CAST_ALIGN*/
		edp = (edirent_t *)dirbuf;
	} else {
		/*LINTED E_BAD_PTR_CAST_ALIGN*/
		dp = (dirent64_t *)dirbuf;
		ebufsize = EDIRENT_RECLEN(MAXNAMELEN);
		ebuf = kmem_zalloc(ebufsize, KM_SLEEP);
		/*LINTED E_BAD_PTR_CAST_ALIGN*/
		edp = (edirent_t *)ebuf;
	}

	while (edp) {
		if (dp)
			DP_TO_EDP(dp, edp);

		if (*maxentries == 0)
			break;

		next_cookie = (uint32_t)edp->ed_off;

		if (edp->ed_ino == 0) {
			*cookiep = next_cookie;
			if (dp) {
				/*LINTED E_BAD_PTR_CAST_ALIGN*/
				DP_ADVANCE(dp, dirbuf, num_bytes);
				if (dp == NULL)
					edp = NULL;
			} else {
				/*LINTED E_BAD_PTR_CAST_ALIGN*/
				EDP_ADVANCE(edp, dirbuf, num_bytes);
			}
			continue;
		}

		error = smb_vop_lookup(dvp, edp->ed_name, &fvp,
		    NULL, 0, NULL, cr, ct);

		if (error) {
			if (error == ENOENT) {
				*cookiep = next_cookie;
				if (dp) {
					/*LINTED E_BAD_PTR_CAST_ALIGN*/
					DP_ADVANCE(dp, dirbuf,
					    num_bytes);
					if (dp == NULL)
						edp = NULL;
				} else {
					/*LINTED E_BAD_PTR_CAST_ALIGN*/
					EDP_ADVANCE(edp, dirbuf,
					    num_bytes);
				}
				continue;
			}
			if (ebuf)
				kmem_free(ebuf, ebufsize);

			return (error);
		}

		ret_snode = smb_node_lookup(sr, NULL, cr, fvp,
		    edp->ed_name, dir_snode, NULL, &ret_attr);

		if (ret_snode == NULL) {
			VN_RELE(fvp);

			if (ebuf)
				kmem_free(ebuf, ebufsize);

			return (ENOMEM);
		}

		if (smb_match_name(edp->ed_ino, edp->ed_name, shortname,
		    name83, pattern, (flags & SMB_IGNORE_CASE))) {

			tmp_name = edp->ed_name;

			if ((flags & SMB_IGNORE_CASE) &&
			    ED_CASE_CONFLICTS(edp)) {
				rc = smb_mangle_name(edp->ed_ino, edp->ed_name,
				    shortname, name83, 1);
				if (rc == 1)
					tmp_name = shortname;
			} else {
				rc = smb_mangle_name(edp->ed_ino, edp->ed_name,
				    shortname, name83, 0);
			}

			if (rc != 1) {
				(void) strlcpy(shortname, edp->ed_name,
				    MANGLE_NAMELEN);
				(void) strlcpy(name83, edp->ed_name,
				    MANGLE_NAMELEN);
				shortname[MANGLE_NAMELEN - 1] = '\0';
				name83[MANGLE_NAMELEN - 1] = '\0';
			}

			error = smb_gather_dents_info(arg, edp->ed_ino,
			    strlen(tmp_name), tmp_name, next_cookie, dircountp,
			    &ret_attr, ret_snode, shortname, name83);

			if (error > 0) {
				if (ebuf)
					kmem_free(ebuf, ebufsize);
				return (error);
			}

			/*
			 * Treat errors from smb_gather_dents_info() that are
			 * < 0 the same as EOF.
			 */
			if (error < 0) {
				if (ebuf)
					kmem_free(ebuf, ebufsize);
				*maxentries = 0;
				return (0);
			}
			(*maxentries)--;
		} else {
			smb_node_release(ret_snode);
		}

		*cookiep = next_cookie;

		if (dp) {
			/*LINTED E_BAD_PTR_CAST_ALIGN*/
			DP_ADVANCE(dp, dirbuf, num_bytes);
			if (dp == NULL)
				edp = NULL;
		} else {
			/*LINTED E_BAD_PTR_CAST_ALIGN*/
			EDP_ADVANCE(edp, dirbuf, num_bytes);
		}
	}

	if (ebuf)
		kmem_free(ebuf, ebufsize);

	return (0);
}

/*
 * 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, caller_context_t *ct)
{
	char *solaris_stream_name;
	char *name;
	int error;

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

	/*
	 * Prepend SMB_STREAM_PREFIX to stream name
	 */

	solaris_stream_name = kmem_alloc(MAXNAMELEN, KM_SLEEP);
	(void) sprintf(solaris_stream_name, "%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, rootvp, cr, ct)) != 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,
    caller_context_t *ct)
{
	char *solaris_stream_name;
	int error;

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

	/*
	 * Prepend SMB_STREAM_PREFIX to stream name
	 */

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

	if ((error = smb_vop_create(*xattrdirvpp, solaris_stream_name, attr,
	    vpp, flags, cr, ct, 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,
    caller_context_t *ct)
{
	char *solaris_stream_name;
	vnode_t *xattrdirvp;
	int error;

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

	/*
	 * Prepend SMB_STREAM_PREFIX to stream name
	 */

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

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

	kmem_free(solaris_stream_name, MAXNAMELEN);

	return (error);
}

/*
 * smb_vop_stream_readdir()
 *
 * Note: stream_info.size is not filled in in this routine.
 * It needs to be filled in by the caller due to the parameters for getattr.
 *
 * stream_info.name is set to the on-disk stream name with the SMB_STREAM_PREFIX
 * removed.
 */

int
smb_vop_stream_readdir(vnode_t *fvp, uint32_t *cookiep,
    struct fs_stream_info *stream_info, vnode_t **vpp, vnode_t **xattrdirvpp,
    int flags, cred_t *cr, caller_context_t *ct)
{
	int nsize = MAXNAMELEN-1;
	int error = 0;
	ino64_t ino;
	char *tmp_name;
	vnode_t *xattrdirvp;
	vnode_t *vp;

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

	bzero(stream_info->name, sizeof (stream_info->name));
	stream_info->size = 0;

	tmp_name = kmem_zalloc(MAXNAMELEN, KM_SLEEP);

	for (;;) {
		error = smb_vop_readdir(xattrdirvp, cookiep, tmp_name, &nsize,
		    &ino, &vp, NULL, flags | SMB_STREAM_RDDIR, cr, ct);

		if (error || (*cookiep == SMB_EOF))
			break;

		if (strncmp(tmp_name, SMB_STREAM_PREFIX,
		    SMB_STREAM_PREFIX_LEN)) {
			VN_RELE(vp);
			continue;
		}

		tmp_name[nsize] = '\0';
		(void) strlcpy(stream_info->name,
		    &(tmp_name[SMB_STREAM_PREFIX_LEN]),
		    sizeof (stream_info->name));

		nsize -= SMB_STREAM_PREFIX_LEN;
		break;
	}

	if ((error == 0) && nsize) {
		if (vpp)
			*vpp = vp;
		else
			VN_RELE(vp);

		if (xattrdirvpp)
			*xattrdirvpp = xattrdirvp;
		else
			VN_RELE(xattrdirvp);

	}

	kmem_free(tmp_name, MAXNAMELEN);

	return (error);
}

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

	error = VOP_LOOKUP(fvp, "", xattrdirvpp, NULL, flags, NULL, cr, 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_from_vsa
 *
 * Converts given vsecattr_t structure to a acl_t structure.
 *
 * The allocated memory for retuned acl_t should be freed by
 * calling acl_free().
 */
static acl_t *
smb_vop_acl_from_vsa(vsecattr_t *vsecattr, acl_type_t acl_type)
{
	int		aclbsize = 0;	/* size of acl list in bytes */
	int		dfaclbsize = 0;	/* size of default acl list in bytes */
	int		numacls;
	acl_t		*acl_info;

	ASSERT(vsecattr);

	acl_info = acl_alloc(acl_type);
	if (acl_info == NULL)
		return (NULL);

	acl_info->acl_flags = 0;

	switch (acl_type) {

	case ACLENT_T:
		numacls = vsecattr->vsa_aclcnt + vsecattr->vsa_dfaclcnt;
		aclbsize = vsecattr->vsa_aclcnt * sizeof (aclent_t);
		dfaclbsize = vsecattr->vsa_dfaclcnt * sizeof (aclent_t);

		acl_info->acl_cnt = numacls;
		acl_info->acl_aclp = kmem_alloc(aclbsize + dfaclbsize,
		    KM_SLEEP);
		(void) memcpy(acl_info->acl_aclp, vsecattr->vsa_aclentp,
		    aclbsize);
		(void) memcpy((char *)acl_info->acl_aclp + aclbsize,
		    vsecattr->vsa_dfaclentp, dfaclbsize);

		if (acl_info->acl_cnt <= MIN_ACL_ENTRIES)
			acl_info->acl_flags |= ACL_IS_TRIVIAL;

		break;

	case ACE_T:
		aclbsize = vsecattr->vsa_aclcnt * sizeof (ace_t);
		acl_info->acl_cnt = vsecattr->vsa_aclcnt;
		acl_info->acl_flags = vsecattr->vsa_aclflags;
		acl_info->acl_aclp = kmem_alloc(aclbsize, KM_SLEEP);
		(void) memcpy(acl_info->acl_aclp, vsecattr->vsa_aclentp,
		    aclbsize);
		if (ace_trivial(acl_info->acl_aclp, acl_info->acl_cnt) == 0)
			acl_info->acl_flags |= ACL_IS_TRIVIAL;

		break;

	default:
		acl_free(acl_info);
		return (NULL);
	}

	if (aclbsize && vsecattr->vsa_aclentp)
		kmem_free(vsecattr->vsa_aclentp, aclbsize);
	if (dfaclbsize && vsecattr->vsa_dfaclentp)
		kmem_free(vsecattr->vsa_dfaclentp, dfaclbsize);

	return (acl_info);
}

/*
 * smb_vop_acl_to_vsa
 *
 * Converts given acl_t structure to a vsecattr_t structure.
 *
 * IMPORTANT:
 * Upon successful return the memory allocated for vsa_aclentp
 * should be freed by calling kmem_free(). The size is returned
 * in aclbsize.
 */
int
smb_vop_acl_to_vsa(acl_t *acl_info, vsecattr_t *vsecattr, int *aclbsize)
{
	int		error = 0;
	int		numacls;
	aclent_t	*aclp;

	ASSERT(acl_info);
	ASSERT(vsecattr);
	ASSERT(aclbsize);

	bzero(vsecattr, sizeof (vsecattr_t));
	*aclbsize = 0;

	switch (acl_info->acl_type) {
	case ACLENT_T:
		numacls = acl_info->acl_cnt;
		/*
		 * Minimum ACL size is three entries so might as well
		 * bail out here.  Also limit request size to prevent user
		 * from allocating too much kernel memory.  Maximum size
		 * is MAX_ACL_ENTRIES for the ACL part and MAX_ACL_ENTRIES
		 * for the default ACL part.
		 */
		if (numacls < 3 || numacls > (MAX_ACL_ENTRIES * 2)) {
			error = EINVAL;
			break;
		}

		vsecattr->vsa_mask = VSA_ACL;

		vsecattr->vsa_aclcnt = numacls;
		*aclbsize = numacls * sizeof (aclent_t);
		vsecattr->vsa_aclentp = kmem_alloc(*aclbsize, KM_SLEEP);
		(void) memcpy(vsecattr->vsa_aclentp, acl_info->acl_aclp,
		    *aclbsize);

		/* Sort the acl list */
		ksort((caddr_t)vsecattr->vsa_aclentp,
		    vsecattr->vsa_aclcnt, sizeof (aclent_t), cmp2acls);

		/* Break into acl and default acl lists */
		for (numacls = 0, aclp = vsecattr->vsa_aclentp;
		    numacls < vsecattr->vsa_aclcnt;
		    aclp++, numacls++) {
			if (aclp->a_type & ACL_DEFAULT)
				break;
		}

		/* Find where defaults start (if any) */
		if (numacls < vsecattr->vsa_aclcnt) {
			vsecattr->vsa_mask |= VSA_DFACL;
			vsecattr->vsa_dfaclcnt = vsecattr->vsa_aclcnt - numacls;
			vsecattr->vsa_dfaclentp = aclp;
			vsecattr->vsa_aclcnt = numacls;
		}

		/* Adjust if they're all defaults */
		if (vsecattr->vsa_aclcnt == 0) {
			vsecattr->vsa_mask &= ~VSA_ACL;
			vsecattr->vsa_aclentp = NULL;
		}

		/* Only directories can have defaults */
		if (vsecattr->vsa_dfaclcnt &&
		    (acl_info->acl_flags & ACL_IS_DIR)) {
			error = ENOTDIR;
		}

		break;

	case ACE_T:
		if (acl_info->acl_cnt < 1 ||
		    acl_info->acl_cnt > MAX_ACL_ENTRIES) {
			error = EINVAL;
			break;
		}

		vsecattr->vsa_mask = VSA_ACE | VSA_ACE_ACLFLAGS;
		vsecattr->vsa_aclcnt = acl_info->acl_cnt;
		vsecattr->vsa_aclflags = acl_info->acl_flags & ACL_FLAGS_ALL;
		*aclbsize = vsecattr->vsa_aclcnt * sizeof (ace_t);
		vsecattr->vsa_aclentsz = *aclbsize;
		vsecattr->vsa_aclentp = kmem_alloc(*aclbsize, KM_SLEEP);
		(void) memcpy(vsecattr->vsa_aclentp, acl_info->acl_aclp,
		    *aclbsize);

		break;

	default:
		error = EINVAL;
	}

	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, caller_context_t *ct)
{
	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, ct))
		return (error);

	*aclp = smb_vop_acl_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,
    caller_context_t *ct)
{
	int error;
	vsecattr_t vsecattr;
	int aclbsize;

	ASSERT(vp);
	ASSERT(aclp);

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

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

	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, 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 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 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];
		}
	}
}