1da6c28aaSamw /* 2da6c28aaSamw * CDDL HEADER START 3da6c28aaSamw * 4da6c28aaSamw * The contents of this file are subject to the terms of the 5da6c28aaSamw * Common Development and Distribution License (the "License"). 6da6c28aaSamw * You may not use this file except in compliance with the License. 7da6c28aaSamw * 8da6c28aaSamw * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9da6c28aaSamw * or http://www.opensolaris.org/os/licensing. 10da6c28aaSamw * See the License for the specific language governing permissions 11da6c28aaSamw * and limitations under the License. 12da6c28aaSamw * 13da6c28aaSamw * When distributing Covered Code, include this CDDL HEADER in each 14da6c28aaSamw * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15da6c28aaSamw * If applicable, add the following below this CDDL HEADER, with the 16da6c28aaSamw * fields enclosed by brackets "[]" replaced with your own identifying 17da6c28aaSamw * information: Portions Copyright [yyyy] [name of copyright owner] 18da6c28aaSamw * 19da6c28aaSamw * CDDL HEADER END 20da6c28aaSamw */ 21da6c28aaSamw /* 22dc20a302Sas200622 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23da6c28aaSamw * Use is subject to license terms. 24da6c28aaSamw */ 25da6c28aaSamw 26da6c28aaSamw #pragma ident "%Z%%M% %I% %E% SMI" 27da6c28aaSamw 28da6c28aaSamw #include <sys/types.h> 29da6c28aaSamw #include <sys/stat.h> 30da6c28aaSamw #include <sys/uio.h> 31da6c28aaSamw #include <sys/statvfs.h> 32da6c28aaSamw #include <sys/vnode.h> 33da6c28aaSamw #include <sys/thread.h> 34da6c28aaSamw #include <sys/pathname.h> 35da6c28aaSamw #include <sys/cred.h> 36da6c28aaSamw #include <sys/extdirent.h> 37dc20a302Sas200622 #include <sys/nbmlock.h> 38dc20a302Sas200622 #include <sys/share.h> 39dc20a302Sas200622 #include <sys/fcntl.h> 40faa1795aSjb150015 #include <nfs/lm.h> 4155bf511dSas200622 42da6c28aaSamw #include <smbsrv/smb_vops.h> 43da6c28aaSamw #include <smbsrv/string.h> 4455bf511dSas200622 45da6c28aaSamw #include <smbsrv/smbtrans.h> 46da6c28aaSamw #include <smbsrv/smb_fsops.h> 4755bf511dSas200622 #include <smbsrv/smb_kproto.h> 4855bf511dSas200622 #include <smbsrv/smb_incl.h> 4955bf511dSas200622 50dc20a302Sas200622 void 51dc20a302Sas200622 smb_vop_setup_xvattr(smb_attr_t *smb_attr, xvattr_t *xvattr); 52da6c28aaSamw 53da6c28aaSamw static int 54faa1795aSjb150015 smb_vop_readdir_readpage(vnode_t *, void *, uint32_t, int *, cred_t *, int); 55da6c28aaSamw 56da6c28aaSamw static int 57faa1795aSjb150015 smb_vop_readdir_entry(vnode_t *, uint32_t *, char *, int *, 58faa1795aSjb150015 ino64_t *, vnode_t **, char *, int, cred_t *, char *, int); 59da6c28aaSamw 60da6c28aaSamw static int 61faa1795aSjb150015 smb_vop_getdents_entries(smb_node_t *, uint32_t *, int32_t *, char *, uint32_t, 62faa1795aSjb150015 smb_request_t *, cred_t *, char *, int *, int, char *); 63da6c28aaSamw 64da6c28aaSamw extern int 65da6c28aaSamw smb_gather_dents_info(char *args, ino_t fileid, int namelen, 66da6c28aaSamw char *name, uint32_t cookie, int32_t *countp, 67da6c28aaSamw smb_attr_t *attr, struct smb_node *snode, 68da6c28aaSamw char *shortname, char *name83); 69da6c28aaSamw 70da6c28aaSamw static void 71da6c28aaSamw smb_sa_to_va_mask(uint_t sa_mask, uint_t *va_maskp); 72da6c28aaSamw 73*8c10a865Sas200622 static 74*8c10a865Sas200622 callb_cpr_t *smb_lock_frlock_callback(flk_cb_when_t, void *); 75*8c10a865Sas200622 76dc20a302Sas200622 extern sysid_t lm_alloc_sysidt(); 77dc20a302Sas200622 78da6c28aaSamw #define SMB_AT_MAX 16 79da6c28aaSamw static uint_t smb_attrmap[SMB_AT_MAX] = { 80da6c28aaSamw 0, 81da6c28aaSamw AT_TYPE, 82da6c28aaSamw AT_MODE, 83da6c28aaSamw AT_UID, 84da6c28aaSamw AT_GID, 85da6c28aaSamw AT_FSID, 86da6c28aaSamw AT_NODEID, 87da6c28aaSamw AT_NLINK, 88da6c28aaSamw AT_SIZE, 89da6c28aaSamw AT_ATIME, 90da6c28aaSamw AT_MTIME, 91da6c28aaSamw AT_CTIME, 92da6c28aaSamw AT_RDEV, 93da6c28aaSamw AT_BLKSIZE, 94da6c28aaSamw AT_NBLOCKS, 95da6c28aaSamw AT_SEQ 96da6c28aaSamw }; 97da6c28aaSamw 98faa1795aSjb150015 static boolean_t smb_vop_initialized = B_FALSE; 99faa1795aSjb150015 caller_context_t smb_ct; 100faa1795aSjb150015 101faa1795aSjb150015 /* 102faa1795aSjb150015 * smb_vop_init 103faa1795aSjb150015 * 104faa1795aSjb150015 * This function is not multi-thread safe. The caller must make sure only one 105faa1795aSjb150015 * thread makes the call. 106faa1795aSjb150015 */ 107faa1795aSjb150015 int 108faa1795aSjb150015 smb_vop_init(void) 109faa1795aSjb150015 { 110faa1795aSjb150015 if (smb_vop_initialized) 111faa1795aSjb150015 return (0); 112faa1795aSjb150015 /* 113faa1795aSjb150015 * The caller_context will be used primarily for range locking. 114faa1795aSjb150015 * Since the CIFS server is mapping its locks to POSIX locks, 115faa1795aSjb150015 * only one pid is used for operations originating from the 116faa1795aSjb150015 * CIFS server (to represent CIFS in the VOP_FRLOCK routines). 117faa1795aSjb150015 */ 118faa1795aSjb150015 smb_ct.cc_sysid = lm_alloc_sysidt(); 119faa1795aSjb150015 if (smb_ct.cc_sysid == LM_NOSYSID) 120faa1795aSjb150015 return (ENOMEM); 121faa1795aSjb150015 122faa1795aSjb150015 smb_ct.cc_caller_id = fs_new_caller_id(); 1236537f381Sas200622 smb_ct.cc_pid = IGN_PID; 124faa1795aSjb150015 smb_ct.cc_flags = 0; 125faa1795aSjb150015 126faa1795aSjb150015 smb_vop_initialized = B_TRUE; 127faa1795aSjb150015 return (0); 128faa1795aSjb150015 } 129faa1795aSjb150015 130faa1795aSjb150015 /* 131faa1795aSjb150015 * smb_vop_fini 132faa1795aSjb150015 * 133faa1795aSjb150015 * This function is not multi-thread safe. The caller must make sure only one 134faa1795aSjb150015 * thread makes the call. 135faa1795aSjb150015 */ 136faa1795aSjb150015 void 137faa1795aSjb150015 smb_vop_fini(void) 138faa1795aSjb150015 { 139faa1795aSjb150015 if (!smb_vop_initialized) 140faa1795aSjb150015 return; 141faa1795aSjb150015 142faa1795aSjb150015 lm_free_sysidt(smb_ct.cc_sysid); 1436537f381Sas200622 smb_ct.cc_pid = IGN_PID; 144faa1795aSjb150015 smb_ct.cc_sysid = LM_NOSYSID; 145faa1795aSjb150015 smb_vop_initialized = B_FALSE; 146faa1795aSjb150015 } 147faa1795aSjb150015 148dc20a302Sas200622 /* 149dc20a302Sas200622 * The smb_ct will be used primarily for range locking. 150dc20a302Sas200622 * Since the CIFS server is mapping its locks to POSIX locks, 151dc20a302Sas200622 * only one pid is used for operations originating from the 152dc20a302Sas200622 * CIFS server (to represent CIFS in the VOP_FRLOCK routines). 153dc20a302Sas200622 */ 154dc20a302Sas200622 155da6c28aaSamw int 156dc20a302Sas200622 smb_vop_open(vnode_t **vpp, int mode, cred_t *cred) 157da6c28aaSamw { 158dc20a302Sas200622 return (VOP_OPEN(vpp, mode, cred, &smb_ct)); 159dc20a302Sas200622 } 160dc20a302Sas200622 161dc20a302Sas200622 int 162dc20a302Sas200622 smb_vop_close(vnode_t *vp, int mode, cred_t *cred) 163dc20a302Sas200622 { 164dc20a302Sas200622 return (VOP_CLOSE(vp, mode, 1, (offset_t)0, cred, &smb_ct)); 165da6c28aaSamw } 166da6c28aaSamw 167*8c10a865Sas200622 int 168*8c10a865Sas200622 smb_vop_other_opens(vnode_t *vp, int mode) 169*8c10a865Sas200622 { 170*8c10a865Sas200622 return (((mode & FWRITE) && vn_has_other_opens(vp, V_WRITE)) || 171*8c10a865Sas200622 (((mode & FWRITE) == 0) && vn_is_opened(vp, V_WRITE)) || 172*8c10a865Sas200622 ((mode & FREAD) && vn_has_other_opens(vp, V_READ)) || 173*8c10a865Sas200622 (((mode & FREAD) == 0) && vn_is_opened(vp, V_READ)) || 174*8c10a865Sas200622 vn_is_mapped(vp, V_RDORWR)); 175*8c10a865Sas200622 } 176*8c10a865Sas200622 177da6c28aaSamw /* 178da6c28aaSamw * The smb_vop_* functions have minimal knowledge of CIFS semantics and 179da6c28aaSamw * serve as an interface to the VFS layer. 180da6c28aaSamw * 181da6c28aaSamw * Only smb_fsop_* layer functions should call smb_vop_* layer functions. 182da6c28aaSamw * (Higher-level CIFS service code should never skip the smb_fsop_* layer 183da6c28aaSamw * to call smb_vop_* layer functions directly.) 184da6c28aaSamw */ 185da6c28aaSamw 186da6c28aaSamw /* 187da6c28aaSamw * XXX - Extended attributes support in the file system assumed. 188da6c28aaSamw * This is needed for full NT Streams functionality. 189da6c28aaSamw */ 190da6c28aaSamw 191da6c28aaSamw int 192dc20a302Sas200622 smb_vop_read(vnode_t *vp, uio_t *uiop, cred_t *cr) 193da6c28aaSamw { 194da6c28aaSamw int error; 195da6c28aaSamw 196*8c10a865Sas200622 (void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, &smb_ct); 197dc20a302Sas200622 error = VOP_READ(vp, uiop, 0, cr, &smb_ct); 198*8c10a865Sas200622 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, &smb_ct); 199da6c28aaSamw return (error); 200da6c28aaSamw } 201da6c28aaSamw 202da6c28aaSamw int 203da6c28aaSamw smb_vop_write(vnode_t *vp, uio_t *uiop, uint32_t *flag, uint32_t *lcount, 204dc20a302Sas200622 cred_t *cr) 205da6c28aaSamw { 206da6c28aaSamw int error; 207da6c28aaSamw int ioflag = 0; 208da6c28aaSamw 209da6c28aaSamw *lcount = uiop->uio_resid; 210da6c28aaSamw 211da6c28aaSamw if (*flag == FSSTAB_FILE_SYNC) 212da6c28aaSamw ioflag = FSYNC; 213da6c28aaSamw 214da6c28aaSamw uiop->uio_llimit = MAXOFFSET_T; 215da6c28aaSamw 216*8c10a865Sas200622 (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, &smb_ct); 217dc20a302Sas200622 error = VOP_WRITE(vp, uiop, ioflag, cr, &smb_ct); 218*8c10a865Sas200622 VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, &smb_ct); 219da6c28aaSamw 220da6c28aaSamw *lcount -= uiop->uio_resid; 221da6c28aaSamw 222da6c28aaSamw return (error); 223da6c28aaSamw } 224da6c28aaSamw 225da6c28aaSamw /* 226da6c28aaSamw * smb_vop_getattr() 227da6c28aaSamw * 228da6c28aaSamw * smb_fsop_getattr()/smb_vop_getattr() should always be called from the CIFS 229da6c28aaSamw * service (instead of calling VOP_GETATTR directly) to retrieve attributes 230da6c28aaSamw * due to special processing needed for streams files. 231da6c28aaSamw * 232da6c28aaSamw * All attributes are retrieved. 233da6c28aaSamw * 234da6c28aaSamw * A named stream's attributes (as far as CIFS is concerned) are those of the 235da6c28aaSamw * unnamed (i.e. data) stream (minus the size attribute), and the size of the 236da6c28aaSamw * named stream. Though the file system may store attributes other than size 237da6c28aaSamw * with the named stream, these should not be used by CIFS for any purpose. 238da6c28aaSamw * 239da6c28aaSamw * When vp denotes a named stream, then unnamed_vp should be passed in (denoting 240da6c28aaSamw * the corresponding unnamed stream). 241da6c28aaSamw */ 242da6c28aaSamw 243da6c28aaSamw int 244da6c28aaSamw smb_vop_getattr(vnode_t *vp, vnode_t *unnamed_vp, smb_attr_t *ret_attr, 245dc20a302Sas200622 int flags, cred_t *cr) 246da6c28aaSamw { 247da6c28aaSamw int error; 248da6c28aaSamw vnode_t *use_vp; 249da6c28aaSamw smb_attr_t tmp_attr; 250da6c28aaSamw xvattr_t tmp_xvattr; 251da6c28aaSamw xoptattr_t *xoap = NULL; 252da6c28aaSamw 253da6c28aaSamw if (unnamed_vp) 254da6c28aaSamw use_vp = unnamed_vp; 255da6c28aaSamw else 256da6c28aaSamw use_vp = vp; 257da6c28aaSamw 258da6c28aaSamw if (vfs_has_feature(use_vp->v_vfsp, VFSFT_XVATTR)) { 259da6c28aaSamw xva_init(&tmp_xvattr); 260da6c28aaSamw xoap = xva_getxoptattr(&tmp_xvattr); 261da6c28aaSamw 262da6c28aaSamw ASSERT(xoap); 263da6c28aaSamw 264da6c28aaSamw smb_sa_to_va_mask(ret_attr->sa_mask, 265da6c28aaSamw &tmp_xvattr.xva_vattr.va_mask); 266da6c28aaSamw 267da6c28aaSamw XVA_SET_REQ(&tmp_xvattr, XAT_READONLY); 268da6c28aaSamw XVA_SET_REQ(&tmp_xvattr, XAT_HIDDEN); 269da6c28aaSamw XVA_SET_REQ(&tmp_xvattr, XAT_SYSTEM); 270da6c28aaSamw XVA_SET_REQ(&tmp_xvattr, XAT_ARCHIVE); 271da6c28aaSamw XVA_SET_REQ(&tmp_xvattr, XAT_CREATETIME); 272da6c28aaSamw 273da6c28aaSamw if ((error = VOP_GETATTR(use_vp, (vattr_t *)&tmp_xvattr, flags, 274dc20a302Sas200622 cr, &smb_ct)) != 0) 275da6c28aaSamw return (error); 276da6c28aaSamw 277da6c28aaSamw ret_attr->sa_vattr = tmp_xvattr.xva_vattr; 278da6c28aaSamw 279da6c28aaSamw /* 280da6c28aaSamw * Copy special attributes to ret_attr parameter 281da6c28aaSamw */ 282da6c28aaSamw 283da6c28aaSamw ret_attr->sa_dosattr = 0; 284da6c28aaSamw 285da6c28aaSamw ASSERT(tmp_xvattr.xva_vattr.va_mask & AT_XVATTR); 286da6c28aaSamw 287da6c28aaSamw xoap = xva_getxoptattr(&tmp_xvattr); 288da6c28aaSamw ASSERT(xoap); 289da6c28aaSamw 290da6c28aaSamw if (XVA_ISSET_RTN(&tmp_xvattr, XAT_READONLY)) { 291da6c28aaSamw if (xoap->xoa_readonly) 292da6c28aaSamw ret_attr->sa_dosattr |= FILE_ATTRIBUTE_READONLY; 293da6c28aaSamw } 294da6c28aaSamw 295da6c28aaSamw if (XVA_ISSET_RTN(&tmp_xvattr, XAT_HIDDEN)) { 296da6c28aaSamw if (xoap->xoa_hidden) 297da6c28aaSamw ret_attr->sa_dosattr |= FILE_ATTRIBUTE_HIDDEN; 298da6c28aaSamw } 299da6c28aaSamw 300da6c28aaSamw if (XVA_ISSET_RTN(&tmp_xvattr, XAT_SYSTEM)) { 301da6c28aaSamw if (xoap->xoa_system) 302da6c28aaSamw ret_attr->sa_dosattr |= FILE_ATTRIBUTE_SYSTEM; 303da6c28aaSamw } 304da6c28aaSamw 305da6c28aaSamw if (XVA_ISSET_RTN(&tmp_xvattr, XAT_ARCHIVE)) { 306da6c28aaSamw if (xoap->xoa_archive) 307da6c28aaSamw ret_attr->sa_dosattr |= FILE_ATTRIBUTE_ARCHIVE; 308da6c28aaSamw } 309da6c28aaSamw 310da6c28aaSamw ret_attr->sa_crtime = xoap->xoa_createtime; 311da6c28aaSamw 312da6c28aaSamw if (unnamed_vp && (ret_attr->sa_mask & SMB_AT_SIZE)) { 313da6c28aaSamw /* 314da6c28aaSamw * Retrieve stream size attribute into temporary 315da6c28aaSamw * structure, in case the underlying file system 316da6c28aaSamw * returns attributes other than the size (we do not 317da6c28aaSamw * want to have ret_attr's other fields get 318da6c28aaSamw * overwritten). 319da6c28aaSamw * 320da6c28aaSamw * Note that vp is used here, and not use_vp. 321da6c28aaSamw * Also, only AT_SIZE is needed. 322da6c28aaSamw */ 323da6c28aaSamw 324da6c28aaSamw tmp_xvattr.xva_vattr.va_mask = AT_SIZE; 325da6c28aaSamw 326da6c28aaSamw if ((error = VOP_GETATTR(vp, (vattr_t *)&tmp_xvattr, 327dc20a302Sas200622 flags, cr, &smb_ct)) != 0) 328da6c28aaSamw return (error); 329da6c28aaSamw 330da6c28aaSamw ret_attr->sa_vattr.va_size = 331da6c28aaSamw tmp_xvattr.xva_vattr.va_size; 332da6c28aaSamw 333da6c28aaSamw } 334da6c28aaSamw 335da6c28aaSamw if (ret_attr->sa_vattr.va_type == VDIR) { 336da6c28aaSamw ret_attr->sa_dosattr |= FILE_ATTRIBUTE_DIRECTORY; 337da6c28aaSamw } 338da6c28aaSamw 339da6c28aaSamw return (error); 340da6c28aaSamw } 341da6c28aaSamw 342da6c28aaSamw /* 343da6c28aaSamw * Support for file systems without VFSFT_XVATTR 344da6c28aaSamw */ 345da6c28aaSamw 346da6c28aaSamw smb_sa_to_va_mask(ret_attr->sa_mask, 347da6c28aaSamw &ret_attr->sa_vattr.va_mask); 348da6c28aaSamw 349dc20a302Sas200622 error = VOP_GETATTR(use_vp, &ret_attr->sa_vattr, flags, cr, &smb_ct); 350da6c28aaSamw 351da6c28aaSamw if (error != 0) 352da6c28aaSamw return (error); 353da6c28aaSamw 354da6c28aaSamw /* 355da6c28aaSamw * "Fake" DOS attributes and create time, filesystem doesn't support 356da6c28aaSamw * them. 357da6c28aaSamw */ 358da6c28aaSamw 359da6c28aaSamw ret_attr->sa_dosattr = 0; 360da6c28aaSamw ret_attr->sa_crtime = ret_attr->sa_vattr.va_ctime; 361da6c28aaSamw 362da6c28aaSamw if (unnamed_vp && (ret_attr->sa_mask & SMB_AT_SIZE)) { 363da6c28aaSamw /* 364da6c28aaSamw * Retrieve stream size attribute into temporary structure, 365da6c28aaSamw * in case the underlying file system returns attributes 366da6c28aaSamw * other than the size (we do not want to have ret_attr's 367da6c28aaSamw * other fields get overwritten). 368da6c28aaSamw * 369da6c28aaSamw * Note that vp is used here, and not use_vp. 370da6c28aaSamw * Also, only AT_SIZE is needed. 371da6c28aaSamw */ 372da6c28aaSamw 373da6c28aaSamw tmp_attr.sa_vattr.va_mask = AT_SIZE; 374dc20a302Sas200622 error = VOP_GETATTR(vp, &tmp_attr.sa_vattr, flags, cr, &smb_ct); 375da6c28aaSamw 376da6c28aaSamw if (error != 0) 377da6c28aaSamw return (error); 378da6c28aaSamw 379da6c28aaSamw 380da6c28aaSamw ret_attr->sa_vattr.va_size = tmp_attr.sa_vattr.va_size; 381da6c28aaSamw } 382da6c28aaSamw 383da6c28aaSamw if (ret_attr->sa_vattr.va_type == VDIR) { 384da6c28aaSamw ret_attr->sa_dosattr |= FILE_ATTRIBUTE_DIRECTORY; 385da6c28aaSamw } 386da6c28aaSamw 387da6c28aaSamw return (error); 388da6c28aaSamw } 389da6c28aaSamw 390da6c28aaSamw /* 391da6c28aaSamw * smb_vop_setattr() 392da6c28aaSamw * 3937b59d02dSjb150015 * smb_fsop_setattr()/smb_vop_setattr() should always be used instead of 3947b59d02dSjb150015 * VOP_SETATTR() when calling from the CIFS service, due to special processing 3957b59d02dSjb150015 * for streams files. 396da6c28aaSamw * 3977b59d02dSjb150015 * Streams have a size but otherwise do not have separate attributes from 3987b59d02dSjb150015 * the (unnamed stream) file, i.e., the security and ownership of the file 3997b59d02dSjb150015 * applies to the stream. In contrast, extended attribute files, which are 4007b59d02dSjb150015 * used to implement streams, are independent objects with their own 4017b59d02dSjb150015 * attributes. 4027b59d02dSjb150015 * 4037b59d02dSjb150015 * For compatibility with streams, we set the size on the extended attribute 4047b59d02dSjb150015 * file and apply other attributes to the (unnamed stream) file. The one 4057b59d02dSjb150015 * exception is that the UID and GID can be set on the stream by passing a 4067b59d02dSjb150015 * NULL unnamed_vp, which allows callers to synchronize stream ownership 4077b59d02dSjb150015 * with the (unnamed stream) file. 408da6c28aaSamw */ 409da6c28aaSamw 410da6c28aaSamw int 411da6c28aaSamw smb_vop_setattr(vnode_t *vp, vnode_t *unnamed_vp, smb_attr_t *set_attr, 412dc20a302Sas200622 int flags, cred_t *cr, boolean_t no_xvattr) 413da6c28aaSamw { 414da6c28aaSamw int error = 0; 415da6c28aaSamw int at_size = 0; 416da6c28aaSamw vnode_t *use_vp; 417dc20a302Sas200622 xvattr_t xvattr; 418dc20a302Sas200622 vattr_t *vap; 419da6c28aaSamw 420da6c28aaSamw if (unnamed_vp) { 421da6c28aaSamw use_vp = unnamed_vp; 422da6c28aaSamw if (set_attr->sa_mask & SMB_AT_SIZE) { 423da6c28aaSamw at_size = 1; 424da6c28aaSamw set_attr->sa_mask &= ~SMB_AT_SIZE; 425da6c28aaSamw } 426da6c28aaSamw } else { 427da6c28aaSamw use_vp = vp; 428da6c28aaSamw } 429da6c28aaSamw 430da6c28aaSamw /* 431da6c28aaSamw * The caller should not be setting sa_vattr.va_mask, 432da6c28aaSamw * but rather sa_mask. 433da6c28aaSamw */ 434da6c28aaSamw 435da6c28aaSamw set_attr->sa_vattr.va_mask = 0; 436da6c28aaSamw 43755bf511dSas200622 if ((no_xvattr == B_FALSE) && 43855bf511dSas200622 vfs_has_feature(use_vp->v_vfsp, VFSFT_XVATTR)) { 439da6c28aaSamw 440dc20a302Sas200622 smb_vop_setup_xvattr(set_attr, &xvattr); 441dc20a302Sas200622 vap = (vattr_t *)&xvattr; 442dc20a302Sas200622 } else { 443da6c28aaSamw smb_sa_to_va_mask(set_attr->sa_mask, 444dc20a302Sas200622 &set_attr->sa_vattr.va_mask); 445dc20a302Sas200622 vap = &set_attr->sa_vattr; 446da6c28aaSamw } 447da6c28aaSamw 448dc20a302Sas200622 if ((error = VOP_SETATTR(use_vp, vap, flags, cr, &smb_ct)) != 0) 449da6c28aaSamw return (error); 450da6c28aaSamw 451da6c28aaSamw /* 452da6c28aaSamw * If the size of the stream needs to be set, set it on 453da6c28aaSamw * the stream file directly. (All other indicated attributes 4547b59d02dSjb150015 * are set on the stream's unnamed stream, except under the 4557b59d02dSjb150015 * exception described in the function header.) 456da6c28aaSamw */ 457da6c28aaSamw 458da6c28aaSamw if (at_size) { 459da6c28aaSamw /* 460da6c28aaSamw * set_attr->sa_vattr.va_size already contains the 461da6c28aaSamw * size as set by the caller 462da6c28aaSamw * 463da6c28aaSamw * Note that vp is used here, and not use_vp. 464da6c28aaSamw * Also, only AT_SIZE is needed. 465da6c28aaSamw */ 466da6c28aaSamw 467da6c28aaSamw set_attr->sa_vattr.va_mask = AT_SIZE; 468dc20a302Sas200622 error = VOP_SETATTR(vp, &set_attr->sa_vattr, flags, cr, 469dc20a302Sas200622 &smb_ct); 470da6c28aaSamw } 471da6c28aaSamw 472da6c28aaSamw return (error); 473da6c28aaSamw } 474da6c28aaSamw 475da6c28aaSamw /* 476da6c28aaSamw * smb_vop_access 477da6c28aaSamw * 478da6c28aaSamw * This is a wrapper round VOP_ACCESS. VOP_ACCESS checks the given mode 479da6c28aaSamw * against file's ACL or Unix permissions. CIFS on the other hand needs to 480da6c28aaSamw * know if the requested operation can succeed for the given object, this 481da6c28aaSamw * requires more checks in case of DELETE bit since permissions on the parent 482da6c28aaSamw * directory are important as well. Based on Windows rules if parent's ACL 483da6c28aaSamw * grant FILE_DELETE_CHILD a file can be delete regardless of the file's 484da6c28aaSamw * permissions. 485da6c28aaSamw */ 486da6c28aaSamw int 487da6c28aaSamw smb_vop_access(vnode_t *vp, int mode, int flags, vnode_t *dir_vp, cred_t *cr) 488da6c28aaSamw { 489da6c28aaSamw int error = 0; 490da6c28aaSamw 491da6c28aaSamw if (mode == 0) 492da6c28aaSamw return (0); 493da6c28aaSamw 494da6c28aaSamw if ((flags == V_ACE_MASK) && (mode & ACE_DELETE)) { 495da6c28aaSamw if (dir_vp) { 496da6c28aaSamw error = VOP_ACCESS(dir_vp, ACE_DELETE_CHILD, flags, 497da6c28aaSamw cr, NULL); 498da6c28aaSamw 499da6c28aaSamw if (error == 0) 500da6c28aaSamw mode &= ~ACE_DELETE; 501da6c28aaSamw } 502da6c28aaSamw } 503da6c28aaSamw 504da6c28aaSamw if (mode) { 505da6c28aaSamw error = VOP_ACCESS(vp, mode, flags, cr, NULL); 506da6c28aaSamw } 507da6c28aaSamw 508da6c28aaSamw return (error); 509da6c28aaSamw } 510da6c28aaSamw 511da6c28aaSamw /* 512da6c28aaSamw * smb_vop_lookup 513da6c28aaSamw * 514da6c28aaSamw * dvp: directory vnode (in) 515da6c28aaSamw * name: name of file to be looked up (in) 516da6c28aaSamw * vpp: looked-up vnode (out) 517da6c28aaSamw * od_name: on-disk name of file (out). 518da6c28aaSamw * This parameter is optional. If a pointer is passed in, it 519da6c28aaSamw * must be allocated with MAXNAMELEN bytes 520da6c28aaSamw * rootvp: vnode of the tree root (in) 521da6c28aaSamw * This parameter is always passed in non-NULL except at the time 522da6c28aaSamw * of share set up. 523da6c28aaSamw */ 524da6c28aaSamw 525da6c28aaSamw int 526faa1795aSjb150015 smb_vop_lookup( 527faa1795aSjb150015 vnode_t *dvp, 528faa1795aSjb150015 char *name, 529faa1795aSjb150015 vnode_t **vpp, 530faa1795aSjb150015 char *od_name, 531faa1795aSjb150015 int flags, 532faa1795aSjb150015 vnode_t *rootvp, 533faa1795aSjb150015 cred_t *cr) 534da6c28aaSamw { 535da6c28aaSamw int error = 0; 536da6c28aaSamw int option_flags = 0; 537da6c28aaSamw pathname_t rpn; 538da6c28aaSamw 539da6c28aaSamw if (*name == '\0') 540da6c28aaSamw return (EINVAL); 541da6c28aaSamw 542da6c28aaSamw ASSERT(vpp); 543da6c28aaSamw *vpp = NULL; 544da6c28aaSamw 545da6c28aaSamw if ((name[0] == '.') && (name[1] == '.') && (name[2] == 0)) { 546da6c28aaSamw if (rootvp && (dvp == rootvp)) { 547da6c28aaSamw VN_HOLD(dvp); 548da6c28aaSamw *vpp = dvp; 549da6c28aaSamw return (0); 550da6c28aaSamw } 551da6c28aaSamw 552da6c28aaSamw if (dvp->v_flag & VROOT) { 553da6c28aaSamw vfs_t *vfsp; 554da6c28aaSamw vnode_t *cvp = dvp; 555da6c28aaSamw 556da6c28aaSamw /* 557da6c28aaSamw * Set dvp and check for races with forced unmount 558da6c28aaSamw * (see lookuppnvp()) 559da6c28aaSamw */ 560da6c28aaSamw 561da6c28aaSamw vfsp = cvp->v_vfsp; 562da6c28aaSamw vfs_rlock_wait(vfsp); 563da6c28aaSamw if (((dvp = cvp->v_vfsp->vfs_vnodecovered) == NULL) || 564da6c28aaSamw (cvp->v_vfsp->vfs_flag & VFS_UNMOUNTED)) { 565da6c28aaSamw vfs_unlock(vfsp); 566da6c28aaSamw return (EIO); 567da6c28aaSamw } 568da6c28aaSamw vfs_unlock(vfsp); 569da6c28aaSamw } 570da6c28aaSamw } 571da6c28aaSamw 572da6c28aaSamw 573da6c28aaSamw 574da6c28aaSamw if (flags & SMB_IGNORE_CASE) 575da6c28aaSamw option_flags = FIGNORECASE; 576da6c28aaSamw 577da6c28aaSamw pn_alloc(&rpn); 578da6c28aaSamw 579da6c28aaSamw error = VOP_LOOKUP(dvp, name, vpp, NULL, option_flags, NULL, cr, 580dc20a302Sas200622 &smb_ct, NULL, &rpn); 581da6c28aaSamw 582da6c28aaSamw if ((error == 0) && od_name) { 583da6c28aaSamw bzero(od_name, MAXNAMELEN); 584da6c28aaSamw if (option_flags == FIGNORECASE) 585da6c28aaSamw (void) strlcpy(od_name, rpn.pn_buf, MAXNAMELEN); 586da6c28aaSamw else 587da6c28aaSamw (void) strlcpy(od_name, name, MAXNAMELEN); 588da6c28aaSamw } 589da6c28aaSamw 590da6c28aaSamw pn_free(&rpn); 591da6c28aaSamw return (error); 592da6c28aaSamw } 593da6c28aaSamw 594da6c28aaSamw int 595da6c28aaSamw smb_vop_create(vnode_t *dvp, char *name, smb_attr_t *attr, vnode_t **vpp, 596dc20a302Sas200622 int flags, cred_t *cr, vsecattr_t *vsap) 597da6c28aaSamw { 598da6c28aaSamw int error; 599da6c28aaSamw int option_flags = 0; 600dc20a302Sas200622 xvattr_t xvattr; 601dc20a302Sas200622 vattr_t *vap; 602da6c28aaSamw 603da6c28aaSamw if (flags & SMB_IGNORE_CASE) 604da6c28aaSamw option_flags = FIGNORECASE; 605da6c28aaSamw 606dc20a302Sas200622 attr->sa_vattr.va_mask = 0; 607da6c28aaSamw 608dc20a302Sas200622 if (vfs_has_feature(dvp->v_vfsp, VFSFT_XVATTR)) { 609dc20a302Sas200622 smb_vop_setup_xvattr(attr, &xvattr); 610dc20a302Sas200622 vap = (vattr_t *)&xvattr; 611dc20a302Sas200622 } else { 612dc20a302Sas200622 smb_sa_to_va_mask(attr->sa_mask, &attr->sa_vattr.va_mask); 613dc20a302Sas200622 vap = &attr->sa_vattr; 614dc20a302Sas200622 } 615dc20a302Sas200622 616dc20a302Sas200622 error = VOP_CREATE(dvp, name, vap, EXCL, attr->sa_vattr.va_mode, 617dc20a302Sas200622 vpp, cr, option_flags, &smb_ct, vsap); 618da6c28aaSamw 619da6c28aaSamw return (error); 620da6c28aaSamw } 621da6c28aaSamw 622da6c28aaSamw int 623dc20a302Sas200622 smb_vop_remove(vnode_t *dvp, char *name, int flags, cred_t *cr) 624da6c28aaSamw { 625da6c28aaSamw int error; 626da6c28aaSamw int option_flags = 0; 627da6c28aaSamw 628da6c28aaSamw if (flags & SMB_IGNORE_CASE) 629da6c28aaSamw option_flags = FIGNORECASE; 630da6c28aaSamw 631dc20a302Sas200622 error = VOP_REMOVE(dvp, name, cr, &smb_ct, option_flags); 632da6c28aaSamw 633da6c28aaSamw return (error); 634da6c28aaSamw } 635da6c28aaSamw 636da6c28aaSamw /* 637da6c28aaSamw * smb_vop_rename() 638da6c28aaSamw * 639da6c28aaSamw * The rename is for files in the same tree (identical TID) only. 640da6c28aaSamw */ 641da6c28aaSamw 642da6c28aaSamw int 643da6c28aaSamw smb_vop_rename(vnode_t *from_dvp, char *from_name, vnode_t *to_dvp, 644dc20a302Sas200622 char *to_name, int flags, cred_t *cr) 645da6c28aaSamw { 646da6c28aaSamw int error; 647da6c28aaSamw int option_flags = 0; 648da6c28aaSamw 649da6c28aaSamw 650da6c28aaSamw if (flags & SMB_IGNORE_CASE) 651da6c28aaSamw option_flags = FIGNORECASE; 652da6c28aaSamw 653da6c28aaSamw error = VOP_RENAME(from_dvp, from_name, to_dvp, to_name, cr, 654dc20a302Sas200622 &smb_ct, option_flags); 655da6c28aaSamw 656da6c28aaSamw return (error); 657da6c28aaSamw } 658da6c28aaSamw 659da6c28aaSamw int 660da6c28aaSamw smb_vop_mkdir(vnode_t *dvp, char *name, smb_attr_t *attr, vnode_t **vpp, 661dc20a302Sas200622 int flags, cred_t *cr, vsecattr_t *vsap) 662da6c28aaSamw { 663da6c28aaSamw int error; 664da6c28aaSamw int option_flags = 0; 665da6c28aaSamw 666da6c28aaSamw 667da6c28aaSamw 668da6c28aaSamw if (flags & SMB_IGNORE_CASE) 669da6c28aaSamw option_flags = FIGNORECASE; 670da6c28aaSamw 671da6c28aaSamw smb_sa_to_va_mask(attr->sa_mask, &attr->sa_vattr.va_mask); 672da6c28aaSamw 673dc20a302Sas200622 error = VOP_MKDIR(dvp, name, &attr->sa_vattr, vpp, cr, &smb_ct, 674da6c28aaSamw option_flags, vsap); 675da6c28aaSamw 676da6c28aaSamw return (error); 677da6c28aaSamw } 678da6c28aaSamw 679da6c28aaSamw /* 680da6c28aaSamw * smb_vop_rmdir() 681da6c28aaSamw * 682da6c28aaSamw * Only simple rmdir supported, consistent with NT semantics 683da6c28aaSamw * (can only remove an empty directory). 684da6c28aaSamw * 685da6c28aaSamw */ 686da6c28aaSamw 687da6c28aaSamw int 688dc20a302Sas200622 smb_vop_rmdir(vnode_t *dvp, char *name, int flags, cred_t *cr) 689da6c28aaSamw { 690da6c28aaSamw int error; 691da6c28aaSamw int option_flags = 0; 692da6c28aaSamw 693da6c28aaSamw if (flags & SMB_IGNORE_CASE) 694da6c28aaSamw option_flags = FIGNORECASE; 695da6c28aaSamw 696da6c28aaSamw /* 697da6c28aaSamw * Comments adapted from rfs_rmdir(). 698da6c28aaSamw * 699da6c28aaSamw * VOP_RMDIR now takes a new third argument (the current 700da6c28aaSamw * directory of the process). That's because rmdir 701da6c28aaSamw * wants to return EINVAL if one tries to remove ".". 702da6c28aaSamw * Of course, SMB servers do not know what their 703da6c28aaSamw * clients' current directories are. We fake it by 704da6c28aaSamw * supplying a vnode known to exist and illegal to 705da6c28aaSamw * remove. 706da6c28aaSamw */ 707da6c28aaSamw 708dc20a302Sas200622 error = VOP_RMDIR(dvp, name, rootdir, cr, &smb_ct, option_flags); 709da6c28aaSamw return (error); 710da6c28aaSamw } 711da6c28aaSamw 712da6c28aaSamw int 713dc20a302Sas200622 smb_vop_commit(vnode_t *vp, cred_t *cr) 714da6c28aaSamw { 715dc20a302Sas200622 return (VOP_FSYNC(vp, 1, cr, &smb_ct)); 716da6c28aaSamw } 717da6c28aaSamw 718dc20a302Sas200622 void 719dc20a302Sas200622 smb_vop_setup_xvattr(smb_attr_t *smb_attr, xvattr_t *xvattr) 720dc20a302Sas200622 { 721dc20a302Sas200622 xoptattr_t *xoap = NULL; 722dc20a302Sas200622 uint_t xva_mask; 723dc20a302Sas200622 724dc20a302Sas200622 /* 725dc20a302Sas200622 * Initialize xvattr, including bzero 726dc20a302Sas200622 */ 727dc20a302Sas200622 xva_init(xvattr); 728dc20a302Sas200622 xoap = xva_getxoptattr(xvattr); 729dc20a302Sas200622 730dc20a302Sas200622 ASSERT(xoap); 731dc20a302Sas200622 732dc20a302Sas200622 /* 733dc20a302Sas200622 * Copy caller-specified classic attributes to xvattr. 734dc20a302Sas200622 * First save xvattr's mask (set in xva_init()), which 735dc20a302Sas200622 * contains AT_XVATTR. This is |'d in later if needed. 736dc20a302Sas200622 */ 737dc20a302Sas200622 738dc20a302Sas200622 xva_mask = xvattr->xva_vattr.va_mask; 739dc20a302Sas200622 xvattr->xva_vattr = smb_attr->sa_vattr; 740dc20a302Sas200622 741dc20a302Sas200622 smb_sa_to_va_mask(smb_attr->sa_mask, &xvattr->xva_vattr.va_mask); 742dc20a302Sas200622 743dc20a302Sas200622 /* 744dc20a302Sas200622 * Do not set ctime (only the file system can do it) 745dc20a302Sas200622 */ 746dc20a302Sas200622 747dc20a302Sas200622 xvattr->xva_vattr.va_mask &= ~AT_CTIME; 748dc20a302Sas200622 749dc20a302Sas200622 if (smb_attr->sa_mask & SMB_AT_DOSATTR) { 750dc20a302Sas200622 751dc20a302Sas200622 /* 752dc20a302Sas200622 * "|" in the original xva_mask, which contains 753dc20a302Sas200622 * AT_XVATTR 754dc20a302Sas200622 */ 755dc20a302Sas200622 756dc20a302Sas200622 xvattr->xva_vattr.va_mask |= xva_mask; 757dc20a302Sas200622 758dc20a302Sas200622 XVA_SET_REQ(xvattr, XAT_ARCHIVE); 759dc20a302Sas200622 XVA_SET_REQ(xvattr, XAT_SYSTEM); 760dc20a302Sas200622 XVA_SET_REQ(xvattr, XAT_READONLY); 761dc20a302Sas200622 XVA_SET_REQ(xvattr, XAT_HIDDEN); 762dc20a302Sas200622 763dc20a302Sas200622 /* 764dc20a302Sas200622 * smb_attr->sa_dosattr: If a given bit is not set, 765dc20a302Sas200622 * that indicates that the corresponding field needs 766dc20a302Sas200622 * to be updated with a "0" value. This is done 767dc20a302Sas200622 * implicitly as the xoap->xoa_* fields were bzero'd. 768dc20a302Sas200622 */ 769dc20a302Sas200622 770dc20a302Sas200622 if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_ARCHIVE) 771dc20a302Sas200622 xoap->xoa_archive = 1; 772dc20a302Sas200622 773dc20a302Sas200622 if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_SYSTEM) 774dc20a302Sas200622 xoap->xoa_system = 1; 775dc20a302Sas200622 776dc20a302Sas200622 if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_READONLY) 777dc20a302Sas200622 xoap->xoa_readonly = 1; 778dc20a302Sas200622 779dc20a302Sas200622 if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_HIDDEN) 780dc20a302Sas200622 xoap->xoa_hidden = 1; 781dc20a302Sas200622 } 782dc20a302Sas200622 783dc20a302Sas200622 if (smb_attr->sa_mask & SMB_AT_CRTIME) { 784dc20a302Sas200622 /* 785dc20a302Sas200622 * "|" in the original xva_mask, which contains 786dc20a302Sas200622 * AT_XVATTR 787dc20a302Sas200622 */ 788dc20a302Sas200622 789dc20a302Sas200622 xvattr->xva_vattr.va_mask |= xva_mask; 790dc20a302Sas200622 XVA_SET_REQ(xvattr, XAT_CREATETIME); 791dc20a302Sas200622 xoap->xoa_createtime = smb_attr->sa_crtime; 792dc20a302Sas200622 } 793dc20a302Sas200622 } 794dc20a302Sas200622 795dc20a302Sas200622 796da6c28aaSamw /* 797da6c28aaSamw * smb_vop_readdir() 798da6c28aaSamw * 799da6c28aaSamw * Upon return, the "name" field will contain either the on-disk name or, if 800da6c28aaSamw * it needs mangling or has a case-insensitive collision, the mangled 801da6c28aaSamw * "shortname." 802da6c28aaSamw * 803da6c28aaSamw * vpp is an optional parameter. If non-NULL, it will contain a pointer to 804da6c28aaSamw * the vnode for the name that is looked up (the vnode will be returned held). 805da6c28aaSamw * 806da6c28aaSamw * od_name is an optional parameter (NULL can be passed if the on-disk name 807da6c28aaSamw * is not needed by the caller). 808da6c28aaSamw */ 809da6c28aaSamw 810da6c28aaSamw int 811da6c28aaSamw smb_vop_readdir(vnode_t *dvp, uint32_t *cookiep, char *name, int *namelen, 812dc20a302Sas200622 ino64_t *inop, vnode_t **vpp, char *od_name, int flags, cred_t *cr) 813da6c28aaSamw { 814da6c28aaSamw int num_bytes; 815da6c28aaSamw int error = 0; 816da6c28aaSamw char *dirbuf = NULL; 817da6c28aaSamw 818da6c28aaSamw ASSERT(dvp); 819da6c28aaSamw ASSERT(cookiep); 820da6c28aaSamw ASSERT(name); 821da6c28aaSamw ASSERT(namelen); 822da6c28aaSamw ASSERT(inop); 823da6c28aaSamw ASSERT(cr); 824da6c28aaSamw 825da6c28aaSamw if (dvp->v_type != VDIR) { 826da6c28aaSamw *namelen = 0; 827da6c28aaSamw return (ENOTDIR); 828da6c28aaSamw } 829da6c28aaSamw 830da6c28aaSamw if (vpp) 831da6c28aaSamw *vpp = NULL; 832da6c28aaSamw 833da6c28aaSamw dirbuf = kmem_zalloc(SMB_MINLEN_RDDIR_BUF, KM_SLEEP); 834da6c28aaSamw num_bytes = SMB_MINLEN_RDDIR_BUF; 835da6c28aaSamw 836da6c28aaSamw /* 837da6c28aaSamw * The goal is to retrieve the first valid entry from *cookiep 838da6c28aaSamw * forward. smb_vop_readdir_readpage() collects an 839da6c28aaSamw * SMB_MINLEN_RDDIR_BUF-size "page" of directory entry information. 840da6c28aaSamw * smb_vop_readdir_entry() attempts to find the first valid entry 841da6c28aaSamw * in that page. 842da6c28aaSamw */ 843da6c28aaSamw 844da6c28aaSamw while ((error = smb_vop_readdir_readpage(dvp, dirbuf, *cookiep, 845dc20a302Sas200622 &num_bytes, cr, flags)) == 0) { 846da6c28aaSamw 847da6c28aaSamw if (num_bytes <= 0) 848da6c28aaSamw break; 849da6c28aaSamw 850da6c28aaSamw name[0] = '\0'; 851da6c28aaSamw 852da6c28aaSamw error = smb_vop_readdir_entry(dvp, cookiep, name, namelen, 853faa1795aSjb150015 inop, vpp, od_name, flags, cr, dirbuf, num_bytes); 854da6c28aaSamw 855da6c28aaSamw if (error) 856da6c28aaSamw break; 857da6c28aaSamw 858da6c28aaSamw if (*name) 859da6c28aaSamw break; 860da6c28aaSamw 861da6c28aaSamw bzero(dirbuf, SMB_MINLEN_RDDIR_BUF); 862da6c28aaSamw num_bytes = SMB_MINLEN_RDDIR_BUF; 863da6c28aaSamw } 864da6c28aaSamw 865da6c28aaSamw 866da6c28aaSamw if (error) { 867da6c28aaSamw kmem_free(dirbuf, SMB_MINLEN_RDDIR_BUF); 868da6c28aaSamw *namelen = 0; 869da6c28aaSamw return (error); 870da6c28aaSamw } 871da6c28aaSamw 872da6c28aaSamw if (num_bytes == 0) { /* EOF */ 873da6c28aaSamw kmem_free(dirbuf, SMB_MINLEN_RDDIR_BUF); 874da6c28aaSamw *cookiep = SMB_EOF; 875da6c28aaSamw *namelen = 0; 876da6c28aaSamw return (0); 877da6c28aaSamw } 878da6c28aaSamw 879da6c28aaSamw kmem_free(dirbuf, SMB_MINLEN_RDDIR_BUF); 880da6c28aaSamw return (0); 881da6c28aaSamw } 882da6c28aaSamw 883da6c28aaSamw /* 884da6c28aaSamw * smb_vop_readdir_readpage() 885da6c28aaSamw * 886da6c28aaSamw * Collects an SMB_MINLEN_RDDIR_BUF "page" of directory entries. (The 887da6c28aaSamw * directory entries are returned in an fs-independent format by the 888da6c28aaSamw * underlying file system. That is, the "page" of information returned is 889da6c28aaSamw * not literally stored on-disk in the format returned.) 890da6c28aaSamw * 891da6c28aaSamw * Much of the following is borrowed from getdents64() 892da6c28aaSamw * 893da6c28aaSamw * MAXGETDENTS_SIZE is defined in getdents.c 894da6c28aaSamw */ 895da6c28aaSamw 896da6c28aaSamw #define MAXGETDENTS_SIZE (64 * 1024) 897da6c28aaSamw 898da6c28aaSamw static int 899da6c28aaSamw smb_vop_readdir_readpage(vnode_t *vp, void *buf, uint32_t offset, int *count, 900dc20a302Sas200622 cred_t *cr, int flags) 901da6c28aaSamw { 902da6c28aaSamw int error = 0; 903da6c28aaSamw int rdirent_flags = 0; 904da6c28aaSamw int sink; 905da6c28aaSamw struct uio auio; 906da6c28aaSamw struct iovec aiov; 907da6c28aaSamw 908da6c28aaSamw if (vp->v_type != VDIR) 909da6c28aaSamw return (ENOTDIR); 910da6c28aaSamw 911da6c28aaSamw /* entflags not working for streams so don't try to use them */ 912da6c28aaSamw if (!(flags & SMB_STREAM_RDDIR) && 913da6c28aaSamw (vfs_has_feature(vp->v_vfsp, VFSFT_DIRENTFLAGS))) { 914da6c28aaSamw /* 915da6c28aaSamw * Setting V_RDDIR_ENTFLAGS will cause the buffer to 916da6c28aaSamw * be filled with edirent_t structures (instead of 917da6c28aaSamw * dirent64_t structures). 918da6c28aaSamw */ 919da6c28aaSamw rdirent_flags = V_RDDIR_ENTFLAGS; 920da6c28aaSamw 921da6c28aaSamw if (*count < sizeof (edirent_t)) 922da6c28aaSamw return (EINVAL); 923da6c28aaSamw } else { 924da6c28aaSamw if (*count < sizeof (dirent64_t)) 925da6c28aaSamw return (EINVAL); 926da6c28aaSamw } 927da6c28aaSamw 928da6c28aaSamw if (*count > MAXGETDENTS_SIZE) 929da6c28aaSamw *count = MAXGETDENTS_SIZE; 930da6c28aaSamw 931da6c28aaSamw aiov.iov_base = buf; 932da6c28aaSamw aiov.iov_len = *count; 933da6c28aaSamw auio.uio_iov = &aiov; 934da6c28aaSamw auio.uio_iovcnt = 1; 935da6c28aaSamw auio.uio_loffset = (uint64_t)offset; 936da6c28aaSamw auio.uio_segflg = UIO_SYSSPACE; 937da6c28aaSamw auio.uio_resid = *count; 938da6c28aaSamw auio.uio_fmode = 0; 939da6c28aaSamw 940*8c10a865Sas200622 (void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, &smb_ct); 941dc20a302Sas200622 error = VOP_READDIR(vp, &auio, cr, &sink, &smb_ct, rdirent_flags); 942*8c10a865Sas200622 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, &smb_ct); 943da6c28aaSamw 944da6c28aaSamw if (error) { 945da6c28aaSamw if (error == ENOENT) { 946da6c28aaSamw /* Fake EOF if offset is bad due to dropping of lock */ 947da6c28aaSamw *count = 0; 948da6c28aaSamw return (0); 949da6c28aaSamw } else { 950da6c28aaSamw return (error); 951da6c28aaSamw } 952da6c28aaSamw } 953da6c28aaSamw 954da6c28aaSamw /* 955da6c28aaSamw * Windows cannot handle an offset > SMB_EOF. 956da6c28aaSamw * Pretend we are at EOF. 957da6c28aaSamw */ 958da6c28aaSamw 959da6c28aaSamw if (auio.uio_loffset > SMB_EOF) { 960da6c28aaSamw *count = 0; 961da6c28aaSamw return (0); 962da6c28aaSamw } 963da6c28aaSamw 964da6c28aaSamw *count = *count - auio.uio_resid; 965da6c28aaSamw return (0); 966da6c28aaSamw } 967da6c28aaSamw 968da6c28aaSamw /* 969da6c28aaSamw * smb_vop_readdir_entry() 970da6c28aaSamw * 971da6c28aaSamw * This function retrieves the first valid entry from the 972da6c28aaSamw * SMB_MINLEN_RDDIR_BUF-sized buffer returned by smb_vop_readdir_readpage() 973da6c28aaSamw * to smb_vop_readdir(). 974da6c28aaSamw * 975da6c28aaSamw * Both dirent64_t and edirent_t structures need to be handled. The former is 976da6c28aaSamw * needed for file systems that do not support VFSFT_DIRENTFLAGS. The latter 977da6c28aaSamw * is required for proper handling of case collisions on file systems that 978da6c28aaSamw * support case-insensitivity. edirent_t structures are also used for 979da6c28aaSamw * case-sensitive file systems if VFSFT_DIRENTFLAGS is supported. 980da6c28aaSamw */ 981da6c28aaSamw 982da6c28aaSamw static int 983faa1795aSjb150015 smb_vop_readdir_entry( 984faa1795aSjb150015 vnode_t *dvp, 985faa1795aSjb150015 uint32_t *cookiep, 986faa1795aSjb150015 char *name, 987faa1795aSjb150015 int *namelen, 988faa1795aSjb150015 ino64_t *inop, 989faa1795aSjb150015 vnode_t **vpp, 990faa1795aSjb150015 char *od_name, 991faa1795aSjb150015 int flags, 992faa1795aSjb150015 cred_t *cr, 993faa1795aSjb150015 char *dirbuf, 994faa1795aSjb150015 int num_bytes) 995da6c28aaSamw { 996da6c28aaSamw uint32_t next_cookie; 997da6c28aaSamw int ebufsize; 998da6c28aaSamw int error = 0; 999da6c28aaSamw int len; 1000da6c28aaSamw int rc; 1001da6c28aaSamw char shortname[MANGLE_NAMELEN]; 1002da6c28aaSamw char name83[MANGLE_NAMELEN]; 1003da6c28aaSamw char *ebuf = NULL; 1004da6c28aaSamw edirent_t *edp; 1005da6c28aaSamw dirent64_t *dp = NULL; 1006da6c28aaSamw vnode_t *vp = NULL; 1007da6c28aaSamw 1008da6c28aaSamw ASSERT(dirbuf); 1009da6c28aaSamw 1010da6c28aaSamw /* 1011da6c28aaSamw * Use edirent_t structure for both 1012da6c28aaSamw * entflags not working for streams so don't try to use them 1013da6c28aaSamw */ 1014da6c28aaSamw if (!(flags & SMB_STREAM_RDDIR) && 1015da6c28aaSamw (vfs_has_feature(dvp->v_vfsp, VFSFT_DIRENTFLAGS))) { 1016da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1017da6c28aaSamw edp = (edirent_t *)dirbuf; 1018da6c28aaSamw } else { 1019da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1020da6c28aaSamw dp = (dirent64_t *)dirbuf; 1021da6c28aaSamw ebufsize = EDIRENT_RECLEN(MAXNAMELEN); 1022da6c28aaSamw ebuf = kmem_zalloc(ebufsize, KM_SLEEP); 1023da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1024da6c28aaSamw edp = (edirent_t *)ebuf; 1025da6c28aaSamw } 1026da6c28aaSamw 1027da6c28aaSamw while (edp) { 1028da6c28aaSamw if (dp) 1029da6c28aaSamw DP_TO_EDP(dp, edp); 1030da6c28aaSamw 1031da6c28aaSamw next_cookie = (uint32_t)edp->ed_off; 1032da6c28aaSamw if (edp->ed_ino == 0) { 1033da6c28aaSamw *cookiep = next_cookie; 1034da6c28aaSamw 1035da6c28aaSamw if (dp) { 1036da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1037da6c28aaSamw DP_ADVANCE(dp, dirbuf, num_bytes); 1038da6c28aaSamw if (dp == NULL) 1039da6c28aaSamw edp = NULL; 1040da6c28aaSamw } else { 1041da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1042da6c28aaSamw EDP_ADVANCE(edp, dirbuf, num_bytes); 1043da6c28aaSamw } 1044da6c28aaSamw continue; 1045da6c28aaSamw } 1046da6c28aaSamw 1047da6c28aaSamw len = strlen(edp->ed_name); 1048da6c28aaSamw 1049da6c28aaSamw if (*namelen < len) { 1050da6c28aaSamw *namelen = 0; 1051da6c28aaSamw 1052da6c28aaSamw if (ebuf) 1053da6c28aaSamw kmem_free(ebuf, ebufsize); 1054da6c28aaSamw 1055da6c28aaSamw return (EOVERFLOW); 1056da6c28aaSamw } 1057da6c28aaSamw 1058da6c28aaSamw /* 1059da6c28aaSamw * Do not pass SMB_IGNORE_CASE to smb_vop_lookup 1060da6c28aaSamw */ 1061da6c28aaSamw 1062da6c28aaSamw error = smb_vop_lookup(dvp, edp->ed_name, vpp ? vpp : &vp, 1063dc20a302Sas200622 od_name, 0, NULL, cr); 1064da6c28aaSamw 1065da6c28aaSamw if (error) { 1066da6c28aaSamw if (error == ENOENT) { 1067da6c28aaSamw *cookiep = (uint32_t)next_cookie; 1068da6c28aaSamw 1069da6c28aaSamw if (dp) { 1070da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1071da6c28aaSamw DP_ADVANCE(dp, dirbuf, num_bytes); 1072da6c28aaSamw if (dp == NULL) 1073da6c28aaSamw edp = NULL; 1074da6c28aaSamw } else { 1075da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1076da6c28aaSamw EDP_ADVANCE(edp, dirbuf, num_bytes); 1077da6c28aaSamw } 1078da6c28aaSamw continue; 1079da6c28aaSamw } 1080da6c28aaSamw 1081da6c28aaSamw 1082da6c28aaSamw *namelen = 0; 1083da6c28aaSamw 1084da6c28aaSamw if (ebuf) 1085da6c28aaSamw kmem_free(ebuf, ebufsize); 1086da6c28aaSamw 1087da6c28aaSamw return (error); 1088da6c28aaSamw } 1089da6c28aaSamw 1090da6c28aaSamw if ((flags & SMB_IGNORE_CASE) && ED_CASE_CONFLICTS(edp)) { 1091da6c28aaSamw rc = smb_mangle_name(edp->ed_ino, edp->ed_name, 1092da6c28aaSamw shortname, name83, 1); 1093da6c28aaSamw 1094da6c28aaSamw if (rc == 1) { /* success */ 1095da6c28aaSamw (void) strlcpy(name, shortname, *namelen + 1); 1096da6c28aaSamw *namelen = strlen(shortname); 1097da6c28aaSamw } else { 1098da6c28aaSamw (void) strlcpy(name, edp->ed_name, 1099da6c28aaSamw *namelen + 1); 1100da6c28aaSamw name[*namelen] = '\0'; 1101da6c28aaSamw } 1102da6c28aaSamw 1103da6c28aaSamw } else { 1104da6c28aaSamw (void) strlcpy(name, edp->ed_name, *namelen + 1); 1105da6c28aaSamw *namelen = len; 1106da6c28aaSamw } 1107da6c28aaSamw 1108da6c28aaSamw if (vpp == NULL) 1109da6c28aaSamw VN_RELE(vp); 1110da6c28aaSamw 1111da6c28aaSamw if (inop) 1112da6c28aaSamw *inop = edp->ed_ino; 1113da6c28aaSamw 1114da6c28aaSamw *cookiep = (uint32_t)next_cookie; 1115da6c28aaSamw break; 1116da6c28aaSamw } 1117da6c28aaSamw 1118da6c28aaSamw if (ebuf) 1119da6c28aaSamw kmem_free(ebuf, ebufsize); 1120da6c28aaSamw 1121da6c28aaSamw return (error); 1122da6c28aaSamw } 1123da6c28aaSamw 1124da6c28aaSamw /* 1125da6c28aaSamw * smb_sa_to_va_mask 1126da6c28aaSamw * 1127da6c28aaSamw * Set va_mask by running through the SMB_AT_* #define's and 1128da6c28aaSamw * setting those bits that correspond to the SMB_AT_* bits 1129da6c28aaSamw * set in sa_mask. 1130da6c28aaSamw */ 1131da6c28aaSamw 1132da6c28aaSamw void 1133da6c28aaSamw smb_sa_to_va_mask(uint_t sa_mask, uint_t *va_maskp) 1134da6c28aaSamw { 1135da6c28aaSamw int i; 1136da6c28aaSamw uint_t smask; 1137da6c28aaSamw 1138da6c28aaSamw smask = (sa_mask); 1139da6c28aaSamw for (i = SMB_AT_TYPE; (i < SMB_AT_MAX) && (smask != 0); ++i) { 1140da6c28aaSamw if (smask & 1) 1141da6c28aaSamw *(va_maskp) |= smb_attrmap[i]; 1142da6c28aaSamw 1143da6c28aaSamw smask >>= 1; 1144da6c28aaSamw } 1145da6c28aaSamw } 1146da6c28aaSamw 1147da6c28aaSamw /* 1148da6c28aaSamw * smb_vop_getdents() 1149da6c28aaSamw * 1150da6c28aaSamw * Upon success, the smb_node corresponding to each entry returned will 1151da6c28aaSamw * have a reference taken on it. These will be released in 1152da6c28aaSamw * smb_trans2_find_get_dents(). 1153da6c28aaSamw * 1154da6c28aaSamw * If an error is returned from this routine, a list of already processed 1155da6c28aaSamw * entries will be returned. The smb_nodes corresponding to these entries 1156da6c28aaSamw * will be referenced, and will be released in smb_trans2_find_get_dents(). 1157da6c28aaSamw * 1158da6c28aaSamw * The returned dp->d_name field will contain either the on-disk name or, if 1159da6c28aaSamw * it needs mangling or has a case-insensitive collision, the mangled 1160da6c28aaSamw * "shortname." In this case, the on-disk name can be retrieved from the 1161da6c28aaSamw * smb_node's od_name (the smb_node is passed to smb_gather_dents_info()). 1162da6c28aaSamw */ 1163da6c28aaSamw 1164da6c28aaSamw int /*ARGSUSED*/ 1165da6c28aaSamw smb_vop_getdents( 1166da6c28aaSamw smb_node_t *dir_snode, 1167da6c28aaSamw uint32_t *cookiep, 1168da6c28aaSamw uint64_t *verifierp, 1169da6c28aaSamw int32_t *dircountp, 1170da6c28aaSamw char *arg, 1171da6c28aaSamw char *pattern, 1172da6c28aaSamw uint32_t flags, 1173da6c28aaSamw smb_request_t *sr, 1174dc20a302Sas200622 cred_t *cr) 1175da6c28aaSamw { 1176da6c28aaSamw int error = 0; 1177da6c28aaSamw int maxentries; 1178da6c28aaSamw int num_bytes; 1179da6c28aaSamw int resid; 1180da6c28aaSamw char *dirbuf = NULL; 1181da6c28aaSamw vnode_t *dvp; 1182da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1183da6c28aaSamw smb_dent_info_hdr_t *ihdr = (smb_dent_info_hdr_t *)arg; 1184da6c28aaSamw 1185da6c28aaSamw dvp = dir_snode->vp; 1186da6c28aaSamw 1187da6c28aaSamw resid = ihdr->uio.uio_resid; 1188da6c28aaSamw maxentries = resid / SMB_MAX_DENT_INFO_SIZE; 1189da6c28aaSamw 1190da6c28aaSamw bzero(ihdr->iov->iov_base, resid); 1191da6c28aaSamw 1192da6c28aaSamw dirbuf = kmem_alloc(SMB_MINLEN_RDDIR_BUF, KM_SLEEP); 1193da6c28aaSamw 1194da6c28aaSamw while (maxentries) { 1195da6c28aaSamw 1196da6c28aaSamw bzero(dirbuf, SMB_MINLEN_RDDIR_BUF); 1197da6c28aaSamw 1198da6c28aaSamw num_bytes = SMB_MINLEN_RDDIR_BUF; 1199da6c28aaSamw error = smb_vop_readdir_readpage(dvp, dirbuf, *cookiep, 1200dc20a302Sas200622 &num_bytes, cr, flags); 1201da6c28aaSamw 1202da6c28aaSamw if (error || (num_bytes <= 0)) 1203da6c28aaSamw break; 1204da6c28aaSamw 1205da6c28aaSamw error = smb_vop_getdents_entries(dir_snode, cookiep, dircountp, 1206dc20a302Sas200622 arg, flags, sr, cr, dirbuf, &maxentries, num_bytes, 1207da6c28aaSamw pattern); 1208da6c28aaSamw 1209da6c28aaSamw if (error) 1210da6c28aaSamw goto out; 1211da6c28aaSamw } 1212da6c28aaSamw 1213da6c28aaSamw if (num_bytes < 0) { 1214da6c28aaSamw error = -1; 1215da6c28aaSamw } else if (num_bytes == 0) { 1216da6c28aaSamw *cookiep = SMB_EOF; 1217da6c28aaSamw error = 0; 1218da6c28aaSamw } else { 1219da6c28aaSamw error = 0; 1220da6c28aaSamw } 1221da6c28aaSamw 1222da6c28aaSamw out: 1223da6c28aaSamw if (dirbuf) 1224da6c28aaSamw kmem_free(dirbuf, SMB_MINLEN_RDDIR_BUF); 1225da6c28aaSamw 1226da6c28aaSamw return (error); 1227da6c28aaSamw } 1228da6c28aaSamw 1229da6c28aaSamw /* 1230da6c28aaSamw * smb_vop_getdents_entries() 1231da6c28aaSamw * 1232da6c28aaSamw * This function retrieves names from the SMB_MINLEN_RDDIR_BUF-sized buffer 1233da6c28aaSamw * returned by smb_vop_readdir_readpage() to smb_vop_getdents(). 1234da6c28aaSamw * 1235da6c28aaSamw * Both dirent64_t and edirent_t structures need to be handled. The former is 1236da6c28aaSamw * needed for file systems that do not support VFSFT_DIRENTFLAGS. The latter 1237da6c28aaSamw * is required for properly handling case collisions on file systems that 1238da6c28aaSamw * support case-insensitivity. edirent_t is also used on case-sensitive 1239da6c28aaSamw * file systems where VFSFT_DIRENTFLAGS is available. 1240da6c28aaSamw */ 1241da6c28aaSamw 1242da6c28aaSamw static int 1243da6c28aaSamw smb_vop_getdents_entries( 1244da6c28aaSamw smb_node_t *dir_snode, 1245da6c28aaSamw uint32_t *cookiep, 1246da6c28aaSamw int32_t *dircountp, 1247da6c28aaSamw char *arg, 1248da6c28aaSamw uint32_t flags, 1249faa1795aSjb150015 smb_request_t *sr, 1250da6c28aaSamw cred_t *cr, 1251da6c28aaSamw char *dirbuf, 1252da6c28aaSamw int *maxentries, 1253da6c28aaSamw int num_bytes, 1254da6c28aaSamw char *pattern) 1255da6c28aaSamw { 1256da6c28aaSamw uint32_t next_cookie; 1257da6c28aaSamw int ebufsize; 1258da6c28aaSamw char *tmp_name; 1259da6c28aaSamw int error; 1260da6c28aaSamw int rc; 1261da6c28aaSamw char shortname[MANGLE_NAMELEN]; 1262da6c28aaSamw char name83[MANGLE_NAMELEN]; 1263da6c28aaSamw char *ebuf = NULL; 1264da6c28aaSamw dirent64_t *dp = NULL; 1265da6c28aaSamw edirent_t *edp; 1266da6c28aaSamw smb_node_t *ret_snode; 1267da6c28aaSamw smb_attr_t ret_attr; 1268da6c28aaSamw vnode_t *dvp; 1269da6c28aaSamw vnode_t *fvp; 1270da6c28aaSamw 1271da6c28aaSamw ASSERT(dirbuf); 1272da6c28aaSamw 1273da6c28aaSamw dvp = dir_snode->vp; 1274da6c28aaSamw 1275da6c28aaSamw if (vfs_has_feature(dvp->v_vfsp, VFSFT_DIRENTFLAGS)) { 1276da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1277da6c28aaSamw edp = (edirent_t *)dirbuf; 1278da6c28aaSamw } else { 1279da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1280da6c28aaSamw dp = (dirent64_t *)dirbuf; 1281da6c28aaSamw ebufsize = EDIRENT_RECLEN(MAXNAMELEN); 1282da6c28aaSamw ebuf = kmem_zalloc(ebufsize, KM_SLEEP); 1283da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1284da6c28aaSamw edp = (edirent_t *)ebuf; 1285da6c28aaSamw } 1286da6c28aaSamw 1287da6c28aaSamw while (edp) { 1288da6c28aaSamw if (dp) 1289da6c28aaSamw DP_TO_EDP(dp, edp); 1290da6c28aaSamw 1291da6c28aaSamw if (*maxentries == 0) 1292da6c28aaSamw break; 1293da6c28aaSamw 1294da6c28aaSamw next_cookie = (uint32_t)edp->ed_off; 1295da6c28aaSamw 1296da6c28aaSamw if (edp->ed_ino == 0) { 1297da6c28aaSamw *cookiep = next_cookie; 1298da6c28aaSamw if (dp) { 1299da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1300da6c28aaSamw DP_ADVANCE(dp, dirbuf, num_bytes); 1301da6c28aaSamw if (dp == NULL) 1302da6c28aaSamw edp = NULL; 1303da6c28aaSamw } else { 1304da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1305da6c28aaSamw EDP_ADVANCE(edp, dirbuf, num_bytes); 1306da6c28aaSamw } 1307da6c28aaSamw continue; 1308da6c28aaSamw } 1309da6c28aaSamw 1310da6c28aaSamw error = smb_vop_lookup(dvp, edp->ed_name, &fvp, 1311dc20a302Sas200622 NULL, 0, NULL, cr); 1312da6c28aaSamw 1313da6c28aaSamw if (error) { 1314da6c28aaSamw if (error == ENOENT) { 1315da6c28aaSamw *cookiep = next_cookie; 1316da6c28aaSamw if (dp) { 1317da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1318da6c28aaSamw DP_ADVANCE(dp, dirbuf, 1319da6c28aaSamw num_bytes); 1320da6c28aaSamw if (dp == NULL) 1321da6c28aaSamw edp = NULL; 1322da6c28aaSamw } else { 1323da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1324da6c28aaSamw EDP_ADVANCE(edp, dirbuf, 1325da6c28aaSamw num_bytes); 1326da6c28aaSamw } 1327da6c28aaSamw continue; 1328da6c28aaSamw } 1329da6c28aaSamw if (ebuf) 1330da6c28aaSamw kmem_free(ebuf, ebufsize); 1331da6c28aaSamw 1332da6c28aaSamw return (error); 1333da6c28aaSamw } 1334da6c28aaSamw 1335da6c28aaSamw ret_snode = smb_node_lookup(sr, NULL, cr, fvp, 1336da6c28aaSamw edp->ed_name, dir_snode, NULL, &ret_attr); 1337da6c28aaSamw 1338da6c28aaSamw if (ret_snode == NULL) { 1339da6c28aaSamw VN_RELE(fvp); 1340da6c28aaSamw 1341da6c28aaSamw if (ebuf) 1342da6c28aaSamw kmem_free(ebuf, ebufsize); 1343da6c28aaSamw 1344da6c28aaSamw return (ENOMEM); 1345da6c28aaSamw } 1346da6c28aaSamw 1347da6c28aaSamw if (smb_match_name(edp->ed_ino, edp->ed_name, shortname, 1348da6c28aaSamw name83, pattern, (flags & SMB_IGNORE_CASE))) { 1349da6c28aaSamw 1350da6c28aaSamw tmp_name = edp->ed_name; 1351da6c28aaSamw 1352da6c28aaSamw if ((flags & SMB_IGNORE_CASE) && 1353da6c28aaSamw ED_CASE_CONFLICTS(edp)) { 1354da6c28aaSamw rc = smb_mangle_name(edp->ed_ino, edp->ed_name, 1355da6c28aaSamw shortname, name83, 1); 1356da6c28aaSamw if (rc == 1) 1357da6c28aaSamw tmp_name = shortname; 1358da6c28aaSamw } else { 1359da6c28aaSamw rc = smb_mangle_name(edp->ed_ino, edp->ed_name, 1360da6c28aaSamw shortname, name83, 0); 1361da6c28aaSamw } 1362da6c28aaSamw 1363da6c28aaSamw if (rc != 1) { 1364da6c28aaSamw (void) strlcpy(shortname, edp->ed_name, 1365da6c28aaSamw MANGLE_NAMELEN); 1366da6c28aaSamw (void) strlcpy(name83, edp->ed_name, 1367da6c28aaSamw MANGLE_NAMELEN); 1368da6c28aaSamw shortname[MANGLE_NAMELEN - 1] = '\0'; 1369da6c28aaSamw name83[MANGLE_NAMELEN - 1] = '\0'; 1370da6c28aaSamw } 1371da6c28aaSamw 1372da6c28aaSamw error = smb_gather_dents_info(arg, edp->ed_ino, 1373da6c28aaSamw strlen(tmp_name), tmp_name, next_cookie, dircountp, 1374da6c28aaSamw &ret_attr, ret_snode, shortname, name83); 1375da6c28aaSamw 1376da6c28aaSamw if (error > 0) { 1377da6c28aaSamw if (ebuf) 1378da6c28aaSamw kmem_free(ebuf, ebufsize); 1379da6c28aaSamw return (error); 1380da6c28aaSamw } 1381da6c28aaSamw 1382da6c28aaSamw /* 1383da6c28aaSamw * Treat errors from smb_gather_dents_info() that are 1384da6c28aaSamw * < 0 the same as EOF. 1385da6c28aaSamw */ 1386da6c28aaSamw if (error < 0) { 1387da6c28aaSamw if (ebuf) 1388da6c28aaSamw kmem_free(ebuf, ebufsize); 1389da6c28aaSamw *maxentries = 0; 1390da6c28aaSamw return (0); 1391da6c28aaSamw } 1392da6c28aaSamw (*maxentries)--; 1393da6c28aaSamw } else { 1394da6c28aaSamw smb_node_release(ret_snode); 1395da6c28aaSamw } 1396da6c28aaSamw 1397da6c28aaSamw *cookiep = next_cookie; 1398da6c28aaSamw 1399da6c28aaSamw if (dp) { 1400da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1401da6c28aaSamw DP_ADVANCE(dp, dirbuf, num_bytes); 1402da6c28aaSamw if (dp == NULL) 1403da6c28aaSamw edp = NULL; 1404da6c28aaSamw } else { 1405da6c28aaSamw /*LINTED E_BAD_PTR_CAST_ALIGN*/ 1406da6c28aaSamw EDP_ADVANCE(edp, dirbuf, num_bytes); 1407da6c28aaSamw } 1408da6c28aaSamw } 1409da6c28aaSamw 1410da6c28aaSamw if (ebuf) 1411da6c28aaSamw kmem_free(ebuf, ebufsize); 1412da6c28aaSamw 1413da6c28aaSamw return (0); 1414da6c28aaSamw } 1415da6c28aaSamw 1416da6c28aaSamw /* 1417da6c28aaSamw * smb_vop_stream_lookup() 1418da6c28aaSamw * 1419da6c28aaSamw * The name returned in od_name is the on-disk name of the stream with the 1420da6c28aaSamw * SMB_STREAM_PREFIX stripped off. od_name should be allocated to MAXNAMELEN 1421da6c28aaSamw * by the caller. 1422da6c28aaSamw */ 1423da6c28aaSamw 1424da6c28aaSamw int 1425faa1795aSjb150015 smb_vop_stream_lookup( 1426faa1795aSjb150015 vnode_t *fvp, 1427faa1795aSjb150015 char *stream_name, 1428faa1795aSjb150015 vnode_t **vpp, 1429faa1795aSjb150015 char *od_name, 1430faa1795aSjb150015 vnode_t **xattrdirvpp, 1431faa1795aSjb150015 int flags, 1432faa1795aSjb150015 vnode_t *rootvp, 1433dc20a302Sas200622 cred_t *cr) 1434da6c28aaSamw { 1435da6c28aaSamw char *solaris_stream_name; 1436da6c28aaSamw char *name; 1437da6c28aaSamw int error; 1438da6c28aaSamw 1439da6c28aaSamw if ((error = smb_vop_lookup_xattrdir(fvp, xattrdirvpp, 1440dc20a302Sas200622 LOOKUP_XATTR | CREATE_XATTR_DIR, cr)) != 0) 1441da6c28aaSamw return (error); 1442da6c28aaSamw 1443da6c28aaSamw /* 1444da6c28aaSamw * Prepend SMB_STREAM_PREFIX to stream name 1445da6c28aaSamw */ 1446da6c28aaSamw 1447da6c28aaSamw solaris_stream_name = kmem_alloc(MAXNAMELEN, KM_SLEEP); 1448da6c28aaSamw (void) sprintf(solaris_stream_name, "%s%s", SMB_STREAM_PREFIX, 1449da6c28aaSamw stream_name); 1450da6c28aaSamw 1451da6c28aaSamw /* 1452da6c28aaSamw * "name" will hold the on-disk name returned from smb_vop_lookup 1453da6c28aaSamw * for the stream, including the SMB_STREAM_PREFIX. 1454da6c28aaSamw */ 1455da6c28aaSamw 1456da6c28aaSamw name = kmem_zalloc(MAXNAMELEN, KM_SLEEP); 1457da6c28aaSamw 1458da6c28aaSamw if ((error = smb_vop_lookup(*xattrdirvpp, solaris_stream_name, vpp, 1459dc20a302Sas200622 name, flags, rootvp, cr)) != 0) { 1460da6c28aaSamw VN_RELE(*xattrdirvpp); 1461da6c28aaSamw } else { 1462da6c28aaSamw (void) strlcpy(od_name, &(name[SMB_STREAM_PREFIX_LEN]), 1463da6c28aaSamw MAXNAMELEN); 1464da6c28aaSamw } 1465da6c28aaSamw 1466da6c28aaSamw kmem_free(solaris_stream_name, MAXNAMELEN); 1467da6c28aaSamw kmem_free(name, MAXNAMELEN); 1468da6c28aaSamw 1469da6c28aaSamw return (error); 1470da6c28aaSamw } 1471da6c28aaSamw 1472da6c28aaSamw int 1473da6c28aaSamw smb_vop_stream_create(vnode_t *fvp, char *stream_name, smb_attr_t *attr, 1474dc20a302Sas200622 vnode_t **vpp, vnode_t **xattrdirvpp, int flags, cred_t *cr) 1475da6c28aaSamw { 1476da6c28aaSamw char *solaris_stream_name; 1477da6c28aaSamw int error; 1478da6c28aaSamw 1479da6c28aaSamw if ((error = smb_vop_lookup_xattrdir(fvp, xattrdirvpp, 1480dc20a302Sas200622 LOOKUP_XATTR | CREATE_XATTR_DIR, cr)) != 0) 1481da6c28aaSamw return (error); 1482da6c28aaSamw 1483da6c28aaSamw /* 1484da6c28aaSamw * Prepend SMB_STREAM_PREFIX to stream name 1485da6c28aaSamw */ 1486da6c28aaSamw 1487da6c28aaSamw solaris_stream_name = kmem_alloc(MAXNAMELEN, KM_SLEEP); 1488da6c28aaSamw (void) sprintf(solaris_stream_name, "%s%s", SMB_STREAM_PREFIX, 1489da6c28aaSamw stream_name); 1490da6c28aaSamw 1491da6c28aaSamw if ((error = smb_vop_create(*xattrdirvpp, solaris_stream_name, attr, 1492dc20a302Sas200622 vpp, flags, cr, NULL)) != 0) 1493da6c28aaSamw VN_RELE(*xattrdirvpp); 1494da6c28aaSamw 1495da6c28aaSamw kmem_free(solaris_stream_name, MAXNAMELEN); 1496da6c28aaSamw 1497da6c28aaSamw return (error); 1498da6c28aaSamw } 1499da6c28aaSamw 1500da6c28aaSamw int 1501dc20a302Sas200622 smb_vop_stream_remove(vnode_t *vp, char *stream_name, int flags, cred_t *cr) 1502da6c28aaSamw { 1503da6c28aaSamw char *solaris_stream_name; 1504da6c28aaSamw vnode_t *xattrdirvp; 1505da6c28aaSamw int error; 1506da6c28aaSamw 1507faa1795aSjb150015 error = smb_vop_lookup_xattrdir(vp, &xattrdirvp, LOOKUP_XATTR, cr); 1508faa1795aSjb150015 if (error != 0) 1509da6c28aaSamw return (error); 1510da6c28aaSamw 1511da6c28aaSamw /* 1512da6c28aaSamw * Prepend SMB_STREAM_PREFIX to stream name 1513da6c28aaSamw */ 1514da6c28aaSamw 1515da6c28aaSamw solaris_stream_name = kmem_alloc(MAXNAMELEN, KM_SLEEP); 1516da6c28aaSamw (void) sprintf(solaris_stream_name, "%s%s", SMB_STREAM_PREFIX, 1517da6c28aaSamw stream_name); 1518da6c28aaSamw 1519da6c28aaSamw /* XXX might have to use kcred */ 1520dc20a302Sas200622 error = smb_vop_remove(xattrdirvp, solaris_stream_name, flags, cr); 1521da6c28aaSamw 1522da6c28aaSamw kmem_free(solaris_stream_name, MAXNAMELEN); 1523da6c28aaSamw 1524da6c28aaSamw return (error); 1525da6c28aaSamw } 1526da6c28aaSamw 1527da6c28aaSamw /* 1528da6c28aaSamw * smb_vop_stream_readdir() 1529da6c28aaSamw * 1530da6c28aaSamw * Note: stream_info.size is not filled in in this routine. 1531da6c28aaSamw * It needs to be filled in by the caller due to the parameters for getattr. 1532da6c28aaSamw * 1533da6c28aaSamw * stream_info.name is set to the on-disk stream name with the SMB_STREAM_PREFIX 1534da6c28aaSamw * removed. 1535da6c28aaSamw */ 1536da6c28aaSamw 1537da6c28aaSamw int 1538da6c28aaSamw smb_vop_stream_readdir(vnode_t *fvp, uint32_t *cookiep, 1539da6c28aaSamw struct fs_stream_info *stream_info, vnode_t **vpp, vnode_t **xattrdirvpp, 1540dc20a302Sas200622 int flags, cred_t *cr) 1541da6c28aaSamw { 1542da6c28aaSamw int nsize = MAXNAMELEN-1; 1543da6c28aaSamw int error = 0; 1544da6c28aaSamw ino64_t ino; 1545da6c28aaSamw char *tmp_name; 1546da6c28aaSamw vnode_t *xattrdirvp; 1547da6c28aaSamw vnode_t *vp; 1548da6c28aaSamw 1549da6c28aaSamw if ((error = smb_vop_lookup_xattrdir(fvp, &xattrdirvp, LOOKUP_XATTR, 1550dc20a302Sas200622 cr)) != 0) 1551da6c28aaSamw return (error); 1552da6c28aaSamw 1553da6c28aaSamw bzero(stream_info->name, sizeof (stream_info->name)); 1554da6c28aaSamw stream_info->size = 0; 1555da6c28aaSamw 1556da6c28aaSamw tmp_name = kmem_zalloc(MAXNAMELEN, KM_SLEEP); 1557da6c28aaSamw 1558da6c28aaSamw for (;;) { 1559da6c28aaSamw error = smb_vop_readdir(xattrdirvp, cookiep, tmp_name, &nsize, 1560dc20a302Sas200622 &ino, &vp, NULL, flags | SMB_STREAM_RDDIR, cr); 1561da6c28aaSamw 1562da6c28aaSamw if (error || (*cookiep == SMB_EOF)) 1563da6c28aaSamw break; 1564da6c28aaSamw 1565da6c28aaSamw if (strncmp(tmp_name, SMB_STREAM_PREFIX, 1566da6c28aaSamw SMB_STREAM_PREFIX_LEN)) { 1567da6c28aaSamw VN_RELE(vp); 1568da6c28aaSamw continue; 1569da6c28aaSamw } 1570da6c28aaSamw 1571da6c28aaSamw tmp_name[nsize] = '\0'; 1572da6c28aaSamw (void) strlcpy(stream_info->name, 1573da6c28aaSamw &(tmp_name[SMB_STREAM_PREFIX_LEN]), 1574da6c28aaSamw sizeof (stream_info->name)); 1575da6c28aaSamw 1576da6c28aaSamw nsize -= SMB_STREAM_PREFIX_LEN; 1577da6c28aaSamw break; 1578da6c28aaSamw } 1579da6c28aaSamw 1580da6c28aaSamw if ((error == 0) && nsize) { 1581da6c28aaSamw if (vpp) 1582da6c28aaSamw *vpp = vp; 1583da6c28aaSamw else 1584da6c28aaSamw VN_RELE(vp); 1585da6c28aaSamw 1586da6c28aaSamw if (xattrdirvpp) 1587da6c28aaSamw *xattrdirvpp = xattrdirvp; 1588da6c28aaSamw else 1589da6c28aaSamw VN_RELE(xattrdirvp); 1590da6c28aaSamw 159162ab33e7Sjc198820 } else { 159262ab33e7Sjc198820 VN_RELE(xattrdirvp); 1593da6c28aaSamw } 1594da6c28aaSamw 1595da6c28aaSamw kmem_free(tmp_name, MAXNAMELEN); 1596da6c28aaSamw 1597da6c28aaSamw return (error); 1598da6c28aaSamw } 1599da6c28aaSamw 1600da6c28aaSamw int 1601da6c28aaSamw smb_vop_lookup_xattrdir(vnode_t *fvp, vnode_t **xattrdirvpp, int flags, 1602dc20a302Sas200622 cred_t *cr) 1603da6c28aaSamw { 1604da6c28aaSamw int error; 1605da6c28aaSamw 1606dc20a302Sas200622 error = VOP_LOOKUP(fvp, "", xattrdirvpp, NULL, flags, NULL, cr, 1607dc20a302Sas200622 &smb_ct, NULL, NULL); 1608da6c28aaSamw return (error); 1609da6c28aaSamw } 1610da6c28aaSamw 1611da6c28aaSamw /* 1612da6c28aaSamw * smb_vop_traverse_check() 1613da6c28aaSamw * 1614da6c28aaSamw * This function checks to see if the passed-in vnode has a file system 1615da6c28aaSamw * mounted on it. If it does, the mount point is "traversed" and the 1616da6c28aaSamw * vnode for the root of the file system is returned. 1617da6c28aaSamw */ 1618da6c28aaSamw 1619da6c28aaSamw int 1620da6c28aaSamw smb_vop_traverse_check(vnode_t **vpp) 1621da6c28aaSamw { 1622da6c28aaSamw int error; 1623da6c28aaSamw 1624da6c28aaSamw if (vn_mountedvfs(*vpp) == 0) 1625da6c28aaSamw return (0); 1626da6c28aaSamw 1627da6c28aaSamw /* 1628da6c28aaSamw * traverse() may return a different held vnode, even in the error case. 1629da6c28aaSamw * If it returns a different vnode, it will have released the original. 1630da6c28aaSamw */ 1631da6c28aaSamw 1632da6c28aaSamw error = traverse(vpp); 1633da6c28aaSamw 1634da6c28aaSamw return (error); 1635da6c28aaSamw } 1636da6c28aaSamw 1637da6c28aaSamw int /*ARGSUSED*/ 1638da6c28aaSamw smb_vop_statfs(vnode_t *vp, struct statvfs64 *statp, cred_t *cr) 1639da6c28aaSamw { 1640da6c28aaSamw int error; 1641da6c28aaSamw 1642da6c28aaSamw error = VFS_STATVFS(vp->v_vfsp, statp); 1643da6c28aaSamw 1644da6c28aaSamw return (error); 1645da6c28aaSamw } 1646da6c28aaSamw 1647da6c28aaSamw /* 1648da6c28aaSamw * smb_vop_acl_read 1649da6c28aaSamw * 1650da6c28aaSamw * Reads the ACL of the specified file into 'aclp'. 1651da6c28aaSamw * acl_type is the type of ACL which the filesystem supports. 1652da6c28aaSamw * 1653da6c28aaSamw * Caller has to free the allocated memory for aclp by calling 1654da6c28aaSamw * acl_free(). 1655da6c28aaSamw */ 1656da6c28aaSamw int 1657da6c28aaSamw smb_vop_acl_read(vnode_t *vp, acl_t **aclp, int flags, acl_type_t acl_type, 1658dc20a302Sas200622 cred_t *cr) 1659da6c28aaSamw { 1660da6c28aaSamw int error; 1661da6c28aaSamw vsecattr_t vsecattr; 1662da6c28aaSamw 1663da6c28aaSamw ASSERT(vp); 1664da6c28aaSamw ASSERT(aclp); 1665da6c28aaSamw 1666da6c28aaSamw *aclp = NULL; 1667da6c28aaSamw bzero(&vsecattr, sizeof (vsecattr_t)); 1668da6c28aaSamw 1669da6c28aaSamw switch (acl_type) { 1670da6c28aaSamw case ACLENT_T: 1671da6c28aaSamw vsecattr.vsa_mask = VSA_ACL | VSA_ACLCNT | VSA_DFACL | 1672da6c28aaSamw VSA_DFACLCNT; 1673da6c28aaSamw break; 1674da6c28aaSamw 1675da6c28aaSamw case ACE_T: 1676da6c28aaSamw vsecattr.vsa_mask = VSA_ACE | VSA_ACECNT | VSA_ACE_ACLFLAGS; 1677da6c28aaSamw break; 1678da6c28aaSamw 1679da6c28aaSamw default: 1680da6c28aaSamw return (EINVAL); 1681da6c28aaSamw } 1682da6c28aaSamw 1683dc20a302Sas200622 if (error = VOP_GETSECATTR(vp, &vsecattr, flags, cr, &smb_ct)) 1684da6c28aaSamw return (error); 1685da6c28aaSamw 168655bf511dSas200622 *aclp = smb_fsacl_from_vsa(&vsecattr, acl_type); 1687da6c28aaSamw if (vp->v_type == VDIR) 1688da6c28aaSamw (*aclp)->acl_flags |= ACL_IS_DIR; 1689da6c28aaSamw 1690da6c28aaSamw return (0); 1691da6c28aaSamw } 1692da6c28aaSamw 1693da6c28aaSamw /* 1694da6c28aaSamw * smb_vop_acl_write 1695da6c28aaSamw * 1696da6c28aaSamw * Writes the given ACL in aclp for the specified file. 1697da6c28aaSamw */ 1698da6c28aaSamw int 1699dc20a302Sas200622 smb_vop_acl_write(vnode_t *vp, acl_t *aclp, int flags, cred_t *cr) 1700da6c28aaSamw { 1701da6c28aaSamw int error; 1702da6c28aaSamw vsecattr_t vsecattr; 1703da6c28aaSamw int aclbsize; 1704da6c28aaSamw 1705da6c28aaSamw ASSERT(vp); 1706da6c28aaSamw ASSERT(aclp); 1707da6c28aaSamw 170855bf511dSas200622 error = smb_fsacl_to_vsa(aclp, &vsecattr, &aclbsize); 1709da6c28aaSamw 1710da6c28aaSamw if (error == 0) { 1711*8c10a865Sas200622 (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, &smb_ct); 1712dc20a302Sas200622 error = VOP_SETSECATTR(vp, &vsecattr, flags, cr, &smb_ct); 1713*8c10a865Sas200622 VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, &smb_ct); 1714da6c28aaSamw } 1715da6c28aaSamw 1716da6c28aaSamw if (aclbsize && vsecattr.vsa_aclentp) 1717da6c28aaSamw kmem_free(vsecattr.vsa_aclentp, aclbsize); 1718da6c28aaSamw 1719da6c28aaSamw return (error); 1720da6c28aaSamw } 1721da6c28aaSamw 1722da6c28aaSamw /* 1723da6c28aaSamw * smb_vop_acl_type 1724da6c28aaSamw * 1725da6c28aaSamw * Determines the ACL type for the given vnode. 1726da6c28aaSamw * ACLENT_T is a Posix ACL and ACE_T is a ZFS ACL. 1727da6c28aaSamw */ 1728da6c28aaSamw acl_type_t 1729da6c28aaSamw smb_vop_acl_type(vnode_t *vp) 1730da6c28aaSamw { 1731da6c28aaSamw int error; 1732da6c28aaSamw ulong_t whichacl; 1733da6c28aaSamw 1734da6c28aaSamw error = VOP_PATHCONF(vp, _PC_ACL_ENABLED, &whichacl, kcred, NULL); 1735da6c28aaSamw if (error != 0) { 1736da6c28aaSamw /* 1737da6c28aaSamw * If we got an error, then the filesystem 1738da6c28aaSamw * likely does not understand the _PC_ACL_ENABLED 1739da6c28aaSamw * pathconf. In this case, we fall back to trying 1740da6c28aaSamw * POSIX-draft (aka UFS-style) ACLs. 1741da6c28aaSamw */ 1742da6c28aaSamw whichacl = _ACL_ACLENT_ENABLED; 1743da6c28aaSamw } 1744da6c28aaSamw 1745da6c28aaSamw if (!(whichacl & (_ACL_ACE_ENABLED | _ACL_ACLENT_ENABLED))) { 1746da6c28aaSamw /* 1747da6c28aaSamw * If the file system supports neither ACE nor 1748da6c28aaSamw * ACLENT ACLs we will fall back to UFS-style ACLs 1749da6c28aaSamw * like we did above if there was an error upon 1750da6c28aaSamw * calling VOP_PATHCONF. 1751da6c28aaSamw * 1752da6c28aaSamw * ACE and ACLENT type ACLs are the only interfaces 1753da6c28aaSamw * supported thus far. If any other bits are set on 1754da6c28aaSamw * 'whichacl' upon return from VOP_PATHCONF, we will 1755da6c28aaSamw * ignore them. 1756da6c28aaSamw */ 1757da6c28aaSamw whichacl = _ACL_ACLENT_ENABLED; 1758da6c28aaSamw } 1759da6c28aaSamw 1760da6c28aaSamw if (whichacl == _ACL_ACLENT_ENABLED) 1761da6c28aaSamw return (ACLENT_T); 1762da6c28aaSamw 1763da6c28aaSamw return (ACE_T); 1764da6c28aaSamw } 1765da6c28aaSamw 1766da6c28aaSamw static int zfs_perms[] = { 1767da6c28aaSamw ACE_READ_DATA, ACE_WRITE_DATA, ACE_APPEND_DATA, ACE_READ_NAMED_ATTRS, 1768da6c28aaSamw ACE_WRITE_NAMED_ATTRS, ACE_EXECUTE, ACE_DELETE_CHILD, 1769da6c28aaSamw ACE_READ_ATTRIBUTES, ACE_WRITE_ATTRIBUTES, ACE_DELETE, ACE_READ_ACL, 1770da6c28aaSamw ACE_WRITE_ACL, ACE_WRITE_OWNER, ACE_SYNCHRONIZE 1771da6c28aaSamw }; 1772da6c28aaSamw 1773da6c28aaSamw static int unix_perms[] = { VREAD, VWRITE, VEXEC }; 1774da6c28aaSamw /* 1775da6c28aaSamw * smb_vop_eaccess 1776da6c28aaSamw * 1777da6c28aaSamw * Returns the effective permission of the given credential for the 1778da6c28aaSamw * specified object. 1779da6c28aaSamw * 1780da6c28aaSamw * This is just a workaround. We need VFS/FS support for this. 1781da6c28aaSamw */ 1782da6c28aaSamw void 1783da6c28aaSamw smb_vop_eaccess(vnode_t *vp, int *mode, int flags, vnode_t *dir_vp, cred_t *cr) 1784da6c28aaSamw { 1785da6c28aaSamw int error, i; 1786da6c28aaSamw int pnum; 1787da6c28aaSamw 1788da6c28aaSamw *mode = 0; 1789da6c28aaSamw 1790da6c28aaSamw if (flags == V_ACE_MASK) { 1791da6c28aaSamw pnum = sizeof (zfs_perms) / sizeof (int); 1792da6c28aaSamw 1793da6c28aaSamw for (i = 0; i < pnum; i++) { 1794da6c28aaSamw error = smb_vop_access(vp, zfs_perms[i], flags, 1795da6c28aaSamw dir_vp, cr); 1796da6c28aaSamw if (error == 0) 1797da6c28aaSamw *mode |= zfs_perms[i]; 1798da6c28aaSamw } 1799da6c28aaSamw } else { 1800da6c28aaSamw pnum = sizeof (unix_perms) / sizeof (int); 1801da6c28aaSamw 1802da6c28aaSamw for (i = 0; i < pnum; i++) { 1803da6c28aaSamw error = smb_vop_access(vp, unix_perms[i], flags, 1804da6c28aaSamw dir_vp, cr); 1805da6c28aaSamw if (error == 0) 1806da6c28aaSamw *mode |= unix_perms[i]; 1807da6c28aaSamw } 1808da6c28aaSamw } 1809da6c28aaSamw } 1810dc20a302Sas200622 1811dc20a302Sas200622 /* 1812dc20a302Sas200622 * smb_vop_shrlock() 1813dc20a302Sas200622 * 1814dc20a302Sas200622 * See comments for smb_fsop_shrlock() 1815dc20a302Sas200622 */ 1816dc20a302Sas200622 1817dc20a302Sas200622 int 1818dc20a302Sas200622 smb_vop_shrlock(vnode_t *vp, uint32_t uniq_fid, uint32_t desired_access, 1819dc20a302Sas200622 uint32_t share_access, cred_t *cr) 1820dc20a302Sas200622 { 1821dc20a302Sas200622 struct shrlock shr; 1822dc20a302Sas200622 struct shr_locowner shr_own; 1823dc20a302Sas200622 short new_access = 0; 1824dc20a302Sas200622 short deny = 0; 1825dc20a302Sas200622 int flag = 0; 1826dc20a302Sas200622 int cmd; 1827dc20a302Sas200622 1828dc20a302Sas200622 cmd = (nbl_need_check(vp)) ? F_SHARE_NBMAND : F_SHARE; 1829dc20a302Sas200622 1830dc20a302Sas200622 /* 1831dc20a302Sas200622 * Check if this is a metadata access 1832dc20a302Sas200622 */ 1833dc20a302Sas200622 1834dc20a302Sas200622 if ((desired_access & FILE_DATA_ALL) == 0) { 1835dc20a302Sas200622 new_access |= F_MDACC; 1836dc20a302Sas200622 } else { 1837dc20a302Sas200622 if (desired_access & (ACE_READ_DATA | ACE_EXECUTE)) { 1838dc20a302Sas200622 new_access |= F_RDACC; 1839dc20a302Sas200622 flag |= FREAD; 1840dc20a302Sas200622 } 1841dc20a302Sas200622 1842dc20a302Sas200622 if (desired_access & (ACE_WRITE_DATA | ACE_APPEND_DATA | 1843dc20a302Sas200622 ACE_ADD_FILE)) { 1844dc20a302Sas200622 new_access |= F_WRACC; 1845dc20a302Sas200622 flag |= FWRITE; 1846dc20a302Sas200622 } 1847dc20a302Sas200622 1848dc20a302Sas200622 if (SMB_DENY_READ(share_access)) { 1849dc20a302Sas200622 deny |= F_RDDNY; 1850dc20a302Sas200622 } 1851dc20a302Sas200622 1852dc20a302Sas200622 if (SMB_DENY_WRITE(share_access)) { 1853dc20a302Sas200622 deny |= F_WRDNY; 1854dc20a302Sas200622 } 1855dc20a302Sas200622 1856dc20a302Sas200622 if (cmd == F_SHARE_NBMAND) { 1857dc20a302Sas200622 if (desired_access & ACE_DELETE) 1858dc20a302Sas200622 new_access |= F_RMACC; 1859dc20a302Sas200622 1860dc20a302Sas200622 if (SMB_DENY_DELETE(share_access)) { 1861dc20a302Sas200622 deny |= F_RMDNY; 1862dc20a302Sas200622 } 1863dc20a302Sas200622 } 1864dc20a302Sas200622 } 1865dc20a302Sas200622 1866dc20a302Sas200622 shr.s_access = new_access; 1867dc20a302Sas200622 shr.s_deny = deny; 1868dc20a302Sas200622 shr.s_sysid = smb_ct.cc_sysid; 1869dc20a302Sas200622 shr.s_pid = uniq_fid; 1870dc20a302Sas200622 shr.s_own_len = sizeof (shr_own); 1871dc20a302Sas200622 shr.s_owner = (caddr_t)&shr_own; 1872dc20a302Sas200622 shr_own.sl_id = shr.s_sysid; 1873dc20a302Sas200622 shr_own.sl_pid = shr.s_pid; 1874dc20a302Sas200622 1875dc20a302Sas200622 return (VOP_SHRLOCK(vp, cmd, &shr, flag, cr, NULL)); 1876dc20a302Sas200622 } 1877dc20a302Sas200622 1878dc20a302Sas200622 int 1879dc20a302Sas200622 smb_vop_unshrlock(vnode_t *vp, uint32_t uniq_fid, cred_t *cr) 1880dc20a302Sas200622 { 1881dc20a302Sas200622 struct shrlock shr; 1882dc20a302Sas200622 struct shr_locowner shr_own; 1883dc20a302Sas200622 1884dc20a302Sas200622 /* 1885dc20a302Sas200622 * For s_access and s_deny, we do not need to pass in the original 1886dc20a302Sas200622 * values. 1887dc20a302Sas200622 */ 1888dc20a302Sas200622 1889dc20a302Sas200622 shr.s_access = 0; 1890dc20a302Sas200622 shr.s_deny = 0; 1891dc20a302Sas200622 shr.s_sysid = smb_ct.cc_sysid; 1892dc20a302Sas200622 shr.s_pid = uniq_fid; 1893dc20a302Sas200622 shr.s_own_len = sizeof (shr_own); 1894dc20a302Sas200622 shr.s_owner = (caddr_t)&shr_own; 1895dc20a302Sas200622 shr_own.sl_id = shr.s_sysid; 1896dc20a302Sas200622 shr_own.sl_pid = shr.s_pid; 1897dc20a302Sas200622 1898dc20a302Sas200622 return (VOP_SHRLOCK(vp, F_UNSHARE, &shr, 0, cr, NULL)); 1899dc20a302Sas200622 } 1900*8c10a865Sas200622 1901*8c10a865Sas200622 int 1902*8c10a865Sas200622 smb_vop_frlock(vnode_t *vp, cred_t *cr, int flag, flock64_t *bf) 1903*8c10a865Sas200622 { 1904*8c10a865Sas200622 int cmd = nbl_need_check(vp) ? F_SETLK_NBMAND : F_SETLK; 1905*8c10a865Sas200622 flk_callback_t flk_cb; 1906*8c10a865Sas200622 1907*8c10a865Sas200622 flk_init_callback(&flk_cb, smb_lock_frlock_callback, NULL); 1908*8c10a865Sas200622 1909*8c10a865Sas200622 return (VOP_FRLOCK(vp, cmd, bf, flag, 0, &flk_cb, cr, &smb_ct)); 1910*8c10a865Sas200622 } 1911*8c10a865Sas200622 1912*8c10a865Sas200622 static callb_cpr_t * 1913*8c10a865Sas200622 /* ARGSUSED */ 1914*8c10a865Sas200622 smb_lock_frlock_callback(flk_cb_when_t when, void *error) 1915*8c10a865Sas200622 { 1916*8c10a865Sas200622 return (0); 1917*8c10a865Sas200622 } 1918