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 /* 22*dc20a302Sas * 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/sid.h> 29*dc20a302Sas #include <sys/nbmlock.h> 30da6c28aaSamw #include <smbsrv/smb_fsops.h> 3155bf511dSas #include <smbsrv/smb_kproto.h> 3255bf511dSas #include <smbsrv/smbvar.h> 3355bf511dSas #include <smbsrv/ntstatus.h> 3455bf511dSas #include <smbsrv/ntaccess.h> 35*dc20a302Sas #include <smbsrv/smb_incl.h> 36da6c28aaSamw #include <acl/acl_common.h> 37*dc20a302Sas #include <sys/fcntl.h> 38*dc20a302Sas #include <sys/flock.h> 39*dc20a302Sas #include <fs/fs_subr.h> 40da6c28aaSamw 41da6c28aaSamw static int smb_fsop_amask_to_omode(uint32_t granted_access); 42da6c28aaSamw static int smb_fsop_sdinherit(smb_request_t *sr, smb_node_t *dnode, 43da6c28aaSamw smb_fssd_t *fs_sd); 44da6c28aaSamw 45*dc20a302Sas static callb_cpr_t *smb_fsop_frlock_callback(flk_cb_when_t when, void *error); 46*dc20a302Sas 47da6c28aaSamw /* 48da6c28aaSamw * The smb_fsop_* functions have knowledge of CIFS semantics. 49da6c28aaSamw * 50da6c28aaSamw * The smb_vop_* functions have minimal knowledge of CIFS semantics and 51da6c28aaSamw * serve as an interface to the VFS layer. 52da6c28aaSamw * 53da6c28aaSamw * Hence, smb_request_t and smb_node_t structures should not be passed 54da6c28aaSamw * from the smb_fsop_* layer to the smb_vop_* layer. 55da6c28aaSamw * 56da6c28aaSamw * In general, CIFS service code should only ever call smb_fsop_* 57da6c28aaSamw * functions directly, and never smb_vop_* functions directly. 58da6c28aaSamw * 59da6c28aaSamw * smb_fsop_* functions should call smb_vop_* functions where possible, instead 60da6c28aaSamw * of their smb_fsop_* counterparts. However, there are times when 61da6c28aaSamw * this cannot be avoided. 62da6c28aaSamw */ 63da6c28aaSamw 64da6c28aaSamw /* 65da6c28aaSamw * Note: Stream names cannot be mangled. 66da6c28aaSamw */ 67da6c28aaSamw 68da6c28aaSamw int 69da6c28aaSamw smb_fsop_start() 70da6c28aaSamw { 71da6c28aaSamw int error; 72da6c28aaSamw 73*dc20a302Sas smb_vop_start(); 74*dc20a302Sas 75da6c28aaSamw error = smb_node_root_init(); 76da6c28aaSamw 77da6c28aaSamw if (error == 0) 78da6c28aaSamw error = smb_fem_init(); 79da6c28aaSamw 80da6c28aaSamw return (error); 81da6c28aaSamw } 82da6c28aaSamw 83da6c28aaSamw void 84da6c28aaSamw smb_fsop_stop() 85da6c28aaSamw { 86da6c28aaSamw smb_fem_shutdown(); 87da6c28aaSamw smb_vfs_rele_all(); 88da6c28aaSamw smb_node_root_fini(); 89da6c28aaSamw } 90da6c28aaSamw 91da6c28aaSamw int 92da6c28aaSamw smb_fsop_open(smb_ofile_t *of) 93da6c28aaSamw { 94da6c28aaSamw int mode; 95da6c28aaSamw 96da6c28aaSamw mode = smb_fsop_amask_to_omode(of->f_granted_access); 97da6c28aaSamw 98da6c28aaSamw /* 99da6c28aaSamw * Assuming that same vnode is returned as we had before 100da6c28aaSamw * (i.e. no special vnodes) 101da6c28aaSamw */ 102da6c28aaSamw 103*dc20a302Sas return (smb_vop_open(&of->f_node->vp, mode, of->f_cr)); 104da6c28aaSamw } 105da6c28aaSamw 106da6c28aaSamw int 107da6c28aaSamw smb_fsop_close(smb_ofile_t *of) 108da6c28aaSamw { 109da6c28aaSamw int mode; 110da6c28aaSamw 111da6c28aaSamw mode = smb_fsop_amask_to_omode(of->f_granted_access); 112da6c28aaSamw 113*dc20a302Sas return (smb_vop_close(of->f_node->vp, mode, of->f_cr)); 114da6c28aaSamw } 115da6c28aaSamw 116da6c28aaSamw static int 117da6c28aaSamw smb_fsop_amask_to_omode(uint32_t granted_access) 118da6c28aaSamw { 119da6c28aaSamw int mode = 0; 120da6c28aaSamw 121da6c28aaSamw if (granted_access & (ACE_READ_DATA | ACE_EXECUTE)) 122da6c28aaSamw mode |= FREAD; 123da6c28aaSamw 124da6c28aaSamw if (granted_access & (ACE_WRITE_DATA | ACE_APPEND_DATA)) 125da6c28aaSamw mode |= FWRITE; 126da6c28aaSamw 127da6c28aaSamw if (granted_access & ACE_APPEND_DATA) 128da6c28aaSamw mode |= FAPPEND; 129da6c28aaSamw 130da6c28aaSamw return (mode); 131da6c28aaSamw } 132da6c28aaSamw 133da6c28aaSamw static int 134da6c28aaSamw smb_fsop_create_with_sd( 135da6c28aaSamw struct smb_request *sr, 136da6c28aaSamw cred_t *cr, 137da6c28aaSamw smb_node_t *snode, 138da6c28aaSamw char *name, 139da6c28aaSamw smb_attr_t *attr, 140da6c28aaSamw smb_node_t **ret_snode, 141da6c28aaSamw smb_attr_t *ret_attr, 142da6c28aaSamw smb_fssd_t *fs_sd) 143da6c28aaSamw { 144da6c28aaSamw vsecattr_t *vsap; 145da6c28aaSamw vsecattr_t vsecattr; 146da6c28aaSamw acl_t *acl, *dacl, *sacl; 147da6c28aaSamw smb_attr_t set_attr; 148da6c28aaSamw vnode_t *vp; 149da6c28aaSamw int aclbsize = 0; /* size of acl list in bytes */ 150da6c28aaSamw int flags = 0; 151da6c28aaSamw int is_dir; 152da6c28aaSamw int rc; 15355bf511dSas boolean_t no_xvattr = B_FALSE; 154da6c28aaSamw 155da6c28aaSamw ASSERT(fs_sd); 156da6c28aaSamw 157da6c28aaSamw if (SMB_TREE_CASE_INSENSITIVE(sr)) 158da6c28aaSamw flags = SMB_IGNORE_CASE; 159da6c28aaSamw 160da6c28aaSamw ASSERT(cr); 161da6c28aaSamw 162da6c28aaSamw is_dir = ((fs_sd->sd_flags & SMB_FSSD_FLAGS_DIR) != 0); 163da6c28aaSamw 164da6c28aaSamw if (sr->tid_tree->t_flags & SMB_TREE_FLAG_ACLONCREATE) { 165da6c28aaSamw if (fs_sd->sd_secinfo & SMB_ACL_SECINFO) { 166da6c28aaSamw dacl = fs_sd->sd_zdacl; 167da6c28aaSamw sacl = fs_sd->sd_zsacl; 168da6c28aaSamw ASSERT(dacl || sacl); 169da6c28aaSamw if (dacl && sacl) { 17055bf511dSas acl = smb_fsacl_merge(dacl, sacl); 171da6c28aaSamw } else if (dacl) { 172da6c28aaSamw acl = dacl; 173da6c28aaSamw } else { 174da6c28aaSamw acl = sacl; 175da6c28aaSamw } 176da6c28aaSamw 17755bf511dSas rc = smb_fsacl_to_vsa(acl, &vsecattr, &aclbsize); 178da6c28aaSamw 179da6c28aaSamw if (dacl && sacl) 180da6c28aaSamw acl_free(acl); 181da6c28aaSamw 182da6c28aaSamw if (rc) 183da6c28aaSamw return (rc); 184da6c28aaSamw 185da6c28aaSamw vsap = &vsecattr; 186da6c28aaSamw } 187da6c28aaSamw else 188da6c28aaSamw vsap = NULL; 189da6c28aaSamw 190da6c28aaSamw if (is_dir) { 191da6c28aaSamw rc = smb_vop_mkdir(snode->vp, name, attr, &vp, flags, 192*dc20a302Sas cr, vsap); 193da6c28aaSamw } else { 194da6c28aaSamw rc = smb_vop_create(snode->vp, name, attr, &vp, flags, 195*dc20a302Sas cr, vsap); 196da6c28aaSamw } 197da6c28aaSamw 198da6c28aaSamw if (vsap != NULL) 199da6c28aaSamw kmem_free(vsap->vsa_aclentp, aclbsize); 200da6c28aaSamw 201da6c28aaSamw if (rc != 0) 202da6c28aaSamw return (rc); 203da6c28aaSamw 204da6c28aaSamw set_attr.sa_mask = 0; 205da6c28aaSamw 206da6c28aaSamw /* 207da6c28aaSamw * Ideally we should be able to specify the owner and owning 208da6c28aaSamw * group at create time along with the ACL. Since we cannot 209da6c28aaSamw * do that right now, kcred is passed to smb_vop_setattr so it 210da6c28aaSamw * doesn't fail due to lack of permission. 211da6c28aaSamw */ 212da6c28aaSamw if (fs_sd->sd_secinfo & SMB_OWNER_SECINFO) { 213da6c28aaSamw set_attr.sa_vattr.va_uid = fs_sd->sd_uid; 214da6c28aaSamw set_attr.sa_mask |= SMB_AT_UID; 215da6c28aaSamw } 216da6c28aaSamw 217da6c28aaSamw if (fs_sd->sd_secinfo & SMB_GROUP_SECINFO) { 218da6c28aaSamw set_attr.sa_vattr.va_gid = fs_sd->sd_gid; 219da6c28aaSamw set_attr.sa_mask |= SMB_AT_GID; 220da6c28aaSamw } 221da6c28aaSamw 222da6c28aaSamw if (set_attr.sa_mask) { 22355bf511dSas if (sr && sr->tid_tree) 22455bf511dSas if (sr->tid_tree->t_flags & SMB_TREE_FLAG_UFS) 22555bf511dSas no_xvattr = B_TRUE; 226da6c28aaSamw rc = smb_vop_setattr(snode->vp, NULL, &set_attr, 227*dc20a302Sas 0, kcred, no_xvattr); 228da6c28aaSamw } 229da6c28aaSamw 230da6c28aaSamw } else { 231da6c28aaSamw /* 232da6c28aaSamw * For filesystems that don't support ACL-on-create, try 233da6c28aaSamw * to set the specified SD after create, which could actually 234da6c28aaSamw * fail because of conflicts between inherited security 235da6c28aaSamw * attributes upon creation and the specified SD. 236da6c28aaSamw * 237da6c28aaSamw * Passing kcred to smb_fsop_sdwrite() to overcome this issue. 238da6c28aaSamw */ 239da6c28aaSamw 240da6c28aaSamw if (is_dir) { 241da6c28aaSamw rc = smb_vop_mkdir(snode->vp, name, attr, &vp, flags, 242*dc20a302Sas cr, NULL); 243da6c28aaSamw } else { 244da6c28aaSamw rc = smb_vop_create(snode->vp, name, attr, &vp, flags, 245*dc20a302Sas cr, NULL); 246da6c28aaSamw } 247da6c28aaSamw 24855bf511dSas if (rc != 0) 24955bf511dSas return (rc); 25055bf511dSas 25155bf511dSas if ((sr->tid_tree->t_flags & SMB_TREE_FLAG_NFS_MOUNTED) == 0) 252da6c28aaSamw rc = smb_fsop_sdwrite(sr, kcred, snode, fs_sd, 1); 253da6c28aaSamw } 254da6c28aaSamw 255da6c28aaSamw if (rc == 0) { 256da6c28aaSamw *ret_snode = smb_node_lookup(sr, &sr->arg.open, cr, vp, name, 257da6c28aaSamw snode, NULL, ret_attr); 258da6c28aaSamw 259da6c28aaSamw if (*ret_snode == NULL) { 260da6c28aaSamw VN_RELE(vp); 261da6c28aaSamw rc = ENOMEM; 262da6c28aaSamw } 263da6c28aaSamw } 264da6c28aaSamw 26555bf511dSas if (rc != 0) { 26655bf511dSas if (is_dir) { 267*dc20a302Sas (void) smb_vop_rmdir(snode->vp, name, flags, cr); 26855bf511dSas } else { 269*dc20a302Sas (void) smb_vop_remove(snode->vp, name, flags, cr); 27055bf511dSas } 27155bf511dSas } 27255bf511dSas 273da6c28aaSamw return (rc); 274da6c28aaSamw } 275da6c28aaSamw 276da6c28aaSamw 277da6c28aaSamw /* 278da6c28aaSamw * smb_fsop_create 279da6c28aaSamw * 280da6c28aaSamw * All SMB functions should use this wrapper to ensure that 281da6c28aaSamw * all the smb_vop_creates are performed with the appropriate credentials. 282da6c28aaSamw * Please document any direct calls to explain the reason 283da6c28aaSamw * for avoiding this wrapper. 284da6c28aaSamw * 285da6c28aaSamw * It is assumed that a reference exists on snode coming into this routine. 286da6c28aaSamw * 287da6c28aaSamw * *ret_snode is returned with a reference upon success. No reference is 288da6c28aaSamw * taken if an error is returned. 289da6c28aaSamw */ 290da6c28aaSamw 291da6c28aaSamw int 292da6c28aaSamw smb_fsop_create( 293da6c28aaSamw struct smb_request *sr, 294da6c28aaSamw cred_t *cr, 295da6c28aaSamw smb_node_t *dir_snode, 296da6c28aaSamw char *name, 297da6c28aaSamw smb_attr_t *attr, 298da6c28aaSamw smb_node_t **ret_snode, 299da6c28aaSamw smb_attr_t *ret_attr) 300da6c28aaSamw { 301da6c28aaSamw struct open_param *op = &sr->arg.open; 302da6c28aaSamw smb_node_t *fnode; 303da6c28aaSamw smb_attr_t file_attr; 304da6c28aaSamw vnode_t *xattrdirvp; 305da6c28aaSamw vnode_t *vp; 306da6c28aaSamw char *longname = NULL; 307da6c28aaSamw char *namep; 308da6c28aaSamw char *fname; 309da6c28aaSamw char *sname; 310da6c28aaSamw int is_stream; 311da6c28aaSamw int flags = 0; 312da6c28aaSamw int rc = 0; 313da6c28aaSamw smb_fssd_t fs_sd; 314da6c28aaSamw uint32_t secinfo; 315da6c28aaSamw uint32_t status; 316da6c28aaSamw 317da6c28aaSamw ASSERT(cr); 318da6c28aaSamw ASSERT(dir_snode); 319da6c28aaSamw ASSERT(dir_snode->n_magic == SMB_NODE_MAGIC); 320da6c28aaSamw ASSERT(dir_snode->n_state != SMB_NODE_STATE_DESTROYING); 321da6c28aaSamw 322da6c28aaSamw ASSERT(ret_snode); 323da6c28aaSamw *ret_snode = 0; 324da6c28aaSamw 325da6c28aaSamw ASSERT(name); 326da6c28aaSamw if (*name == 0) 327da6c28aaSamw return (EINVAL); 328da6c28aaSamw 329da6c28aaSamw if (SMB_TREE_ROOT_FS(sr, dir_snode) == 0) 330da6c28aaSamw return (EACCES); 331da6c28aaSamw 332da6c28aaSamw ASSERT(sr); 333da6c28aaSamw ASSERT(sr->tid_tree); 334da6c28aaSamw if (SMB_TREE_IS_READ_ONLY(sr)) 335da6c28aaSamw return (EROFS); 336da6c28aaSamw 337da6c28aaSamw if (SMB_TREE_CASE_INSENSITIVE(sr)) 338da6c28aaSamw flags = SMB_IGNORE_CASE; 339da6c28aaSamw 340da6c28aaSamw fname = kmem_alloc(MAXNAMELEN, KM_SLEEP); 341da6c28aaSamw sname = kmem_alloc(MAXNAMELEN, KM_SLEEP); 342da6c28aaSamw 343da6c28aaSamw is_stream = smb_stream_parse_name(name, fname, sname); 344da6c28aaSamw 345da6c28aaSamw if (is_stream) 346da6c28aaSamw namep = fname; 347da6c28aaSamw else 348da6c28aaSamw namep = name; 349da6c28aaSamw 350da6c28aaSamw if (smb_maybe_mangled_name(namep)) { 351da6c28aaSamw longname = kmem_alloc(MAXNAMELEN, KM_SLEEP); 352da6c28aaSamw 353da6c28aaSamw rc = smb_unmangle_name(sr, cr, dir_snode, namep, longname, 354da6c28aaSamw MAXNAMELEN, NULL, NULL, 1); 355da6c28aaSamw 356da6c28aaSamw if ((is_stream == 0) && (rc == 0)) 357da6c28aaSamw rc = EEXIST; 358da6c28aaSamw 359da6c28aaSamw if ((is_stream && rc) || 360da6c28aaSamw ((is_stream == 0) && (rc != ENOENT))) { 361da6c28aaSamw kmem_free(longname, MAXNAMELEN); 362da6c28aaSamw kmem_free(fname, MAXNAMELEN); 363da6c28aaSamw kmem_free(sname, MAXNAMELEN); 364da6c28aaSamw return (rc); 365da6c28aaSamw } 366da6c28aaSamw 367da6c28aaSamw if (is_stream) 368da6c28aaSamw namep = longname; 369da6c28aaSamw else 370da6c28aaSamw kmem_free(longname, MAXNAMELEN); 371da6c28aaSamw } 372da6c28aaSamw 373da6c28aaSamw if (is_stream) { 374da6c28aaSamw /* 375da6c28aaSamw * Look up the unnamed stream. 376da6c28aaSamw * 377da6c28aaSamw * Mangle processing in smb_fsop_lookup() for the unnamed 378da6c28aaSamw * stream won't be needed (as it was done above), but 379da6c28aaSamw * it may be needed on any link target (which 380da6c28aaSamw * smb_fsop_lookup() will provide). 381da6c28aaSamw */ 382da6c28aaSamw rc = smb_fsop_lookup(sr, cr, flags | SMB_FOLLOW_LINKS, 383da6c28aaSamw sr->tid_tree->t_snode, dir_snode, namep, &fnode, &file_attr, 384da6c28aaSamw 0, 0); 385da6c28aaSamw 386da6c28aaSamw if (longname) { 387da6c28aaSamw kmem_free(longname, MAXNAMELEN); 388da6c28aaSamw namep = NULL; 389da6c28aaSamw } 390da6c28aaSamw 391da6c28aaSamw if (rc != 0) { 392da6c28aaSamw kmem_free(fname, MAXNAMELEN); 393da6c28aaSamw kmem_free(sname, MAXNAMELEN); 394da6c28aaSamw return (rc); 395da6c28aaSamw } 396da6c28aaSamw 397da6c28aaSamw rc = smb_vop_stream_create(fnode->vp, sname, attr, &vp, 398*dc20a302Sas &xattrdirvp, flags, cr); 399da6c28aaSamw 400da6c28aaSamw if (rc != 0) { 401da6c28aaSamw smb_node_release(fnode); 402da6c28aaSamw kmem_free(fname, MAXNAMELEN); 403da6c28aaSamw kmem_free(sname, MAXNAMELEN); 404da6c28aaSamw return (rc); 405da6c28aaSamw } 406da6c28aaSamw 407da6c28aaSamw *ret_snode = smb_stream_node_lookup(sr, cr, fnode, xattrdirvp, 408da6c28aaSamw vp, sname, ret_attr); 409da6c28aaSamw 410da6c28aaSamw smb_node_release(fnode); 411da6c28aaSamw 412da6c28aaSamw if (*ret_snode == NULL) { 413da6c28aaSamw VN_RELE(xattrdirvp); 414da6c28aaSamw VN_RELE(vp); 415da6c28aaSamw kmem_free(fname, MAXNAMELEN); 416da6c28aaSamw kmem_free(sname, MAXNAMELEN); 417da6c28aaSamw return (ENOMEM); 418da6c28aaSamw } 419da6c28aaSamw } else { 42055bf511dSas if (op->sd) { 421da6c28aaSamw /* 422da6c28aaSamw * SD sent by client in Windows format. Needs to be 423da6c28aaSamw * converted to FS format. No inheritance. 424da6c28aaSamw */ 42555bf511dSas secinfo = smb_sd_get_secinfo(op->sd); 42655bf511dSas smb_fssd_init(&fs_sd, secinfo, 0); 427da6c28aaSamw 42855bf511dSas status = smb_sd_tofs(op->sd, &fs_sd); 429da6c28aaSamw if (status == NT_STATUS_SUCCESS) { 430da6c28aaSamw rc = smb_fsop_create_with_sd(sr, cr, dir_snode, 431da6c28aaSamw name, attr, ret_snode, ret_attr, &fs_sd); 432da6c28aaSamw } 433da6c28aaSamw else 434da6c28aaSamw rc = EINVAL; 43555bf511dSas smb_fssd_term(&fs_sd); 436da6c28aaSamw } else if (sr->tid_tree->t_acltype == ACE_T) { 437da6c28aaSamw /* 438da6c28aaSamw * No incoming SD and filesystem is ZFS 439da6c28aaSamw * Server applies Windows inheritance rules, 440da6c28aaSamw * see smb_fsop_sdinherit() comments as to why. 441da6c28aaSamw */ 44255bf511dSas smb_fssd_init(&fs_sd, SMB_ACL_SECINFO, 0); 443da6c28aaSamw rc = smb_fsop_sdinherit(sr, dir_snode, &fs_sd); 444da6c28aaSamw if (rc == 0) { 445da6c28aaSamw rc = smb_fsop_create_with_sd(sr, cr, dir_snode, 446da6c28aaSamw name, attr, ret_snode, ret_attr, &fs_sd); 447da6c28aaSamw } 448da6c28aaSamw 44955bf511dSas smb_fssd_term(&fs_sd); 450da6c28aaSamw } else { 451da6c28aaSamw /* 452da6c28aaSamw * No incoming SD and filesystem is not ZFS 453da6c28aaSamw * let the filesystem handles the inheritance. 454da6c28aaSamw */ 455da6c28aaSamw rc = smb_vop_create(dir_snode->vp, name, attr, &vp, 456*dc20a302Sas flags, cr, NULL); 457da6c28aaSamw 458da6c28aaSamw if (rc == 0) { 459da6c28aaSamw *ret_snode = smb_node_lookup(sr, op, cr, vp, 460da6c28aaSamw name, dir_snode, NULL, ret_attr); 461da6c28aaSamw 462da6c28aaSamw if (*ret_snode == NULL) { 463da6c28aaSamw VN_RELE(vp); 464da6c28aaSamw rc = ENOMEM; 465da6c28aaSamw } 466da6c28aaSamw } 467da6c28aaSamw 468da6c28aaSamw } 469da6c28aaSamw } 470da6c28aaSamw 471da6c28aaSamw kmem_free(fname, MAXNAMELEN); 472da6c28aaSamw kmem_free(sname, MAXNAMELEN); 473da6c28aaSamw return (rc); 474da6c28aaSamw } 475da6c28aaSamw 476da6c28aaSamw /* 477da6c28aaSamw * smb_fsop_mkdir 478da6c28aaSamw * 479da6c28aaSamw * All SMB functions should use this wrapper to ensure that 480da6c28aaSamw * the the calls are performed with the appropriate credentials. 481da6c28aaSamw * Please document any direct call to explain the reason 482da6c28aaSamw * for avoiding this wrapper. 483da6c28aaSamw * 484da6c28aaSamw * It is assumed that a reference exists on snode coming into this routine. 485da6c28aaSamw * 486da6c28aaSamw * *ret_snode is returned with a reference upon success. No reference is 487da6c28aaSamw * taken if an error is returned. 488da6c28aaSamw */ 489da6c28aaSamw int 490da6c28aaSamw smb_fsop_mkdir( 491da6c28aaSamw struct smb_request *sr, 492da6c28aaSamw cred_t *cr, 493da6c28aaSamw smb_node_t *dir_snode, 494da6c28aaSamw char *name, 495da6c28aaSamw smb_attr_t *attr, 496da6c28aaSamw smb_node_t **ret_snode, 497da6c28aaSamw smb_attr_t *ret_attr) 498da6c28aaSamw { 499da6c28aaSamw struct open_param *op = &sr->arg.open; 500da6c28aaSamw char *longname; 501da6c28aaSamw vnode_t *vp; 502da6c28aaSamw int flags = 0; 503da6c28aaSamw smb_fssd_t fs_sd; 504da6c28aaSamw uint32_t secinfo; 505da6c28aaSamw uint32_t status; 506da6c28aaSamw int rc; 507da6c28aaSamw ASSERT(cr); 508da6c28aaSamw ASSERT(dir_snode); 509da6c28aaSamw ASSERT(dir_snode->n_magic == SMB_NODE_MAGIC); 510da6c28aaSamw ASSERT(dir_snode->n_state != SMB_NODE_STATE_DESTROYING); 511da6c28aaSamw 512da6c28aaSamw ASSERT(ret_snode); 513da6c28aaSamw *ret_snode = 0; 514da6c28aaSamw 515da6c28aaSamw ASSERT(name); 516da6c28aaSamw if (*name == 0) 517da6c28aaSamw return (EINVAL); 518da6c28aaSamw 519da6c28aaSamw if (SMB_TREE_ROOT_FS(sr, dir_snode) == 0) 520da6c28aaSamw return (EACCES); 521da6c28aaSamw 522da6c28aaSamw ASSERT(sr); 523da6c28aaSamw ASSERT(sr->tid_tree); 524da6c28aaSamw if (SMB_TREE_IS_READ_ONLY(sr)) 525da6c28aaSamw return (EROFS); 526da6c28aaSamw 527da6c28aaSamw if (smb_maybe_mangled_name(name)) { 528da6c28aaSamw longname = kmem_alloc(MAXNAMELEN, KM_SLEEP); 529da6c28aaSamw rc = smb_unmangle_name(sr, cr, dir_snode, name, longname, 530da6c28aaSamw MAXNAMELEN, NULL, NULL, 1); 531da6c28aaSamw 532da6c28aaSamw kmem_free(longname, MAXNAMELEN); 533da6c28aaSamw 534da6c28aaSamw /* 535da6c28aaSamw * If the name passed in by the client has an unmangled 536da6c28aaSamw * equivalent that is found in the specified directory, 537da6c28aaSamw * then the mkdir cannot succeed. Return EEXIST. 538da6c28aaSamw * 539da6c28aaSamw * Only if ENOENT is returned will a mkdir be attempted. 540da6c28aaSamw */ 541da6c28aaSamw 542da6c28aaSamw if (rc == 0) 543da6c28aaSamw rc = EEXIST; 544da6c28aaSamw 545da6c28aaSamw if (rc != ENOENT) 546da6c28aaSamw return (rc); 547da6c28aaSamw } 548da6c28aaSamw 549da6c28aaSamw if (SMB_TREE_CASE_INSENSITIVE(sr)) 550da6c28aaSamw flags = SMB_IGNORE_CASE; 551da6c28aaSamw 55255bf511dSas if (op->sd) { 553da6c28aaSamw /* 554da6c28aaSamw * SD sent by client in Windows format. Needs to be 555da6c28aaSamw * converted to FS format. No inheritance. 556da6c28aaSamw */ 55755bf511dSas secinfo = smb_sd_get_secinfo(op->sd); 55855bf511dSas smb_fssd_init(&fs_sd, secinfo, SMB_FSSD_FLAGS_DIR); 559da6c28aaSamw 56055bf511dSas status = smb_sd_tofs(op->sd, &fs_sd); 561da6c28aaSamw if (status == NT_STATUS_SUCCESS) { 562da6c28aaSamw rc = smb_fsop_create_with_sd(sr, cr, dir_snode, 563da6c28aaSamw name, attr, ret_snode, ret_attr, &fs_sd); 564da6c28aaSamw } 565da6c28aaSamw else 566da6c28aaSamw rc = EINVAL; 56755bf511dSas smb_fssd_term(&fs_sd); 568da6c28aaSamw } else if (sr->tid_tree->t_acltype == ACE_T) { 569da6c28aaSamw /* 570da6c28aaSamw * No incoming SD and filesystem is ZFS 571da6c28aaSamw * Server applies Windows inheritance rules, 572da6c28aaSamw * see smb_fsop_sdinherit() comments as to why. 573da6c28aaSamw */ 57455bf511dSas smb_fssd_init(&fs_sd, SMB_ACL_SECINFO, SMB_FSSD_FLAGS_DIR); 575da6c28aaSamw rc = smb_fsop_sdinherit(sr, dir_snode, &fs_sd); 576da6c28aaSamw if (rc == 0) { 577da6c28aaSamw rc = smb_fsop_create_with_sd(sr, cr, dir_snode, 578da6c28aaSamw name, attr, ret_snode, ret_attr, &fs_sd); 579da6c28aaSamw } 580da6c28aaSamw 58155bf511dSas smb_fssd_term(&fs_sd); 582da6c28aaSamw 583da6c28aaSamw } else { 584da6c28aaSamw rc = smb_vop_mkdir(dir_snode->vp, name, attr, &vp, flags, cr, 585*dc20a302Sas NULL); 586da6c28aaSamw 587da6c28aaSamw if (rc == 0) { 588da6c28aaSamw *ret_snode = smb_node_lookup(sr, op, cr, vp, name, 589da6c28aaSamw dir_snode, NULL, ret_attr); 590da6c28aaSamw 591da6c28aaSamw if (*ret_snode == NULL) { 592da6c28aaSamw VN_RELE(vp); 593da6c28aaSamw rc = ENOMEM; 594da6c28aaSamw } 595da6c28aaSamw } 596da6c28aaSamw } 597da6c28aaSamw 598da6c28aaSamw return (rc); 599da6c28aaSamw } 600da6c28aaSamw 601da6c28aaSamw /* 602da6c28aaSamw * smb_fsop_remove 603da6c28aaSamw * 604da6c28aaSamw * All SMB functions should use this wrapper to ensure that 605da6c28aaSamw * the the calls are performed with the appropriate credentials. 606da6c28aaSamw * Please document any direct call to explain the reason 607da6c28aaSamw * for avoiding this wrapper. 608da6c28aaSamw * 609da6c28aaSamw * It is assumed that a reference exists on snode coming into this routine. 610da6c28aaSamw * 611da6c28aaSamw * od: This means that the name passed in is an on-disk name. 612da6c28aaSamw * A null smb_request might be passed to this function. 613da6c28aaSamw */ 614da6c28aaSamw 615da6c28aaSamw int 616da6c28aaSamw smb_fsop_remove( 617da6c28aaSamw struct smb_request *sr, 618da6c28aaSamw cred_t *cr, 619da6c28aaSamw smb_node_t *dir_snode, 620da6c28aaSamw char *name, 621da6c28aaSamw int od) 622da6c28aaSamw { 623da6c28aaSamw smb_node_t *fnode; 624da6c28aaSamw smb_attr_t file_attr; 625da6c28aaSamw char *longname; 626da6c28aaSamw char *fname; 627da6c28aaSamw char *sname; 628da6c28aaSamw int flags = 0; 629da6c28aaSamw int rc; 630da6c28aaSamw 631da6c28aaSamw ASSERT(cr); 632da6c28aaSamw /* 633da6c28aaSamw * The state of the node could be SMB_NODE_STATE_DESTROYING if this 634da6c28aaSamw * function is called during the deletion of the node (because of 635da6c28aaSamw * DELETE_ON_CLOSE). 636da6c28aaSamw */ 637da6c28aaSamw ASSERT(dir_snode); 638da6c28aaSamw ASSERT(dir_snode->n_magic == SMB_NODE_MAGIC); 639da6c28aaSamw 640da6c28aaSamw if (SMB_TREE_ROOT_FS(sr, dir_snode) == 0) 641da6c28aaSamw return (EACCES); 642da6c28aaSamw 643da6c28aaSamw if (SMB_TREE_IS_READ_ONLY(sr)) 644da6c28aaSamw return (EROFS); 645da6c28aaSamw 646da6c28aaSamw fname = kmem_alloc(MAXNAMELEN, KM_SLEEP); 647da6c28aaSamw sname = kmem_alloc(MAXNAMELEN, KM_SLEEP); 648da6c28aaSamw 649da6c28aaSamw if (smb_stream_parse_name(name, fname, sname)) { 650da6c28aaSamw 651da6c28aaSamw ASSERT(od == 0); 652da6c28aaSamw 653da6c28aaSamw if (SMB_TREE_CASE_INSENSITIVE(sr)) 654da6c28aaSamw flags = SMB_IGNORE_CASE; 655da6c28aaSamw 656da6c28aaSamw /* 657da6c28aaSamw * Look up the unnamed stream (i.e. fname). 658da6c28aaSamw * Unmangle processing will be done on fname 659da6c28aaSamw * as well as any link target. 660da6c28aaSamw */ 661da6c28aaSamw 662da6c28aaSamw rc = smb_fsop_lookup(sr, cr, flags | SMB_FOLLOW_LINKS, 663da6c28aaSamw sr->tid_tree->t_snode, dir_snode, fname, &fnode, &file_attr, 664da6c28aaSamw 0, 0); 665da6c28aaSamw 666da6c28aaSamw if (rc != 0) { 667da6c28aaSamw kmem_free(fname, MAXNAMELEN); 668da6c28aaSamw kmem_free(sname, MAXNAMELEN); 669da6c28aaSamw return (rc); 670da6c28aaSamw } 671da6c28aaSamw 672da6c28aaSamw /* 673da6c28aaSamw * XXX 674da6c28aaSamw * Need to find out what permission is required by NTFS 675da6c28aaSamw * to remove a stream. 676da6c28aaSamw */ 677*dc20a302Sas rc = smb_vop_stream_remove(fnode->vp, sname, flags, cr); 678da6c28aaSamw 679da6c28aaSamw smb_node_release(fnode); 680da6c28aaSamw } else { 681da6c28aaSamw /* 682da6c28aaSamw * If the passed-in name is an on-disk name, 683da6c28aaSamw * then we need to do a case-sensitive remove. 684da6c28aaSamw * This is important if the on-disk name 685da6c28aaSamw * corresponds to a mangled name passed in by 686da6c28aaSamw * the client. We want to make sure to remove 687da6c28aaSamw * the exact file specified by the client, 688da6c28aaSamw * instead of letting the underlying file system 689da6c28aaSamw * do a remove on the "first match." 690da6c28aaSamw */ 691da6c28aaSamw 692da6c28aaSamw if ((od == 0) && SMB_TREE_CASE_INSENSITIVE(sr)) 693da6c28aaSamw flags = SMB_IGNORE_CASE; 694da6c28aaSamw 695*dc20a302Sas rc = smb_vop_remove(dir_snode->vp, name, flags, cr); 696da6c28aaSamw 697da6c28aaSamw if (rc == ENOENT) { 698da6c28aaSamw if (smb_maybe_mangled_name(name) == 0) { 699da6c28aaSamw kmem_free(fname, MAXNAMELEN); 700da6c28aaSamw kmem_free(sname, MAXNAMELEN); 701da6c28aaSamw return (rc); 702da6c28aaSamw } 703da6c28aaSamw longname = kmem_alloc(MAXNAMELEN, KM_SLEEP); 704da6c28aaSamw 705da6c28aaSamw rc = smb_unmangle_name(sr, cr, dir_snode, name, 706da6c28aaSamw longname, MAXNAMELEN, NULL, NULL, 1); 707da6c28aaSamw 708da6c28aaSamw if (rc == 0) { 709da6c28aaSamw /* 710da6c28aaSamw * We passed "1" as the "od" parameter 711da6c28aaSamw * to smb_unmangle_name(), such that longname 712da6c28aaSamw * is the real (case-sensitive) on-disk name. 713da6c28aaSamw * We make sure we do a remove on this exact 714da6c28aaSamw * name, as the name was mangled and denotes 715da6c28aaSamw * a unique file. 716da6c28aaSamw */ 717da6c28aaSamw flags &= ~SMB_IGNORE_CASE; 718da6c28aaSamw rc = smb_vop_remove(dir_snode->vp, longname, 719*dc20a302Sas flags, cr); 720da6c28aaSamw } 721da6c28aaSamw 722da6c28aaSamw kmem_free(longname, MAXNAMELEN); 723da6c28aaSamw } 724da6c28aaSamw } 725da6c28aaSamw 726da6c28aaSamw kmem_free(fname, MAXNAMELEN); 727da6c28aaSamw kmem_free(sname, MAXNAMELEN); 728da6c28aaSamw return (rc); 729da6c28aaSamw } 730da6c28aaSamw 731da6c28aaSamw /* 732da6c28aaSamw * smb_fsop_remove_streams 733da6c28aaSamw * 734da6c28aaSamw * This function removes a file's streams without removing the 735da6c28aaSamw * file itself. 736da6c28aaSamw * 737da6c28aaSamw * It is assumed that snode is not a link. 738da6c28aaSamw */ 739da6c28aaSamw int 740da6c28aaSamw smb_fsop_remove_streams(struct smb_request *sr, cred_t *cr, 741da6c28aaSamw smb_node_t *fnode) 742da6c28aaSamw { 743da6c28aaSamw struct fs_stream_info stream_info; 744da6c28aaSamw uint32_t cookie = 0; 745da6c28aaSamw int flags = 0; 746da6c28aaSamw int rc; 747da6c28aaSamw 748da6c28aaSamw ASSERT(cr); 749da6c28aaSamw ASSERT(fnode); 750da6c28aaSamw ASSERT(fnode->n_magic == SMB_NODE_MAGIC); 751da6c28aaSamw ASSERT(fnode->n_state != SMB_NODE_STATE_DESTROYING); 752da6c28aaSamw 753da6c28aaSamw if (SMB_TREE_ROOT_FS(sr, fnode) == 0) 754da6c28aaSamw return (EACCES); 755da6c28aaSamw 756da6c28aaSamw if (SMB_TREE_IS_READ_ONLY(sr)) 757da6c28aaSamw return (EROFS); 758da6c28aaSamw 759da6c28aaSamw if (SMB_TREE_CASE_INSENSITIVE(sr)) 760da6c28aaSamw flags = SMB_IGNORE_CASE; 761da6c28aaSamw 762da6c28aaSamw for (;;) { 763da6c28aaSamw rc = smb_vop_stream_readdir(fnode->vp, &cookie, &stream_info, 764*dc20a302Sas NULL, NULL, flags, cr); 765da6c28aaSamw 766da6c28aaSamw if ((rc != 0) || (cookie == SMB_EOF)) 767da6c28aaSamw break; 768da6c28aaSamw 769da6c28aaSamw (void) smb_vop_stream_remove(fnode->vp, stream_info.name, flags, 770*dc20a302Sas cr); 771da6c28aaSamw } 772da6c28aaSamw return (rc); 773da6c28aaSamw } 774da6c28aaSamw 775da6c28aaSamw /* 776da6c28aaSamw * smb_fsop_rmdir 777da6c28aaSamw * 778da6c28aaSamw * All SMB functions should use this wrapper to ensure that 779da6c28aaSamw * the the calls are performed with the appropriate credentials. 780da6c28aaSamw * Please document any direct call to explain the reason 781da6c28aaSamw * for avoiding this wrapper. 782da6c28aaSamw * 783da6c28aaSamw * It is assumed that a reference exists on snode coming into this routine. 784da6c28aaSamw * 785da6c28aaSamw * od: This means that the name passed in is an on-disk name. 786da6c28aaSamw */ 787da6c28aaSamw 788da6c28aaSamw int 789da6c28aaSamw smb_fsop_rmdir( 790da6c28aaSamw struct smb_request *sr, 791da6c28aaSamw cred_t *cr, 792da6c28aaSamw smb_node_t *dir_snode, 793da6c28aaSamw char *name, 794da6c28aaSamw int od) 795da6c28aaSamw { 796da6c28aaSamw int rc; 797da6c28aaSamw int flags = 0; 798da6c28aaSamw char *longname; 799da6c28aaSamw 800da6c28aaSamw ASSERT(cr); 801da6c28aaSamw /* 802da6c28aaSamw * The state of the node could be SMB_NODE_STATE_DESTROYING if this 803da6c28aaSamw * function is called during the deletion of the node (because of 804da6c28aaSamw * DELETE_ON_CLOSE). 805da6c28aaSamw */ 806da6c28aaSamw ASSERT(dir_snode); 807da6c28aaSamw ASSERT(dir_snode->n_magic == SMB_NODE_MAGIC); 808da6c28aaSamw 809da6c28aaSamw if (SMB_TREE_ROOT_FS(sr, dir_snode) == 0) 810da6c28aaSamw return (EACCES); 811da6c28aaSamw 812da6c28aaSamw if (SMB_TREE_IS_READ_ONLY(sr)) 813da6c28aaSamw return (EROFS); 814da6c28aaSamw 815da6c28aaSamw /* 816da6c28aaSamw * If the passed-in name is an on-disk name, 817da6c28aaSamw * then we need to do a case-sensitive rmdir. 818da6c28aaSamw * This is important if the on-disk name 819da6c28aaSamw * corresponds to a mangled name passed in by 820da6c28aaSamw * the client. We want to make sure to remove 821da6c28aaSamw * the exact directory specified by the client, 822da6c28aaSamw * instead of letting the underlying file system 823da6c28aaSamw * do a rmdir on the "first match." 824da6c28aaSamw */ 825da6c28aaSamw 826da6c28aaSamw if ((od == 0) && SMB_TREE_CASE_INSENSITIVE(sr)) 827da6c28aaSamw flags = SMB_IGNORE_CASE; 828da6c28aaSamw 829*dc20a302Sas rc = smb_vop_rmdir(dir_snode->vp, name, flags, cr); 830da6c28aaSamw 831da6c28aaSamw if (rc == ENOENT) { 832da6c28aaSamw if (smb_maybe_mangled_name(name) == 0) 833da6c28aaSamw return (rc); 834da6c28aaSamw 835da6c28aaSamw longname = kmem_alloc(MAXNAMELEN, KM_SLEEP); 836da6c28aaSamw 837da6c28aaSamw rc = smb_unmangle_name(sr, cr, dir_snode, 838da6c28aaSamw name, longname, MAXNAMELEN, NULL, 839da6c28aaSamw NULL, 1); 840da6c28aaSamw 841da6c28aaSamw if (rc == 0) { 842da6c28aaSamw /* 843da6c28aaSamw * We passed "1" as the "od" parameter 844da6c28aaSamw * to smb_unmangle_name(), such that longname 845da6c28aaSamw * is the real (case-sensitive) on-disk name. 846da6c28aaSamw * We make sure we do a rmdir on this exact 847da6c28aaSamw * name, as the name was mangled and denotes 848da6c28aaSamw * a unique directory. 849da6c28aaSamw */ 850da6c28aaSamw flags &= ~SMB_IGNORE_CASE; 851*dc20a302Sas rc = smb_vop_rmdir(dir_snode->vp, longname, flags, cr); 852da6c28aaSamw } 853da6c28aaSamw 854da6c28aaSamw kmem_free(longname, MAXNAMELEN); 855da6c28aaSamw } 856da6c28aaSamw 857da6c28aaSamw return (rc); 858da6c28aaSamw } 859da6c28aaSamw 860da6c28aaSamw /* 861da6c28aaSamw * smb_fsop_getattr 862da6c28aaSamw * 863da6c28aaSamw * All SMB functions should use this wrapper to ensure that 864da6c28aaSamw * the the calls are performed with the appropriate credentials. 865da6c28aaSamw * Please document any direct call to explain the reason 866da6c28aaSamw * for avoiding this wrapper. 867da6c28aaSamw * 868da6c28aaSamw * It is assumed that a reference exists on snode coming into this routine. 869da6c28aaSamw */ 870da6c28aaSamw int 871da6c28aaSamw smb_fsop_getattr(struct smb_request *sr, cred_t *cr, smb_node_t *snode, 872da6c28aaSamw smb_attr_t *attr) 873da6c28aaSamw { 874da6c28aaSamw smb_node_t *unnamed_node; 875da6c28aaSamw vnode_t *unnamed_vp = NULL; 876da6c28aaSamw uint32_t status; 877da6c28aaSamw uint32_t access = 0; 878da6c28aaSamw int flags = 0; 879*dc20a302Sas int rc; 880da6c28aaSamw 881da6c28aaSamw ASSERT(cr); 882da6c28aaSamw ASSERT(snode); 883da6c28aaSamw ASSERT(snode->n_magic == SMB_NODE_MAGIC); 884da6c28aaSamw ASSERT(snode->n_state != SMB_NODE_STATE_DESTROYING); 885da6c28aaSamw 886da6c28aaSamw if (SMB_TREE_ROOT_FS(sr, snode) == 0) 887da6c28aaSamw return (EACCES); 888da6c28aaSamw 889da6c28aaSamw if (sr->fid_ofile) { 890da6c28aaSamw /* if uid and/or gid is requested */ 891da6c28aaSamw if (attr->sa_mask & (SMB_AT_UID|SMB_AT_GID)) 892da6c28aaSamw access |= READ_CONTROL; 893da6c28aaSamw 894da6c28aaSamw /* if anything else is also requested */ 895da6c28aaSamw if (attr->sa_mask & ~(SMB_AT_UID|SMB_AT_GID)) 896da6c28aaSamw access |= FILE_READ_ATTRIBUTES; 897da6c28aaSamw 898da6c28aaSamw status = smb_ofile_access(sr->fid_ofile, cr, access); 899da6c28aaSamw if (status != NT_STATUS_SUCCESS) 900da6c28aaSamw return (EACCES); 901da6c28aaSamw 902da6c28aaSamw if (sr->tid_tree->t_flags & SMB_TREE_FLAG_ACEMASKONACCESS) 903da6c28aaSamw flags = ATTR_NOACLCHECK; 904da6c28aaSamw } 905da6c28aaSamw 906da6c28aaSamw unnamed_node = SMB_IS_STREAM(snode); 907da6c28aaSamw 908da6c28aaSamw if (unnamed_node) { 909da6c28aaSamw ASSERT(unnamed_node->n_magic == SMB_NODE_MAGIC); 910da6c28aaSamw ASSERT(unnamed_node->n_state != SMB_NODE_STATE_DESTROYING); 911da6c28aaSamw unnamed_vp = unnamed_node->vp; 912da6c28aaSamw } 913da6c28aaSamw 914*dc20a302Sas rc = smb_vop_getattr(snode->vp, unnamed_vp, attr, flags, cr); 915*dc20a302Sas if (rc == 0) 916*dc20a302Sas snode->attr = *attr; 917*dc20a302Sas 918*dc20a302Sas return (rc); 919da6c28aaSamw } 920da6c28aaSamw 921da6c28aaSamw /* 922da6c28aaSamw * smb_fsop_readdir 923da6c28aaSamw * 924da6c28aaSamw * All SMB functions should use this smb_fsop_readdir wrapper to ensure that 925da6c28aaSamw * the smb_vop_readdir is performed with the appropriate credentials. 926da6c28aaSamw * Please document any direct call to smb_vop_readdir to explain the reason 927da6c28aaSamw * for avoiding this wrapper. 928da6c28aaSamw * 929da6c28aaSamw * It is assumed that a reference exists on snode coming into this routine. 930da6c28aaSamw */ 931da6c28aaSamw int 932da6c28aaSamw smb_fsop_readdir( 933da6c28aaSamw struct smb_request *sr, 934da6c28aaSamw cred_t *cr, 935da6c28aaSamw smb_node_t *dir_snode, 936da6c28aaSamw uint32_t *cookie, 937da6c28aaSamw char *name, 938da6c28aaSamw int *namelen, 939da6c28aaSamw ino64_t *fileid, 940da6c28aaSamw struct fs_stream_info *stream_info, 941da6c28aaSamw smb_node_t **ret_snode, 942da6c28aaSamw smb_attr_t *ret_attr) 943da6c28aaSamw { 944da6c28aaSamw smb_node_t *ret_snodep; 945da6c28aaSamw smb_node_t *fnode; 946da6c28aaSamw smb_attr_t tmp_attr; 947da6c28aaSamw vnode_t *xattrdirvp; 948da6c28aaSamw vnode_t *fvp; 949da6c28aaSamw vnode_t *vp = NULL; 950da6c28aaSamw char *od_name; 951da6c28aaSamw int rc; 952da6c28aaSamw int flags = 0; 953da6c28aaSamw 954da6c28aaSamw ASSERT(cr); 955da6c28aaSamw ASSERT(dir_snode); 956da6c28aaSamw ASSERT(dir_snode->n_magic == SMB_NODE_MAGIC); 957da6c28aaSamw ASSERT(dir_snode->n_state != SMB_NODE_STATE_DESTROYING); 958da6c28aaSamw 959da6c28aaSamw if (SMB_TREE_ROOT_FS(sr, dir_snode) == 0) 960da6c28aaSamw return (EACCES); 961da6c28aaSamw 962da6c28aaSamw if (*cookie == SMB_EOF) { 963da6c28aaSamw *namelen = 0; 964da6c28aaSamw return (0); 965da6c28aaSamw } 966da6c28aaSamw 967da6c28aaSamw if (SMB_TREE_CASE_INSENSITIVE(sr)) 968da6c28aaSamw flags = SMB_IGNORE_CASE; 969da6c28aaSamw 970da6c28aaSamw od_name = kmem_alloc(MAXNAMELEN, KM_SLEEP); 971da6c28aaSamw 972da6c28aaSamw if (stream_info) { 973da6c28aaSamw rc = smb_vop_lookup(dir_snode->vp, name, &fvp, od_name, 974*dc20a302Sas SMB_FOLLOW_LINKS, sr->tid_tree->t_snode->vp, cr); 975da6c28aaSamw 976da6c28aaSamw if (rc != 0) { 977da6c28aaSamw kmem_free(od_name, MAXNAMELEN); 978da6c28aaSamw return (rc); 979da6c28aaSamw } 980da6c28aaSamw 981da6c28aaSamw fnode = smb_node_lookup(sr, NULL, cr, fvp, od_name, dir_snode, 982da6c28aaSamw NULL, ret_attr); 983da6c28aaSamw 984da6c28aaSamw kmem_free(od_name, MAXNAMELEN); 985da6c28aaSamw 986da6c28aaSamw if (fnode == NULL) { 987da6c28aaSamw VN_RELE(fvp); 988da6c28aaSamw return (ENOMEM); 989da6c28aaSamw } 990da6c28aaSamw 991da6c28aaSamw /* 992da6c28aaSamw * XXX 993da6c28aaSamw * Need to find out what permission(s) NTFS requires for getting 994da6c28aaSamw * a file's streams list. 995da6c28aaSamw * 996da6c28aaSamw * Might have to use kcred. 997da6c28aaSamw */ 998da6c28aaSamw rc = smb_vop_stream_readdir(fvp, cookie, stream_info, &vp, 999*dc20a302Sas &xattrdirvp, flags, cr); 1000da6c28aaSamw 1001da6c28aaSamw if ((rc != 0) || (*cookie == SMB_EOF)) { 1002da6c28aaSamw smb_node_release(fnode); 1003da6c28aaSamw return (rc); 1004da6c28aaSamw } 1005da6c28aaSamw 1006da6c28aaSamw ret_snodep = smb_stream_node_lookup(sr, cr, fnode, xattrdirvp, 1007da6c28aaSamw vp, stream_info->name, &tmp_attr); 1008da6c28aaSamw 1009da6c28aaSamw smb_node_release(fnode); 1010da6c28aaSamw 1011da6c28aaSamw if (ret_snodep == NULL) { 1012da6c28aaSamw VN_RELE(xattrdirvp); 1013da6c28aaSamw VN_RELE(vp); 1014da6c28aaSamw return (ENOMEM); 1015da6c28aaSamw } 1016da6c28aaSamw 1017da6c28aaSamw stream_info->size = tmp_attr.sa_vattr.va_size; 1018da6c28aaSamw 1019da6c28aaSamw if (ret_attr) 1020da6c28aaSamw *ret_attr = tmp_attr; 1021da6c28aaSamw 1022da6c28aaSamw if (ret_snode) 1023da6c28aaSamw *ret_snode = ret_snodep; 1024da6c28aaSamw else 1025da6c28aaSamw smb_node_release(ret_snodep); 1026da6c28aaSamw 1027da6c28aaSamw } else { 1028da6c28aaSamw rc = smb_vop_readdir(dir_snode->vp, cookie, name, namelen, 1029*dc20a302Sas fileid, &vp, od_name, flags, cr); 1030da6c28aaSamw 1031da6c28aaSamw if (rc != 0) { 1032da6c28aaSamw kmem_free(od_name, MAXNAMELEN); 1033da6c28aaSamw return (rc); 1034da6c28aaSamw } 1035da6c28aaSamw 1036da6c28aaSamw if (*namelen) { 1037da6c28aaSamw ASSERT(vp); 1038da6c28aaSamw if (ret_attr || ret_snode) { 1039da6c28aaSamw ret_snodep = smb_node_lookup(sr, NULL, cr, vp, 1040da6c28aaSamw od_name, dir_snode, NULL, &tmp_attr); 1041da6c28aaSamw 1042da6c28aaSamw if (ret_snodep == NULL) { 1043da6c28aaSamw kmem_free(od_name, MAXNAMELEN); 1044da6c28aaSamw VN_RELE(vp); 1045da6c28aaSamw return (ENOMEM); 1046da6c28aaSamw } 1047da6c28aaSamw 1048da6c28aaSamw if (ret_attr) 1049da6c28aaSamw *ret_attr = tmp_attr; 1050da6c28aaSamw 1051da6c28aaSamw if (ret_snode) 1052da6c28aaSamw *ret_snode = ret_snodep; 1053da6c28aaSamw else 1054da6c28aaSamw smb_node_release(ret_snodep); 1055da6c28aaSamw } 1056da6c28aaSamw } 1057da6c28aaSamw 1058da6c28aaSamw kmem_free(od_name, MAXNAMELEN); 1059da6c28aaSamw } 1060da6c28aaSamw 1061da6c28aaSamw return (rc); 1062da6c28aaSamw } 1063da6c28aaSamw 1064da6c28aaSamw /* 1065da6c28aaSamw * smb_fsop_getdents 1066da6c28aaSamw * 1067da6c28aaSamw * All SMB functions should use this smb_vop_getdents wrapper to ensure that 1068da6c28aaSamw * the smb_vop_getdents is performed with the appropriate credentials. 1069da6c28aaSamw * Please document any direct call to smb_vop_getdents to explain the reason 1070da6c28aaSamw * for avoiding this wrapper. 1071da6c28aaSamw * 1072da6c28aaSamw * It is assumed that a reference exists on snode coming into this routine. 1073da6c28aaSamw */ 1074da6c28aaSamw /*ARGSUSED*/ 1075da6c28aaSamw int 1076da6c28aaSamw smb_fsop_getdents( 1077da6c28aaSamw struct smb_request *sr, 1078da6c28aaSamw cred_t *cr, 1079da6c28aaSamw smb_node_t *dir_snode, 1080da6c28aaSamw uint32_t *cookie, 1081da6c28aaSamw uint64_t *verifierp, 1082da6c28aaSamw int32_t *maxcnt, 1083da6c28aaSamw char *args, 1084da6c28aaSamw char *pattern) 1085da6c28aaSamw { 1086da6c28aaSamw int flags = 0; 1087da6c28aaSamw 1088da6c28aaSamw ASSERT(cr); 1089da6c28aaSamw ASSERT(dir_snode); 1090da6c28aaSamw ASSERT(dir_snode->n_magic == SMB_NODE_MAGIC); 1091da6c28aaSamw ASSERT(dir_snode->n_state != SMB_NODE_STATE_DESTROYING); 1092da6c28aaSamw 1093da6c28aaSamw if (SMB_TREE_ROOT_FS(sr, dir_snode) == 0) 1094da6c28aaSamw return (EACCES); 1095da6c28aaSamw 1096da6c28aaSamw if (SMB_TREE_CASE_INSENSITIVE(sr)) 1097da6c28aaSamw flags = SMB_IGNORE_CASE; 1098da6c28aaSamw 1099da6c28aaSamw return (smb_vop_getdents(dir_snode, cookie, 0, maxcnt, args, pattern, 1100*dc20a302Sas flags, sr, cr)); 1101da6c28aaSamw } 1102da6c28aaSamw 1103da6c28aaSamw /* 1104da6c28aaSamw * smb_fsop_rename 1105da6c28aaSamw * 1106da6c28aaSamw * All SMB functions should use this smb_vop_rename wrapper to ensure that 1107da6c28aaSamw * the smb_vop_rename is performed with the appropriate credentials. 1108da6c28aaSamw * Please document any direct call to smb_vop_rename to explain the reason 1109da6c28aaSamw * for avoiding this wrapper. 1110da6c28aaSamw * 1111da6c28aaSamw * It is assumed that references exist on from_dir_snode and to_dir_snode coming 1112da6c28aaSamw * into this routine. 1113da6c28aaSamw */ 1114da6c28aaSamw int 1115da6c28aaSamw smb_fsop_rename( 1116da6c28aaSamw struct smb_request *sr, 1117da6c28aaSamw cred_t *cr, 1118da6c28aaSamw smb_node_t *from_dir_snode, 1119da6c28aaSamw char *from_name, 1120da6c28aaSamw smb_node_t *to_dir_snode, 1121da6c28aaSamw char *to_name) 1122da6c28aaSamw { 1123da6c28aaSamw smb_node_t *from_snode; 1124da6c28aaSamw smb_attr_t tmp_attr; 1125da6c28aaSamw vnode_t *from_vp; 1126da6c28aaSamw int flags = 0; 1127da6c28aaSamw int rc; 1128da6c28aaSamw 1129da6c28aaSamw ASSERT(cr); 1130da6c28aaSamw ASSERT(from_dir_snode); 1131da6c28aaSamw ASSERT(from_dir_snode->n_magic == SMB_NODE_MAGIC); 1132da6c28aaSamw ASSERT(from_dir_snode->n_state != SMB_NODE_STATE_DESTROYING); 1133da6c28aaSamw 1134da6c28aaSamw ASSERT(to_dir_snode); 1135da6c28aaSamw ASSERT(to_dir_snode->n_magic == SMB_NODE_MAGIC); 1136da6c28aaSamw ASSERT(to_dir_snode->n_state != SMB_NODE_STATE_DESTROYING); 1137da6c28aaSamw 1138da6c28aaSamw if (SMB_TREE_ROOT_FS(sr, from_dir_snode) == 0) 1139da6c28aaSamw return (EACCES); 1140da6c28aaSamw 1141da6c28aaSamw if (SMB_TREE_ROOT_FS(sr, to_dir_snode) == 0) 1142da6c28aaSamw return (EACCES); 1143da6c28aaSamw 1144da6c28aaSamw ASSERT(sr); 1145da6c28aaSamw ASSERT(sr->tid_tree); 1146da6c28aaSamw if (SMB_TREE_IS_READ_ONLY(sr)) 1147da6c28aaSamw return (EROFS); 1148da6c28aaSamw 1149da6c28aaSamw /* 1150da6c28aaSamw * Note: There is no need to check SMB_TREE_CASE_INSENSITIVE(sr) 1151da6c28aaSamw * here. 1152da6c28aaSamw * 1153da6c28aaSamw * A case-sensitive rename is always done in this routine 1154da6c28aaSamw * because we are using the on-disk name from an earlier lookup. 1155da6c28aaSamw * If a mangled name was passed in by the caller (denoting a 1156da6c28aaSamw * deterministic lookup), then the exact file must be renamed 1157da6c28aaSamw * (i.e. SMB_IGNORE_CASE must not be passed to VOP_RENAME, or 1158da6c28aaSamw * else the underlying file system might return a "first-match" 1159da6c28aaSamw * on this on-disk name, possibly resulting in the wrong file). 1160da6c28aaSamw */ 1161da6c28aaSamw 1162da6c28aaSamw /* 1163da6c28aaSamw * XXX: Lock required through smb_node_release() below? 1164da6c28aaSamw */ 1165da6c28aaSamw 1166da6c28aaSamw rc = smb_vop_lookup(from_dir_snode->vp, from_name, &from_vp, NULL, 0, 1167*dc20a302Sas NULL, cr); 1168da6c28aaSamw 1169da6c28aaSamw if (rc != 0) 1170da6c28aaSamw return (rc); 1171da6c28aaSamw 1172da6c28aaSamw rc = smb_vop_rename(from_dir_snode->vp, from_name, to_dir_snode->vp, 1173*dc20a302Sas to_name, flags, cr); 1174da6c28aaSamw 1175da6c28aaSamw if (rc == 0) { 1176da6c28aaSamw from_snode = smb_node_lookup(sr, NULL, cr, from_vp, from_name, 1177da6c28aaSamw from_dir_snode, NULL, &tmp_attr); 1178da6c28aaSamw 1179da6c28aaSamw if (from_snode == NULL) { 1180da6c28aaSamw VN_RELE(from_vp); 1181da6c28aaSamw return (ENOMEM); 1182da6c28aaSamw } 1183da6c28aaSamw 1184da6c28aaSamw (void) smb_node_rename(from_dir_snode, from_snode, to_dir_snode, 1185da6c28aaSamw to_name); 1186da6c28aaSamw 1187da6c28aaSamw smb_node_release(from_snode); 1188da6c28aaSamw } else { 1189da6c28aaSamw VN_RELE(from_vp); 1190da6c28aaSamw } 1191da6c28aaSamw 1192da6c28aaSamw /* XXX: unlock */ 1193da6c28aaSamw 1194da6c28aaSamw return (rc); 1195da6c28aaSamw } 1196da6c28aaSamw 1197da6c28aaSamw /* 1198da6c28aaSamw * smb_fsop_setattr 1199da6c28aaSamw * 1200da6c28aaSamw * All SMB functions should use this wrapper to ensure that 1201da6c28aaSamw * the the calls are performed with the appropriate credentials. 1202da6c28aaSamw * Please document any direct call to explain the reason 1203da6c28aaSamw * for avoiding this wrapper. 1204da6c28aaSamw * 1205da6c28aaSamw * It is assumed that a reference exists on snode coming into this routine. 1206da6c28aaSamw * A null smb_request might be passed to this function. 1207da6c28aaSamw */ 1208da6c28aaSamw int 1209da6c28aaSamw smb_fsop_setattr( 1210da6c28aaSamw smb_request_t *sr, 1211da6c28aaSamw cred_t *cr, 1212da6c28aaSamw smb_node_t *snode, 1213da6c28aaSamw smb_attr_t *set_attr, 1214da6c28aaSamw smb_attr_t *ret_attr) 1215da6c28aaSamw { 1216da6c28aaSamw smb_node_t *unnamed_node; 1217da6c28aaSamw vnode_t *unnamed_vp = NULL; 1218da6c28aaSamw uint32_t status; 1219da6c28aaSamw uint32_t access = 0; 1220da6c28aaSamw int rc = 0; 1221da6c28aaSamw int flags = 0; 122255bf511dSas boolean_t no_xvattr = B_FALSE; 1223da6c28aaSamw 1224da6c28aaSamw ASSERT(cr); 1225da6c28aaSamw ASSERT(snode); 1226da6c28aaSamw ASSERT(snode->n_magic == SMB_NODE_MAGIC); 1227da6c28aaSamw ASSERT(snode->n_state != SMB_NODE_STATE_DESTROYING); 1228da6c28aaSamw 1229da6c28aaSamw if (SMB_TREE_ROOT_FS(sr, snode) == 0) 1230da6c28aaSamw return (EACCES); 1231da6c28aaSamw 1232da6c28aaSamw if (SMB_TREE_IS_READ_ONLY(sr)) 1233da6c28aaSamw return (EROFS); 1234da6c28aaSamw 1235da6c28aaSamw /* sr could be NULL in some cases */ 1236da6c28aaSamw if (sr && sr->fid_ofile) { 1237da6c28aaSamw /* if uid and/or gid is requested */ 1238da6c28aaSamw if (set_attr->sa_mask & (SMB_AT_UID|SMB_AT_GID)) 1239da6c28aaSamw access |= WRITE_OWNER; 1240da6c28aaSamw 1241da6c28aaSamw /* if anything else is also requested */ 1242da6c28aaSamw if (set_attr->sa_mask & ~(SMB_AT_UID|SMB_AT_GID)) 1243da6c28aaSamw access |= FILE_WRITE_ATTRIBUTES; 1244da6c28aaSamw 1245da6c28aaSamw status = smb_ofile_access(sr->fid_ofile, cr, access); 1246da6c28aaSamw if (status != NT_STATUS_SUCCESS) 1247da6c28aaSamw return (EACCES); 1248da6c28aaSamw 1249da6c28aaSamw if (sr->tid_tree->t_flags & SMB_TREE_FLAG_ACEMASKONACCESS) 1250da6c28aaSamw flags = ATTR_NOACLCHECK; 1251da6c28aaSamw } 1252da6c28aaSamw 1253da6c28aaSamw unnamed_node = SMB_IS_STREAM(snode); 1254da6c28aaSamw 1255da6c28aaSamw if (unnamed_node) { 1256da6c28aaSamw ASSERT(unnamed_node->n_magic == SMB_NODE_MAGIC); 1257da6c28aaSamw ASSERT(unnamed_node->n_state != SMB_NODE_STATE_DESTROYING); 1258da6c28aaSamw unnamed_vp = unnamed_node->vp; 1259da6c28aaSamw } 126055bf511dSas if (sr && sr->tid_tree) 126155bf511dSas if (sr->tid_tree->t_flags & SMB_TREE_FLAG_UFS) 126255bf511dSas no_xvattr = B_TRUE; 1263da6c28aaSamw 1264*dc20a302Sas rc = smb_vop_setattr(snode->vp, unnamed_vp, set_attr, flags, cr, 1265*dc20a302Sas no_xvattr); 1266da6c28aaSamw 1267da6c28aaSamw if ((rc == 0) && ret_attr) { 1268da6c28aaSamw /* 1269*dc20a302Sas * Use kcred to update the node attr because this 1270*dc20a302Sas * call is not being made on behalf of the user. 1271da6c28aaSamw */ 1272da6c28aaSamw ret_attr->sa_mask = SMB_AT_ALL; 1273*dc20a302Sas rc = smb_vop_getattr(snode->vp, unnamed_vp, ret_attr, 0, kcred); 1274*dc20a302Sas if (rc == 0) 1275*dc20a302Sas snode->attr = *ret_attr; 1276da6c28aaSamw } 1277da6c28aaSamw 1278da6c28aaSamw return (rc); 1279da6c28aaSamw } 1280da6c28aaSamw 1281da6c28aaSamw /* 1282da6c28aaSamw * smb_fsop_read 1283da6c28aaSamw * 1284da6c28aaSamw * All SMB functions should use this wrapper to ensure that 1285da6c28aaSamw * the the calls are performed with the appropriate credentials. 1286da6c28aaSamw * Please document any direct call to explain the reason 1287da6c28aaSamw * for avoiding this wrapper. 1288da6c28aaSamw * 1289da6c28aaSamw * It is assumed that a reference exists on snode coming into this routine. 1290da6c28aaSamw */ 1291da6c28aaSamw int 1292da6c28aaSamw smb_fsop_read( 1293da6c28aaSamw struct smb_request *sr, 1294da6c28aaSamw cred_t *cr, 1295da6c28aaSamw smb_node_t *snode, 1296da6c28aaSamw uio_t *uio, 1297da6c28aaSamw smb_attr_t *ret_attr) 1298da6c28aaSamw { 1299da6c28aaSamw smb_node_t *unnamed_node; 1300da6c28aaSamw vnode_t *unnamed_vp = NULL; 1301*dc20a302Sas int svmand; 1302da6c28aaSamw int rc; 1303da6c28aaSamw 1304da6c28aaSamw ASSERT(cr); 1305da6c28aaSamw ASSERT(snode); 1306da6c28aaSamw ASSERT(snode->n_magic == SMB_NODE_MAGIC); 1307da6c28aaSamw ASSERT(snode->n_state != SMB_NODE_STATE_DESTROYING); 1308da6c28aaSamw 1309da6c28aaSamw ASSERT(sr); 1310da6c28aaSamw ASSERT(sr->fid_ofile); 1311da6c28aaSamw 1312da6c28aaSamw rc = smb_ofile_access(sr->fid_ofile, cr, FILE_READ_DATA); 1313da6c28aaSamw if (rc != NT_STATUS_SUCCESS) { 1314da6c28aaSamw rc = smb_ofile_access(sr->fid_ofile, cr, FILE_EXECUTE); 1315da6c28aaSamw if (rc != NT_STATUS_SUCCESS) 1316da6c28aaSamw return (EACCES); 1317da6c28aaSamw } 1318da6c28aaSamw 1319da6c28aaSamw unnamed_node = SMB_IS_STREAM(snode); 1320da6c28aaSamw if (unnamed_node) { 1321da6c28aaSamw ASSERT(unnamed_node->n_magic == SMB_NODE_MAGIC); 1322da6c28aaSamw ASSERT(unnamed_node->n_state != SMB_NODE_STATE_DESTROYING); 1323da6c28aaSamw unnamed_vp = unnamed_node->vp; 1324da6c28aaSamw /* 1325da6c28aaSamw * Streams permission are checked against the unnamed stream, 1326da6c28aaSamw * but in FS level they have their own permissions. To avoid 1327da6c28aaSamw * rejection by FS due to lack of permission on the actual 1328da6c28aaSamw * extended attr kcred is passed for streams. 1329da6c28aaSamw */ 1330da6c28aaSamw cr = kcred; 1331da6c28aaSamw } 1332da6c28aaSamw 1333*dc20a302Sas smb_node_start_crit(snode, RW_READER); 1334*dc20a302Sas rc = nbl_svmand(snode->vp, cr, &svmand); 1335*dc20a302Sas if (rc) { 1336*dc20a302Sas smb_node_end_crit(snode); 1337*dc20a302Sas return (rc); 1338*dc20a302Sas } 1339*dc20a302Sas 1340*dc20a302Sas rc = nbl_lock_conflict(snode->vp, NBL_READ, uio->uio_loffset, 1341*dc20a302Sas uio->uio_iov->iov_len, svmand, &smb_ct); 1342da6c28aaSamw 1343*dc20a302Sas if (rc) { 1344*dc20a302Sas smb_node_end_crit(snode); 1345*dc20a302Sas return (rc); 1346*dc20a302Sas } 1347*dc20a302Sas rc = smb_vop_read(snode->vp, uio, cr); 1348*dc20a302Sas 1349*dc20a302Sas if (rc == 0 && ret_attr) { 1350da6c28aaSamw /* 1351*dc20a302Sas * Use kcred to update the node attr because this 1352*dc20a302Sas * call is not being made on behalf of the user. 1353da6c28aaSamw */ 1354da6c28aaSamw ret_attr->sa_mask = SMB_AT_ALL; 1355*dc20a302Sas if (smb_vop_getattr(snode->vp, unnamed_vp, ret_attr, 0, 1356*dc20a302Sas kcred) == 0) { 1357*dc20a302Sas snode->attr = *ret_attr; 1358*dc20a302Sas } 1359da6c28aaSamw } 1360da6c28aaSamw 1361*dc20a302Sas smb_node_end_crit(snode); 1362*dc20a302Sas 1363da6c28aaSamw return (rc); 1364da6c28aaSamw } 1365da6c28aaSamw 1366da6c28aaSamw /* 1367da6c28aaSamw * smb_fsop_write 1368da6c28aaSamw * 1369da6c28aaSamw * This is a wrapper function used for smb_write and smb_write_raw operations. 1370da6c28aaSamw * 1371da6c28aaSamw * It is assumed that a reference exists on snode coming into this routine. 1372da6c28aaSamw */ 1373da6c28aaSamw int 1374da6c28aaSamw smb_fsop_write( 1375da6c28aaSamw struct smb_request *sr, 1376da6c28aaSamw cred_t *cr, 1377da6c28aaSamw smb_node_t *snode, 1378da6c28aaSamw uio_t *uio, 1379da6c28aaSamw uint32_t *lcount, 1380da6c28aaSamw smb_attr_t *ret_attr, 1381da6c28aaSamw uint32_t *flag) 1382da6c28aaSamw { 1383da6c28aaSamw smb_node_t *unnamed_node; 1384da6c28aaSamw vnode_t *unnamed_vp = NULL; 1385*dc20a302Sas int svmand; 1386da6c28aaSamw int rc; 1387da6c28aaSamw 1388da6c28aaSamw ASSERT(cr); 1389da6c28aaSamw ASSERT(snode); 1390da6c28aaSamw ASSERT(snode->n_magic == SMB_NODE_MAGIC); 1391da6c28aaSamw ASSERT(snode->n_state != SMB_NODE_STATE_DESTROYING); 1392da6c28aaSamw 1393da6c28aaSamw ASSERT(sr); 1394da6c28aaSamw ASSERT(sr->tid_tree); 1395da6c28aaSamw ASSERT(sr->fid_ofile); 1396da6c28aaSamw 1397da6c28aaSamw if (SMB_TREE_IS_READ_ONLY(sr)) 1398da6c28aaSamw return (EROFS); 1399da6c28aaSamw 1400*dc20a302Sas rc = smb_ofile_access(sr->fid_ofile, cr, FILE_WRITE_DATA); 1401*dc20a302Sas if (rc != NT_STATUS_SUCCESS) { 1402*dc20a302Sas rc = smb_ofile_access(sr->fid_ofile, cr, FILE_APPEND_DATA); 1403*dc20a302Sas if (rc != NT_STATUS_SUCCESS) 1404*dc20a302Sas return (EACCES); 1405*dc20a302Sas } 1406da6c28aaSamw 1407da6c28aaSamw unnamed_node = SMB_IS_STREAM(snode); 1408da6c28aaSamw 1409da6c28aaSamw if (unnamed_node) { 1410da6c28aaSamw ASSERT(unnamed_node->n_magic == SMB_NODE_MAGIC); 1411da6c28aaSamw ASSERT(unnamed_node->n_state != SMB_NODE_STATE_DESTROYING); 1412da6c28aaSamw unnamed_vp = unnamed_node->vp; 1413da6c28aaSamw /* 1414da6c28aaSamw * Streams permission are checked against the unnamed stream, 1415da6c28aaSamw * but in FS level they have their own permissions. To avoid 1416da6c28aaSamw * rejection by FS due to lack of permission on the actual 1417da6c28aaSamw * extended attr kcred is passed for streams. 1418da6c28aaSamw */ 1419da6c28aaSamw cr = kcred; 1420da6c28aaSamw } 1421da6c28aaSamw 1422*dc20a302Sas smb_node_start_crit(snode, RW_READER); 1423*dc20a302Sas rc = nbl_svmand(snode->vp, cr, &svmand); 1424*dc20a302Sas if (rc) { 1425*dc20a302Sas smb_node_end_crit(snode); 1426*dc20a302Sas return (rc); 1427*dc20a302Sas } 1428*dc20a302Sas rc = nbl_lock_conflict(snode->vp, NBL_WRITE, uio->uio_loffset, 1429*dc20a302Sas uio->uio_iov->iov_len, svmand, &smb_ct); 1430da6c28aaSamw 1431*dc20a302Sas if (rc) { 1432*dc20a302Sas smb_node_end_crit(snode); 1433*dc20a302Sas return (rc); 1434*dc20a302Sas } 1435*dc20a302Sas rc = smb_vop_write(snode->vp, uio, flag, lcount, cr); 1436*dc20a302Sas 1437*dc20a302Sas if (rc == 0 && ret_attr) { 1438da6c28aaSamw /* 1439*dc20a302Sas * Use kcred to update the node attr because this 1440*dc20a302Sas * call is not being made on behalf of the user. 1441da6c28aaSamw */ 1442da6c28aaSamw ret_attr->sa_mask = SMB_AT_ALL; 1443*dc20a302Sas if (smb_vop_getattr(snode->vp, unnamed_vp, ret_attr, 0, 1444*dc20a302Sas kcred) == 0) { 1445*dc20a302Sas snode->attr = *ret_attr; 1446*dc20a302Sas } 1447da6c28aaSamw } 1448da6c28aaSamw 1449*dc20a302Sas smb_node_end_crit(snode); 1450*dc20a302Sas 1451da6c28aaSamw return (rc); 1452da6c28aaSamw } 1453da6c28aaSamw 1454da6c28aaSamw /* 1455da6c28aaSamw * smb_fsop_statfs 1456da6c28aaSamw * 1457da6c28aaSamw * This is a wrapper function used for stat operations. 1458da6c28aaSamw */ 1459da6c28aaSamw int 1460da6c28aaSamw smb_fsop_statfs( 1461da6c28aaSamw cred_t *cr, 1462da6c28aaSamw smb_node_t *snode, 1463da6c28aaSamw struct statvfs64 *statp) 1464da6c28aaSamw { 1465da6c28aaSamw ASSERT(cr); 1466da6c28aaSamw ASSERT(snode); 1467da6c28aaSamw ASSERT(snode->n_magic == SMB_NODE_MAGIC); 1468da6c28aaSamw ASSERT(snode->n_state != SMB_NODE_STATE_DESTROYING); 1469da6c28aaSamw 1470da6c28aaSamw return (smb_vop_statfs(snode->vp, statp, cr)); 1471da6c28aaSamw } 1472da6c28aaSamw 1473da6c28aaSamw /* 1474da6c28aaSamw * smb_fsop_access 1475da6c28aaSamw */ 1476da6c28aaSamw int 1477da6c28aaSamw smb_fsop_access(smb_request_t *sr, cred_t *cr, smb_node_t *snode, 1478da6c28aaSamw uint32_t faccess) 1479da6c28aaSamw { 1480da6c28aaSamw int access = 0; 1481da6c28aaSamw int error; 1482da6c28aaSamw vnode_t *dir_vp; 1483da6c28aaSamw boolean_t acl_check = B_TRUE; 1484da6c28aaSamw smb_node_t *unnamed_node; 1485da6c28aaSamw 1486da6c28aaSamw ASSERT(cr); 1487da6c28aaSamw ASSERT(snode); 1488da6c28aaSamw ASSERT(snode->n_magic == SMB_NODE_MAGIC); 1489da6c28aaSamw ASSERT(snode->n_state != SMB_NODE_STATE_DESTROYING); 1490da6c28aaSamw 1491da6c28aaSamw if (faccess == 0) 1492da6c28aaSamw return (NT_STATUS_SUCCESS); 1493da6c28aaSamw 1494da6c28aaSamw if (SMB_TREE_IS_READ_ONLY(sr)) { 1495da6c28aaSamw if (faccess & (FILE_WRITE_DATA|FILE_APPEND_DATA| 1496da6c28aaSamw FILE_WRITE_EA|FILE_DELETE_CHILD|FILE_WRITE_ATTRIBUTES| 1497da6c28aaSamw DELETE|WRITE_DAC|WRITE_OWNER)) { 1498da6c28aaSamw return (NT_STATUS_ACCESS_DENIED); 1499da6c28aaSamw } 1500da6c28aaSamw } 1501da6c28aaSamw 1502da6c28aaSamw unnamed_node = SMB_IS_STREAM(snode); 1503da6c28aaSamw if (unnamed_node) { 1504da6c28aaSamw ASSERT(unnamed_node->n_magic == SMB_NODE_MAGIC); 1505da6c28aaSamw ASSERT(unnamed_node->n_state != SMB_NODE_STATE_DESTROYING); 1506da6c28aaSamw /* 1507da6c28aaSamw * Streams authorization should be performed against the 1508da6c28aaSamw * unnamed stream. 1509da6c28aaSamw */ 1510da6c28aaSamw snode = unnamed_node; 1511da6c28aaSamw } 1512da6c28aaSamw 1513da6c28aaSamw if (faccess & ACCESS_SYSTEM_SECURITY) { 1514da6c28aaSamw /* 1515da6c28aaSamw * This permission is required for reading/writing SACL and 1516da6c28aaSamw * it's not part of DACL. It's only granted via proper 1517da6c28aaSamw * privileges. 1518da6c28aaSamw */ 1519da6c28aaSamw if ((sr->uid_user->u_privileges & 1520da6c28aaSamw (SMB_USER_PRIV_BACKUP | 1521da6c28aaSamw SMB_USER_PRIV_RESTORE | 1522da6c28aaSamw SMB_USER_PRIV_SECURITY)) == 0) 1523da6c28aaSamw return (NT_STATUS_PRIVILEGE_NOT_HELD); 1524da6c28aaSamw 1525da6c28aaSamw faccess &= ~ACCESS_SYSTEM_SECURITY; 1526da6c28aaSamw } 1527da6c28aaSamw 1528da6c28aaSamw /* Links don't have ACL */ 1529da6c28aaSamw if (((sr->tid_tree->t_flags & SMB_TREE_FLAG_ACEMASKONACCESS) == 0) || 1530da6c28aaSamw (snode->attr.sa_vattr.va_type == VLNK)) 1531da6c28aaSamw acl_check = B_FALSE; 1532da6c28aaSamw 1533da6c28aaSamw if (acl_check) { 1534da6c28aaSamw dir_vp = (snode->dir_snode) ? snode->dir_snode->vp : NULL; 1535da6c28aaSamw error = smb_vop_access(snode->vp, faccess, V_ACE_MASK, dir_vp, 1536da6c28aaSamw cr); 1537da6c28aaSamw } else { 1538da6c28aaSamw /* 1539da6c28aaSamw * FS doesn't understand 32-bit mask, need to map 1540da6c28aaSamw */ 1541da6c28aaSamw if (faccess & (FILE_WRITE_DATA | FILE_APPEND_DATA)) 1542da6c28aaSamw access |= VWRITE; 1543da6c28aaSamw 1544da6c28aaSamw if (faccess & FILE_READ_DATA) 1545da6c28aaSamw access |= VREAD; 1546da6c28aaSamw 1547da6c28aaSamw if (faccess & FILE_EXECUTE) 1548da6c28aaSamw access |= VEXEC; 1549da6c28aaSamw 1550da6c28aaSamw error = smb_vop_access(snode->vp, access, 0, NULL, cr); 1551da6c28aaSamw } 1552da6c28aaSamw 1553da6c28aaSamw return ((error) ? NT_STATUS_ACCESS_DENIED : NT_STATUS_SUCCESS); 1554da6c28aaSamw } 1555da6c28aaSamw 1556da6c28aaSamw /* 1557da6c28aaSamw * smb_fsop_lookup_name() 1558da6c28aaSamw * 1559da6c28aaSamw * Sanity checks on dir_snode done in smb_fsop_lookup(). 1560da6c28aaSamw * 1561da6c28aaSamw * Note: This function is called only from the open path. 1562da6c28aaSamw * It will check if the file is a stream. 1563da6c28aaSamw * It will also return an error if the looked-up file is in 1564da6c28aaSamw * a child mount. 1565da6c28aaSamw */ 1566da6c28aaSamw 1567da6c28aaSamw int 1568da6c28aaSamw smb_fsop_lookup_name( 1569da6c28aaSamw struct smb_request *sr, 1570da6c28aaSamw cred_t *cr, 1571da6c28aaSamw int flags, 1572da6c28aaSamw smb_node_t *root_node, 1573da6c28aaSamw smb_node_t *dir_snode, 1574da6c28aaSamw char *name, 1575da6c28aaSamw smb_node_t **ret_snode, 1576da6c28aaSamw smb_attr_t *ret_attr) 1577da6c28aaSamw { 1578da6c28aaSamw smb_node_t *fnode; 1579da6c28aaSamw smb_attr_t file_attr; 1580da6c28aaSamw vnode_t *xattrdirvp; 1581da6c28aaSamw vnode_t *vp; 1582da6c28aaSamw char *od_name; 1583da6c28aaSamw char *fname; 1584da6c28aaSamw char *sname; 1585da6c28aaSamw int rc; 1586da6c28aaSamw 1587da6c28aaSamw ASSERT(cr); 1588da6c28aaSamw ASSERT(dir_snode); 1589da6c28aaSamw ASSERT(dir_snode->n_magic == SMB_NODE_MAGIC); 1590da6c28aaSamw ASSERT(dir_snode->n_state != SMB_NODE_STATE_DESTROYING); 1591da6c28aaSamw 1592da6c28aaSamw /* 1593da6c28aaSamw * The following check is required for streams processing, below 1594da6c28aaSamw */ 1595da6c28aaSamw 1596da6c28aaSamw if (SMB_TREE_CASE_INSENSITIVE(sr)) 1597da6c28aaSamw flags |= SMB_IGNORE_CASE; 1598da6c28aaSamw 1599da6c28aaSamw fname = kmem_alloc(MAXNAMELEN, KM_SLEEP); 1600da6c28aaSamw sname = kmem_alloc(MAXNAMELEN, KM_SLEEP); 1601da6c28aaSamw 1602da6c28aaSamw if (smb_stream_parse_name(name, fname, sname)) { 1603da6c28aaSamw /* 1604da6c28aaSamw * Look up the unnamed stream (i.e. fname). 1605da6c28aaSamw * Unmangle processing will be done on fname 1606da6c28aaSamw * as well as any link target. 1607da6c28aaSamw */ 1608da6c28aaSamw rc = smb_fsop_lookup(sr, cr, flags, root_node, dir_snode, fname, 1609da6c28aaSamw &fnode, &file_attr, NULL, NULL); 1610da6c28aaSamw 1611da6c28aaSamw if (rc != 0) { 1612da6c28aaSamw kmem_free(fname, MAXNAMELEN); 1613da6c28aaSamw kmem_free(sname, MAXNAMELEN); 1614da6c28aaSamw return (rc); 1615da6c28aaSamw } 1616da6c28aaSamw 1617da6c28aaSamw od_name = kmem_alloc(MAXNAMELEN, KM_SLEEP); 1618da6c28aaSamw 1619da6c28aaSamw /* 1620da6c28aaSamw * od_name is the on-disk name of the stream, except 1621da6c28aaSamw * without the prepended stream prefix (SMB_STREAM_PREFIX) 1622da6c28aaSamw */ 1623da6c28aaSamw 1624da6c28aaSamw /* 1625da6c28aaSamw * XXX 1626da6c28aaSamw * What permissions NTFS requires for stream lookup if any? 1627da6c28aaSamw */ 1628da6c28aaSamw rc = smb_vop_stream_lookup(fnode->vp, sname, &vp, od_name, 1629*dc20a302Sas &xattrdirvp, flags, root_node->vp, cr); 1630da6c28aaSamw 1631da6c28aaSamw if (rc != 0) { 1632da6c28aaSamw smb_node_release(fnode); 1633da6c28aaSamw kmem_free(fname, MAXNAMELEN); 1634da6c28aaSamw kmem_free(sname, MAXNAMELEN); 1635da6c28aaSamw kmem_free(od_name, MAXNAMELEN); 1636da6c28aaSamw return (rc); 1637da6c28aaSamw } 1638da6c28aaSamw 1639da6c28aaSamw *ret_snode = smb_stream_node_lookup(sr, cr, fnode, xattrdirvp, 1640da6c28aaSamw vp, od_name, ret_attr); 1641da6c28aaSamw 1642da6c28aaSamw kmem_free(od_name, MAXNAMELEN); 1643da6c28aaSamw smb_node_release(fnode); 1644da6c28aaSamw 1645da6c28aaSamw if (*ret_snode == NULL) { 1646da6c28aaSamw VN_RELE(xattrdirvp); 1647da6c28aaSamw VN_RELE(vp); 1648da6c28aaSamw kmem_free(fname, MAXNAMELEN); 1649da6c28aaSamw kmem_free(sname, MAXNAMELEN); 1650da6c28aaSamw return (ENOMEM); 1651da6c28aaSamw } 1652da6c28aaSamw } else { 1653da6c28aaSamw rc = smb_fsop_lookup(sr, cr, flags, root_node, dir_snode, name, 1654da6c28aaSamw ret_snode, ret_attr, NULL, NULL); 1655da6c28aaSamw } 1656da6c28aaSamw 1657da6c28aaSamw if (rc == 0) { 1658da6c28aaSamw ASSERT(ret_snode); 1659da6c28aaSamw if (SMB_TREE_ROOT_FS(sr, *ret_snode) == 0) { 1660da6c28aaSamw smb_node_release(*ret_snode); 1661da6c28aaSamw *ret_snode = NULL; 1662da6c28aaSamw rc = EACCES; 1663da6c28aaSamw } 1664da6c28aaSamw } 1665da6c28aaSamw 1666da6c28aaSamw kmem_free(fname, MAXNAMELEN); 1667da6c28aaSamw kmem_free(sname, MAXNAMELEN); 1668da6c28aaSamw 1669da6c28aaSamw return (rc); 1670da6c28aaSamw } 1671da6c28aaSamw 1672da6c28aaSamw /* 1673da6c28aaSamw * smb_fsop_lookup 1674da6c28aaSamw * 1675da6c28aaSamw * All SMB functions should use this smb_vop_lookup wrapper to ensure that 1676da6c28aaSamw * the smb_vop_lookup is performed with the appropriate credentials and using 1677da6c28aaSamw * case insensitive compares. Please document any direct call to smb_vop_lookup 1678da6c28aaSamw * to explain the reason for avoiding this wrapper. 1679da6c28aaSamw * 1680da6c28aaSamw * It is assumed that a reference exists on dir_snode coming into this routine 1681da6c28aaSamw * (and that it is safe from deallocation). 1682da6c28aaSamw * 1683da6c28aaSamw * Same with the root_node. 1684da6c28aaSamw * 1685da6c28aaSamw * *ret_snode is returned with a reference upon success. No reference is 1686da6c28aaSamw * taken if an error is returned. 1687da6c28aaSamw * 1688da6c28aaSamw * Note: The returned ret_snode may be in a child mount. This is ok for 1689da6c28aaSamw * readdir and getdents. 1690da6c28aaSamw * 1691da6c28aaSamw * Other smb_fsop_* routines will call SMB_TREE_ROOT_FS() to prevent 1692da6c28aaSamw * operations on files not in the parent mount. 1693da6c28aaSamw */ 1694da6c28aaSamw int 1695da6c28aaSamw smb_fsop_lookup( 1696da6c28aaSamw struct smb_request *sr, 1697da6c28aaSamw cred_t *cr, 1698da6c28aaSamw int flags, 1699da6c28aaSamw smb_node_t *root_node, 1700da6c28aaSamw smb_node_t *dir_snode, 1701da6c28aaSamw char *name, 1702da6c28aaSamw smb_node_t **ret_snode, 1703da6c28aaSamw smb_attr_t *ret_attr, 1704da6c28aaSamw char *ret_shortname, /* Must be at least MANGLE_NAMELEN chars */ 1705da6c28aaSamw char *ret_name83) /* Must be at least MANGLE_NAMELEN chars */ 1706da6c28aaSamw { 1707da6c28aaSamw smb_node_t *lnk_target_node; 1708da6c28aaSamw smb_node_t *lnk_dnode; 1709da6c28aaSamw char *longname; 1710da6c28aaSamw char *od_name; 1711da6c28aaSamw vnode_t *vp; 1712da6c28aaSamw int rc; 1713da6c28aaSamw 1714da6c28aaSamw ASSERT(cr); 1715da6c28aaSamw ASSERT(dir_snode); 1716da6c28aaSamw ASSERT(dir_snode->n_magic == SMB_NODE_MAGIC); 1717da6c28aaSamw ASSERT(dir_snode->n_state != SMB_NODE_STATE_DESTROYING); 1718da6c28aaSamw 1719da6c28aaSamw if (name == NULL) 1720da6c28aaSamw return (EINVAL); 1721da6c28aaSamw 1722da6c28aaSamw if (SMB_TREE_ROOT_FS(sr, dir_snode) == 0) 1723da6c28aaSamw return (EACCES); 1724da6c28aaSamw 1725da6c28aaSamw if (SMB_TREE_CASE_INSENSITIVE(sr)) 1726da6c28aaSamw flags |= SMB_IGNORE_CASE; 1727da6c28aaSamw 1728da6c28aaSamw od_name = kmem_alloc(MAXNAMELEN, KM_SLEEP); 1729da6c28aaSamw 1730da6c28aaSamw rc = smb_vop_lookup(dir_snode->vp, name, &vp, od_name, flags, 1731*dc20a302Sas root_node ? root_node->vp : NULL, cr); 1732da6c28aaSamw 1733da6c28aaSamw if (rc != 0) { 1734da6c28aaSamw if (smb_maybe_mangled_name(name) == 0) { 1735da6c28aaSamw kmem_free(od_name, MAXNAMELEN); 1736da6c28aaSamw return (rc); 1737da6c28aaSamw } 1738da6c28aaSamw 1739da6c28aaSamw longname = kmem_alloc(MAXNAMELEN, KM_SLEEP); 1740da6c28aaSamw 1741da6c28aaSamw rc = smb_unmangle_name(sr, cr, dir_snode, name, longname, 1742da6c28aaSamw MAXNAMELEN, ret_shortname, ret_name83, 1); 1743da6c28aaSamw 1744da6c28aaSamw if (rc != 0) { 1745da6c28aaSamw kmem_free(od_name, MAXNAMELEN); 1746da6c28aaSamw kmem_free(longname, MAXNAMELEN); 1747da6c28aaSamw return (rc); 1748da6c28aaSamw } 1749da6c28aaSamw 1750da6c28aaSamw /* 1751da6c28aaSamw * We passed "1" as the "od" parameter 1752da6c28aaSamw * to smb_unmangle_name(), such that longname 1753da6c28aaSamw * is the real (case-sensitive) on-disk name. 1754da6c28aaSamw * We make sure we do a lookup on this exact 1755da6c28aaSamw * name, as the name was mangled and denotes 1756da6c28aaSamw * a unique file. 1757da6c28aaSamw */ 1758da6c28aaSamw 1759da6c28aaSamw if (flags & SMB_IGNORE_CASE) 1760da6c28aaSamw flags &= ~SMB_IGNORE_CASE; 1761da6c28aaSamw 1762da6c28aaSamw rc = smb_vop_lookup(dir_snode->vp, longname, &vp, od_name, 1763*dc20a302Sas flags, root_node ? root_node->vp : NULL, cr); 1764da6c28aaSamw 1765da6c28aaSamw kmem_free(longname, MAXNAMELEN); 1766da6c28aaSamw 1767da6c28aaSamw if (rc != 0) { 1768da6c28aaSamw kmem_free(od_name, MAXNAMELEN); 1769da6c28aaSamw return (rc); 1770da6c28aaSamw } 1771da6c28aaSamw } 1772da6c28aaSamw 1773da6c28aaSamw if ((flags & SMB_FOLLOW_LINKS) && (vp->v_type == VLNK)) { 1774da6c28aaSamw 1775da6c28aaSamw rc = smb_pathname(sr, od_name, FOLLOW, root_node, dir_snode, 1776da6c28aaSamw &lnk_dnode, &lnk_target_node, cr); 1777da6c28aaSamw 1778da6c28aaSamw if (rc != 0) { 1779da6c28aaSamw /* 1780da6c28aaSamw * The link is assumed to be for the last component 1781da6c28aaSamw * of a path. Hence any ENOTDIR error will be returned 1782da6c28aaSamw * as ENOENT. 1783da6c28aaSamw */ 1784da6c28aaSamw if (rc == ENOTDIR) 1785da6c28aaSamw rc = ENOENT; 1786da6c28aaSamw 1787da6c28aaSamw VN_RELE(vp); 1788da6c28aaSamw kmem_free(od_name, MAXNAMELEN); 1789da6c28aaSamw return (rc); 1790da6c28aaSamw } 1791da6c28aaSamw 1792da6c28aaSamw /* 1793da6c28aaSamw * Release the original VLNK vnode 1794da6c28aaSamw */ 1795da6c28aaSamw 1796da6c28aaSamw VN_RELE(vp); 1797da6c28aaSamw vp = lnk_target_node->vp; 1798da6c28aaSamw 1799da6c28aaSamw rc = smb_vop_traverse_check(&vp); 1800da6c28aaSamw 1801da6c28aaSamw if (rc != 0) { 1802da6c28aaSamw smb_node_release(lnk_dnode); 1803da6c28aaSamw smb_node_release(lnk_target_node); 1804da6c28aaSamw kmem_free(od_name, MAXNAMELEN); 1805da6c28aaSamw return (rc); 1806da6c28aaSamw } 1807da6c28aaSamw 1808da6c28aaSamw /* 1809da6c28aaSamw * smb_vop_traverse_check() may have returned a different vnode 1810da6c28aaSamw */ 1811da6c28aaSamw 1812da6c28aaSamw if (lnk_target_node->vp == vp) { 1813da6c28aaSamw *ret_snode = lnk_target_node; 1814da6c28aaSamw *ret_attr = (*ret_snode)->attr; 1815da6c28aaSamw } else { 1816da6c28aaSamw *ret_snode = smb_node_lookup(sr, NULL, cr, vp, 1817da6c28aaSamw lnk_target_node->od_name, lnk_dnode, NULL, 1818da6c28aaSamw ret_attr); 1819da6c28aaSamw 1820da6c28aaSamw if (*ret_snode == NULL) { 1821da6c28aaSamw VN_RELE(vp); 1822da6c28aaSamw rc = ENOMEM; 1823da6c28aaSamw } 1824da6c28aaSamw smb_node_release(lnk_target_node); 1825da6c28aaSamw } 1826da6c28aaSamw 1827da6c28aaSamw smb_node_release(lnk_dnode); 1828da6c28aaSamw 1829da6c28aaSamw } else { 1830da6c28aaSamw 1831da6c28aaSamw rc = smb_vop_traverse_check(&vp); 1832da6c28aaSamw if (rc) { 1833da6c28aaSamw VN_RELE(vp); 1834da6c28aaSamw kmem_free(od_name, MAXNAMELEN); 1835da6c28aaSamw return (rc); 1836da6c28aaSamw } 1837da6c28aaSamw 1838da6c28aaSamw *ret_snode = smb_node_lookup(sr, NULL, cr, vp, od_name, 1839da6c28aaSamw dir_snode, NULL, ret_attr); 1840da6c28aaSamw 1841da6c28aaSamw if (*ret_snode == NULL) { 1842da6c28aaSamw VN_RELE(vp); 1843da6c28aaSamw rc = ENOMEM; 1844da6c28aaSamw } 1845da6c28aaSamw } 1846da6c28aaSamw 1847da6c28aaSamw kmem_free(od_name, MAXNAMELEN); 1848da6c28aaSamw return (rc); 1849da6c28aaSamw } 1850da6c28aaSamw 1851da6c28aaSamw /* 1852da6c28aaSamw * smb_fsop_stream_readdir() 1853da6c28aaSamw * 1854da6c28aaSamw * ret_snode and ret_attr are optional parameters (i.e. NULL may be passed in) 1855da6c28aaSamw * 1856da6c28aaSamw * This routine will return only NTFS streams. If an NTFS stream is not 1857da6c28aaSamw * found at the offset specified, the directory will be read until an NTFS 1858da6c28aaSamw * stream is found or until EOF. 1859da6c28aaSamw * 1860da6c28aaSamw * Note: Sanity checks done in caller 1861da6c28aaSamw * (smb_fsop_readdir(), smb_fsop_remove_streams()) 1862da6c28aaSamw */ 1863da6c28aaSamw 1864da6c28aaSamw int 1865da6c28aaSamw smb_fsop_stream_readdir(struct smb_request *sr, cred_t *cr, smb_node_t *fnode, 1866da6c28aaSamw uint32_t *cookiep, struct fs_stream_info *stream_info, 1867da6c28aaSamw smb_node_t **ret_snode, smb_attr_t *ret_attr) 1868da6c28aaSamw { 1869da6c28aaSamw smb_node_t *ret_snodep = NULL; 1870da6c28aaSamw smb_attr_t tmp_attr; 1871da6c28aaSamw vnode_t *xattrdirvp; 1872da6c28aaSamw vnode_t *vp; 1873da6c28aaSamw int rc = 0; 1874da6c28aaSamw int flags = 0; 1875da6c28aaSamw 1876da6c28aaSamw /* 1877da6c28aaSamw * XXX NTFS permission requirements if any? 1878da6c28aaSamw */ 1879da6c28aaSamw ASSERT(cr); 1880da6c28aaSamw ASSERT(fnode); 1881da6c28aaSamw ASSERT(fnode->n_magic == SMB_NODE_MAGIC); 1882da6c28aaSamw ASSERT(fnode->n_state != SMB_NODE_STATE_DESTROYING); 1883da6c28aaSamw 1884da6c28aaSamw if (SMB_TREE_CASE_INSENSITIVE(sr)) 1885da6c28aaSamw flags = SMB_IGNORE_CASE; 1886da6c28aaSamw 1887da6c28aaSamw rc = smb_vop_stream_readdir(fnode->vp, cookiep, stream_info, &vp, 1888*dc20a302Sas &xattrdirvp, flags, cr); 1889da6c28aaSamw 1890da6c28aaSamw if ((rc != 0) || *cookiep == SMB_EOF) 1891da6c28aaSamw return (rc); 1892da6c28aaSamw 1893da6c28aaSamw ret_snodep = smb_stream_node_lookup(sr, cr, fnode, xattrdirvp, vp, 1894da6c28aaSamw stream_info->name, &tmp_attr); 1895da6c28aaSamw 1896da6c28aaSamw if (ret_snodep == NULL) { 1897da6c28aaSamw VN_RELE(xattrdirvp); 1898da6c28aaSamw VN_RELE(vp); 1899da6c28aaSamw return (ENOMEM); 1900da6c28aaSamw } 1901da6c28aaSamw 1902da6c28aaSamw stream_info->size = tmp_attr.sa_vattr.va_size; 1903da6c28aaSamw 1904da6c28aaSamw if (ret_attr) 1905da6c28aaSamw *ret_attr = tmp_attr; 1906da6c28aaSamw 1907da6c28aaSamw if (ret_snode) 1908da6c28aaSamw *ret_snode = ret_snodep; 1909da6c28aaSamw else 1910da6c28aaSamw smb_node_release(ret_snodep); 1911da6c28aaSamw 1912da6c28aaSamw return (rc); 1913da6c28aaSamw } 1914da6c28aaSamw 1915da6c28aaSamw int /*ARGSUSED*/ 1916da6c28aaSamw smb_fsop_commit(smb_request_t *sr, cred_t *cr, smb_node_t *snode) 1917da6c28aaSamw { 1918da6c28aaSamw ASSERT(cr); 1919da6c28aaSamw ASSERT(snode); 1920da6c28aaSamw ASSERT(snode->n_magic == SMB_NODE_MAGIC); 1921da6c28aaSamw ASSERT(snode->n_state != SMB_NODE_STATE_DESTROYING); 1922da6c28aaSamw 1923da6c28aaSamw ASSERT(sr); 1924da6c28aaSamw ASSERT(sr->tid_tree); 1925da6c28aaSamw if (SMB_TREE_IS_READ_ONLY(sr)) 1926da6c28aaSamw return (EROFS); 1927da6c28aaSamw 1928*dc20a302Sas return (smb_vop_commit(snode->vp, cr)); 1929da6c28aaSamw } 1930da6c28aaSamw 1931da6c28aaSamw /* 1932da6c28aaSamw * smb_fsop_aclread 1933da6c28aaSamw * 1934da6c28aaSamw * Retrieve filesystem ACL. Depends on requested ACLs in 1935da6c28aaSamw * fs_sd->sd_secinfo, it'll set DACL and SACL pointers in 1936da6c28aaSamw * fs_sd. Note that requesting a DACL/SACL doesn't mean that 1937da6c28aaSamw * the corresponding field in fs_sd should be non-NULL upon 1938da6c28aaSamw * return, since the target ACL might not contain that type of 1939da6c28aaSamw * entries. 1940da6c28aaSamw * 1941da6c28aaSamw * Returned ACL is always in ACE_T (aka ZFS) format. 1942da6c28aaSamw * If successful the allocated memory for the ACL should be freed 194355bf511dSas * using smb_fsacl_free() or smb_fssd_term() 1944da6c28aaSamw */ 1945da6c28aaSamw int 1946da6c28aaSamw smb_fsop_aclread(smb_request_t *sr, cred_t *cr, smb_node_t *snode, 1947da6c28aaSamw smb_fssd_t *fs_sd) 1948da6c28aaSamw { 1949da6c28aaSamw int error = 0; 1950da6c28aaSamw int flags = 0; 1951da6c28aaSamw int access = 0; 1952da6c28aaSamw acl_t *acl; 1953da6c28aaSamw smb_node_t *unnamed_node; 1954da6c28aaSamw 1955da6c28aaSamw ASSERT(cr); 1956da6c28aaSamw 1957da6c28aaSamw if (sr->fid_ofile) { 1958da6c28aaSamw if (fs_sd->sd_secinfo & SMB_DACL_SECINFO) 1959da6c28aaSamw access = READ_CONTROL; 1960da6c28aaSamw 1961da6c28aaSamw if (fs_sd->sd_secinfo & SMB_SACL_SECINFO) 1962da6c28aaSamw access |= ACCESS_SYSTEM_SECURITY; 1963da6c28aaSamw 1964da6c28aaSamw error = smb_ofile_access(sr->fid_ofile, cr, access); 1965da6c28aaSamw if (error != NT_STATUS_SUCCESS) { 1966da6c28aaSamw return (EACCES); 1967da6c28aaSamw } 1968da6c28aaSamw } 1969da6c28aaSamw 1970da6c28aaSamw unnamed_node = SMB_IS_STREAM(snode); 1971da6c28aaSamw if (unnamed_node) { 1972da6c28aaSamw ASSERT(unnamed_node->n_magic == SMB_NODE_MAGIC); 1973da6c28aaSamw ASSERT(unnamed_node->n_state != SMB_NODE_STATE_DESTROYING); 1974da6c28aaSamw /* 1975da6c28aaSamw * Streams don't have ACL, any read ACL attempt on a stream 1976da6c28aaSamw * should be performed on the unnamed stream. 1977da6c28aaSamw */ 1978da6c28aaSamw snode = unnamed_node; 1979da6c28aaSamw } 1980da6c28aaSamw 1981da6c28aaSamw if (sr->tid_tree->t_flags & SMB_TREE_FLAG_ACEMASKONACCESS) 1982da6c28aaSamw flags = ATTR_NOACLCHECK; 1983da6c28aaSamw 1984da6c28aaSamw error = smb_vop_acl_read(snode->vp, &acl, flags, 1985*dc20a302Sas sr->tid_tree->t_acltype, cr); 1986da6c28aaSamw if (error != 0) { 1987da6c28aaSamw return (error); 1988da6c28aaSamw } 1989da6c28aaSamw 1990da6c28aaSamw error = acl_translate(acl, _ACL_ACE_ENABLED, 1991da6c28aaSamw (snode->vp->v_type == VDIR), fs_sd->sd_uid, fs_sd->sd_gid); 1992da6c28aaSamw 1993da6c28aaSamw if (error == 0) { 199455bf511dSas smb_fsacl_split(acl, &fs_sd->sd_zdacl, &fs_sd->sd_zsacl, 1995da6c28aaSamw fs_sd->sd_secinfo); 1996da6c28aaSamw } 1997da6c28aaSamw 1998da6c28aaSamw acl_free(acl); 1999da6c28aaSamw return (error); 2000da6c28aaSamw } 2001da6c28aaSamw 2002da6c28aaSamw /* 2003da6c28aaSamw * smb_fsop_aclwrite 2004da6c28aaSamw * 2005da6c28aaSamw * Stores the filesystem ACL provided in fs_sd->sd_acl. 2006da6c28aaSamw */ 2007da6c28aaSamw int 2008da6c28aaSamw smb_fsop_aclwrite(smb_request_t *sr, cred_t *cr, smb_node_t *snode, 2009da6c28aaSamw smb_fssd_t *fs_sd) 2010da6c28aaSamw { 2011da6c28aaSamw int target_flavor; 2012da6c28aaSamw int error = 0; 2013da6c28aaSamw int flags = 0; 2014da6c28aaSamw int access = 0; 2015da6c28aaSamw acl_t *acl, *dacl, *sacl; 2016da6c28aaSamw smb_node_t *unnamed_node; 2017da6c28aaSamw 2018da6c28aaSamw ASSERT(cr); 2019da6c28aaSamw 2020da6c28aaSamw ASSERT(sr); 2021da6c28aaSamw ASSERT(sr->tid_tree); 2022da6c28aaSamw if (SMB_TREE_IS_READ_ONLY(sr)) 2023da6c28aaSamw return (EROFS); 2024da6c28aaSamw 2025da6c28aaSamw if (sr->fid_ofile) { 2026da6c28aaSamw if (fs_sd->sd_secinfo & SMB_DACL_SECINFO) 2027da6c28aaSamw access = WRITE_DAC; 2028da6c28aaSamw 2029da6c28aaSamw if (fs_sd->sd_secinfo & SMB_SACL_SECINFO) 2030da6c28aaSamw access |= ACCESS_SYSTEM_SECURITY; 2031da6c28aaSamw 2032da6c28aaSamw error = smb_ofile_access(sr->fid_ofile, cr, access); 2033da6c28aaSamw if (error != NT_STATUS_SUCCESS) 2034da6c28aaSamw return (EACCES); 2035da6c28aaSamw } 2036da6c28aaSamw 2037da6c28aaSamw switch (sr->tid_tree->t_acltype) { 2038da6c28aaSamw case ACLENT_T: 2039da6c28aaSamw target_flavor = _ACL_ACLENT_ENABLED; 2040da6c28aaSamw break; 2041da6c28aaSamw 2042da6c28aaSamw case ACE_T: 2043da6c28aaSamw target_flavor = _ACL_ACE_ENABLED; 2044da6c28aaSamw break; 2045da6c28aaSamw default: 2046da6c28aaSamw return (EINVAL); 2047da6c28aaSamw } 2048da6c28aaSamw 2049da6c28aaSamw unnamed_node = SMB_IS_STREAM(snode); 2050da6c28aaSamw if (unnamed_node) { 2051da6c28aaSamw ASSERT(unnamed_node->n_magic == SMB_NODE_MAGIC); 2052da6c28aaSamw ASSERT(unnamed_node->n_state != SMB_NODE_STATE_DESTROYING); 2053da6c28aaSamw /* 2054da6c28aaSamw * Streams don't have ACL, any write ACL attempt on a stream 2055da6c28aaSamw * should be performed on the unnamed stream. 2056da6c28aaSamw */ 2057da6c28aaSamw snode = unnamed_node; 2058da6c28aaSamw } 2059da6c28aaSamw 2060da6c28aaSamw dacl = fs_sd->sd_zdacl; 2061da6c28aaSamw sacl = fs_sd->sd_zsacl; 2062da6c28aaSamw 2063da6c28aaSamw ASSERT(dacl || sacl); 2064da6c28aaSamw if ((dacl == NULL) && (sacl == NULL)) 2065da6c28aaSamw return (EINVAL); 2066da6c28aaSamw 2067da6c28aaSamw if (dacl && sacl) 206855bf511dSas acl = smb_fsacl_merge(dacl, sacl); 2069da6c28aaSamw else if (dacl) 2070da6c28aaSamw acl = dacl; 2071da6c28aaSamw else 2072da6c28aaSamw acl = sacl; 2073da6c28aaSamw 2074da6c28aaSamw error = acl_translate(acl, target_flavor, (snode->vp->v_type == VDIR), 2075da6c28aaSamw fs_sd->sd_uid, fs_sd->sd_gid); 2076da6c28aaSamw if (error == 0) { 2077da6c28aaSamw if (sr->tid_tree->t_flags & SMB_TREE_FLAG_ACEMASKONACCESS) 2078da6c28aaSamw flags = ATTR_NOACLCHECK; 2079da6c28aaSamw 2080*dc20a302Sas error = smb_vop_acl_write(snode->vp, acl, flags, cr); 2081da6c28aaSamw } 2082da6c28aaSamw 2083da6c28aaSamw if (dacl && sacl) 2084da6c28aaSamw acl_free(acl); 2085da6c28aaSamw 2086da6c28aaSamw return (error); 2087da6c28aaSamw } 2088da6c28aaSamw 2089da6c28aaSamw acl_type_t 2090da6c28aaSamw smb_fsop_acltype(smb_node_t *snode) 2091da6c28aaSamw { 2092da6c28aaSamw return (smb_vop_acl_type(snode->vp)); 2093da6c28aaSamw } 2094da6c28aaSamw 2095da6c28aaSamw /* 2096da6c28aaSamw * smb_fsop_sdread 2097da6c28aaSamw * 2098da6c28aaSamw * Read the requested security descriptor items from filesystem. 2099da6c28aaSamw * The items are specified in fs_sd->sd_secinfo. 2100da6c28aaSamw */ 2101da6c28aaSamw int 2102da6c28aaSamw smb_fsop_sdread(smb_request_t *sr, cred_t *cr, smb_node_t *snode, 2103da6c28aaSamw smb_fssd_t *fs_sd) 2104da6c28aaSamw { 2105da6c28aaSamw int error = 0; 2106da6c28aaSamw int getowner = 0; 2107da6c28aaSamw cred_t *ga_cred; 2108da6c28aaSamw smb_attr_t attr; 2109da6c28aaSamw 2110da6c28aaSamw ASSERT(cr); 2111da6c28aaSamw ASSERT(fs_sd); 2112da6c28aaSamw 2113da6c28aaSamw /* 2114da6c28aaSamw * File's uid/gid is fetched in two cases: 2115da6c28aaSamw * 2116da6c28aaSamw * 1. it's explicitly requested 2117da6c28aaSamw * 2118da6c28aaSamw * 2. target ACL is ACE_T (ZFS ACL). They're needed for 2119da6c28aaSamw * owner@/group@ entries. In this case kcred should be used 2120da6c28aaSamw * because uid/gid are fetched on behalf of smb server. 2121da6c28aaSamw */ 2122da6c28aaSamw if (fs_sd->sd_secinfo & (SMB_OWNER_SECINFO | SMB_GROUP_SECINFO)) { 2123da6c28aaSamw getowner = 1; 2124da6c28aaSamw ga_cred = cr; 2125da6c28aaSamw } else if (sr->tid_tree->t_acltype == ACE_T) { 2126da6c28aaSamw getowner = 1; 2127da6c28aaSamw ga_cred = kcred; 2128da6c28aaSamw } 2129da6c28aaSamw 2130da6c28aaSamw if (getowner) { 2131da6c28aaSamw /* 2132da6c28aaSamw * Windows require READ_CONTROL to read owner/group SID since 2133da6c28aaSamw * they're part of Security Descriptor. 2134da6c28aaSamw * ZFS only requires read_attribute. Need to have a explicit 2135da6c28aaSamw * access check here. 2136da6c28aaSamw */ 2137da6c28aaSamw if (sr->fid_ofile == NULL) { 2138da6c28aaSamw error = smb_fsop_access(sr, ga_cred, snode, 2139da6c28aaSamw READ_CONTROL); 2140da6c28aaSamw if (error) 2141da6c28aaSamw return (error); 2142da6c28aaSamw } 2143da6c28aaSamw 2144da6c28aaSamw attr.sa_mask = SMB_AT_UID | SMB_AT_GID; 2145da6c28aaSamw error = smb_fsop_getattr(sr, ga_cred, snode, &attr); 2146da6c28aaSamw if (error == 0) { 2147da6c28aaSamw fs_sd->sd_uid = attr.sa_vattr.va_uid; 2148da6c28aaSamw fs_sd->sd_gid = attr.sa_vattr.va_gid; 2149da6c28aaSamw } else { 2150da6c28aaSamw return (error); 2151da6c28aaSamw } 2152da6c28aaSamw } 2153da6c28aaSamw 2154da6c28aaSamw if (fs_sd->sd_secinfo & SMB_ACL_SECINFO) { 2155da6c28aaSamw error = smb_fsop_aclread(sr, cr, snode, fs_sd); 2156da6c28aaSamw } 2157da6c28aaSamw 2158da6c28aaSamw return (error); 2159da6c28aaSamw } 2160da6c28aaSamw 2161da6c28aaSamw /* 2162da6c28aaSamw * smb_fsop_sdmerge 2163da6c28aaSamw * 2164da6c28aaSamw * From SMB point of view DACL and SACL are two separate list 2165da6c28aaSamw * which can be manipulated independently without one affecting 2166da6c28aaSamw * the other, but entries for both DACL and SACL will end up 2167da6c28aaSamw * in the same ACL if target filesystem supports ACE_T ACLs. 2168da6c28aaSamw * 2169da6c28aaSamw * So, if either DACL or SACL is present in the client set request 2170da6c28aaSamw * the entries corresponding to the non-present ACL shouldn't 2171da6c28aaSamw * be touched in the FS ACL. 2172da6c28aaSamw * 2173da6c28aaSamw * fs_sd parameter contains DACL and SACL specified by SMB 2174da6c28aaSamw * client to be set on a file/directory. The client could 2175da6c28aaSamw * specify both or one of these ACLs (if none is specified 2176da6c28aaSamw * we don't get this far). When both DACL and SACL are given 2177da6c28aaSamw * by client the existing ACL should be overwritten. If only 2178da6c28aaSamw * one of them is specified the entries corresponding to the other 2179da6c28aaSamw * ACL should not be touched. For example, if only DACL 2180da6c28aaSamw * is specified in input fs_sd, the function reads audit entries 2181da6c28aaSamw * of the existing ACL of the file and point fs_sd->sd_zsdacl 2182da6c28aaSamw * pointer to the fetched SACL, this way when smb_fsop_sdwrite() 2183da6c28aaSamw * function is called the passed fs_sd would point to the specified 2184da6c28aaSamw * DACL by client and fetched SACL from filesystem, so the file 2185da6c28aaSamw * will end up with correct ACL. 2186da6c28aaSamw */ 2187da6c28aaSamw static int 2188da6c28aaSamw smb_fsop_sdmerge(smb_request_t *sr, smb_node_t *snode, smb_fssd_t *fs_sd) 2189da6c28aaSamw { 2190da6c28aaSamw smb_fssd_t cur_sd; 2191da6c28aaSamw int error = 0; 2192da6c28aaSamw 2193da6c28aaSamw if (sr->tid_tree->t_acltype != ACE_T) 2194da6c28aaSamw /* Don't bother if target FS doesn't support ACE_T */ 2195da6c28aaSamw return (0); 2196da6c28aaSamw 2197da6c28aaSamw if ((fs_sd->sd_secinfo & SMB_ACL_SECINFO) != SMB_ACL_SECINFO) { 2198da6c28aaSamw if (fs_sd->sd_secinfo & SMB_DACL_SECINFO) { 2199da6c28aaSamw /* 2200da6c28aaSamw * Don't overwrite existing audit entries 2201da6c28aaSamw */ 220255bf511dSas smb_fssd_init(&cur_sd, SMB_SACL_SECINFO, 2203da6c28aaSamw fs_sd->sd_flags); 2204da6c28aaSamw 2205da6c28aaSamw error = smb_fsop_sdread(sr, kcred, snode, &cur_sd); 2206da6c28aaSamw if (error == 0) { 2207da6c28aaSamw ASSERT(fs_sd->sd_zsacl == NULL); 2208da6c28aaSamw fs_sd->sd_zsacl = cur_sd.sd_zsacl; 2209da6c28aaSamw if (fs_sd->sd_zsacl && fs_sd->sd_zdacl) 2210da6c28aaSamw fs_sd->sd_zsacl->acl_flags = 2211da6c28aaSamw fs_sd->sd_zdacl->acl_flags; 2212da6c28aaSamw } 2213da6c28aaSamw } else { 2214da6c28aaSamw /* 2215da6c28aaSamw * Don't overwrite existing access entries 2216da6c28aaSamw */ 221755bf511dSas smb_fssd_init(&cur_sd, SMB_DACL_SECINFO, 2218da6c28aaSamw fs_sd->sd_flags); 2219da6c28aaSamw 2220da6c28aaSamw error = smb_fsop_sdread(sr, kcred, snode, &cur_sd); 2221da6c28aaSamw if (error == 0) { 2222da6c28aaSamw ASSERT(fs_sd->sd_zdacl == NULL); 2223da6c28aaSamw fs_sd->sd_zdacl = cur_sd.sd_zdacl; 2224da6c28aaSamw if (fs_sd->sd_zdacl && fs_sd->sd_zsacl) 2225da6c28aaSamw fs_sd->sd_zdacl->acl_flags = 2226da6c28aaSamw fs_sd->sd_zsacl->acl_flags; 2227da6c28aaSamw } 2228da6c28aaSamw } 2229da6c28aaSamw 2230da6c28aaSamw if (error) 223155bf511dSas smb_fssd_term(&cur_sd); 2232da6c28aaSamw } 2233da6c28aaSamw 2234da6c28aaSamw return (error); 2235da6c28aaSamw } 2236da6c28aaSamw 2237da6c28aaSamw /* 2238da6c28aaSamw * smb_fsop_sdwrite 2239da6c28aaSamw * 2240da6c28aaSamw * Stores the given uid, gid and acl in filesystem. 2241da6c28aaSamw * Provided items in fs_sd are specified by fs_sd->sd_secinfo. 2242da6c28aaSamw * 2243da6c28aaSamw * A SMB security descriptor could contain owner, primary group, 2244da6c28aaSamw * DACL and SACL. Setting an SD should be atomic but here it has to 2245da6c28aaSamw * be done via two separate FS operations: VOP_SETATTR and 2246da6c28aaSamw * VOP_SETSECATTR. Therefore, this function has to simulate the 2247da6c28aaSamw * atomicity as well as it can. 2248da6c28aaSamw */ 2249da6c28aaSamw int 2250da6c28aaSamw smb_fsop_sdwrite(smb_request_t *sr, cred_t *cr, smb_node_t *snode, 2251da6c28aaSamw smb_fssd_t *fs_sd, int overwrite) 2252da6c28aaSamw { 2253da6c28aaSamw int error = 0; 2254da6c28aaSamw int access = 0; 2255da6c28aaSamw smb_attr_t set_attr; 2256da6c28aaSamw smb_attr_t orig_attr; 2257da6c28aaSamw 2258da6c28aaSamw ASSERT(cr); 2259da6c28aaSamw ASSERT(fs_sd); 2260da6c28aaSamw 2261da6c28aaSamw ASSERT(sr); 2262da6c28aaSamw ASSERT(sr->tid_tree); 2263da6c28aaSamw if (SMB_TREE_IS_READ_ONLY(sr)) 2264da6c28aaSamw return (EROFS); 2265da6c28aaSamw 2266da6c28aaSamw bzero(&set_attr, sizeof (smb_attr_t)); 2267da6c28aaSamw 2268da6c28aaSamw if (fs_sd->sd_secinfo & SMB_OWNER_SECINFO) { 2269da6c28aaSamw set_attr.sa_vattr.va_uid = fs_sd->sd_uid; 2270da6c28aaSamw set_attr.sa_mask |= SMB_AT_UID; 2271da6c28aaSamw } 2272da6c28aaSamw 2273da6c28aaSamw if (fs_sd->sd_secinfo & SMB_GROUP_SECINFO) { 2274da6c28aaSamw set_attr.sa_vattr.va_gid = fs_sd->sd_gid; 2275da6c28aaSamw set_attr.sa_mask |= SMB_AT_GID; 2276da6c28aaSamw } 2277da6c28aaSamw 2278da6c28aaSamw if (fs_sd->sd_secinfo & SMB_DACL_SECINFO) 2279da6c28aaSamw access |= WRITE_DAC; 2280da6c28aaSamw 2281da6c28aaSamw if (fs_sd->sd_secinfo & SMB_SACL_SECINFO) 2282da6c28aaSamw access |= ACCESS_SYSTEM_SECURITY; 2283da6c28aaSamw 2284da6c28aaSamw if (sr->fid_ofile) 2285da6c28aaSamw error = smb_ofile_access(sr->fid_ofile, cr, access); 2286da6c28aaSamw else 2287da6c28aaSamw error = smb_fsop_access(sr, cr, snode, access); 2288da6c28aaSamw 2289da6c28aaSamw if (error) 2290da6c28aaSamw return (EACCES); 2291da6c28aaSamw 2292da6c28aaSamw if (set_attr.sa_mask) { 2293da6c28aaSamw /* 2294da6c28aaSamw * Get the current uid, gid so if smb_fsop_aclwrite fails 2295da6c28aaSamw * we can revert uid, gid changes. 2296da6c28aaSamw * 2297da6c28aaSamw * We use root cred here so the operation doesn't fail 2298da6c28aaSamw * due to lack of permission for the user to read the attrs 2299da6c28aaSamw */ 2300da6c28aaSamw 2301da6c28aaSamw orig_attr.sa_mask = SMB_AT_UID | SMB_AT_GID; 2302da6c28aaSamw error = smb_fsop_getattr(sr, kcred, snode, &orig_attr); 2303da6c28aaSamw if (error == 0) 2304da6c28aaSamw error = smb_fsop_setattr(sr, cr, snode, &set_attr, 2305da6c28aaSamw NULL); 2306da6c28aaSamw 2307da6c28aaSamw if (error) 2308da6c28aaSamw return (error); 2309da6c28aaSamw } 2310da6c28aaSamw 2311da6c28aaSamw if (fs_sd->sd_secinfo & SMB_ACL_SECINFO) { 2312da6c28aaSamw if (overwrite == 0) { 2313da6c28aaSamw error = smb_fsop_sdmerge(sr, snode, fs_sd); 2314da6c28aaSamw if (error) 2315da6c28aaSamw return (error); 2316da6c28aaSamw } 2317da6c28aaSamw 2318da6c28aaSamw error = smb_fsop_aclwrite(sr, cr, snode, fs_sd); 2319da6c28aaSamw if (error) { 2320da6c28aaSamw /* 2321da6c28aaSamw * Revert uid/gid changes if required. 2322da6c28aaSamw */ 2323da6c28aaSamw if (set_attr.sa_mask) { 2324da6c28aaSamw orig_attr.sa_mask = set_attr.sa_mask; 2325da6c28aaSamw (void) smb_fsop_setattr(sr, kcred, snode, 2326da6c28aaSamw &orig_attr, NULL); 2327da6c28aaSamw } 2328da6c28aaSamw } 2329da6c28aaSamw } 2330da6c28aaSamw 2331da6c28aaSamw return (error); 2332da6c28aaSamw } 2333da6c28aaSamw 2334da6c28aaSamw /* 2335da6c28aaSamw * smb_fsop_sdinherit 2336da6c28aaSamw * 2337da6c28aaSamw * Inherit the security descriptor from the parent container. 2338da6c28aaSamw * This function is called after FS has created the file/folder 2339da6c28aaSamw * so if this doesn't do anything it means FS inheritance is 2340da6c28aaSamw * in place. 2341da6c28aaSamw * 2342da6c28aaSamw * Do inheritance for ZFS internally. 2343da6c28aaSamw * 2344da6c28aaSamw * If we want to let ZFS does the inheritance the 2345da6c28aaSamw * following setting should be true: 2346da6c28aaSamw * 2347da6c28aaSamw * - aclinherit = passthrough 2348da6c28aaSamw * - aclmode = passthrough 2349da6c28aaSamw * - smbd umask = 0777 2350da6c28aaSamw * 2351da6c28aaSamw * This will result in right effective permissions but 2352da6c28aaSamw * ZFS will always add 6 ACEs for owner, owning group 2353da6c28aaSamw * and others to be POSIX compliant. This is not what 2354da6c28aaSamw * Windows clients/users expect, so we decided that CIFS 2355da6c28aaSamw * implements Windows rules and overwrite whatever ZFS 2356da6c28aaSamw * comes up with. This way we also don't have to care 2357da6c28aaSamw * about ZFS aclinherit and aclmode settings. 2358da6c28aaSamw */ 2359da6c28aaSamw static int 2360da6c28aaSamw smb_fsop_sdinherit(smb_request_t *sr, smb_node_t *dnode, smb_fssd_t *fs_sd) 2361da6c28aaSamw { 2362da6c28aaSamw int is_dir; 236355bf511dSas acl_t *dacl = NULL; 236455bf511dSas acl_t *sacl = NULL; 2365da6c28aaSamw ksid_t *owner_sid; 2366da6c28aaSamw int error; 2367da6c28aaSamw 2368da6c28aaSamw ASSERT(fs_sd); 2369da6c28aaSamw 2370da6c28aaSamw if (sr->tid_tree->t_acltype != ACE_T) { 2371da6c28aaSamw /* 2372da6c28aaSamw * No forced inheritance for non-ZFS filesystems. 2373da6c28aaSamw */ 2374da6c28aaSamw fs_sd->sd_secinfo = 0; 2375da6c28aaSamw return (0); 2376da6c28aaSamw } 2377da6c28aaSamw 2378da6c28aaSamw 2379da6c28aaSamw /* Fetch parent directory's ACL */ 2380da6c28aaSamw error = smb_fsop_sdread(sr, kcred, dnode, fs_sd); 2381da6c28aaSamw if (error) { 2382da6c28aaSamw return (error); 2383da6c28aaSamw } 2384da6c28aaSamw 2385da6c28aaSamw is_dir = (fs_sd->sd_flags & SMB_FSSD_FLAGS_DIR); 2386da6c28aaSamw owner_sid = crgetsid(sr->user_cr, KSID_OWNER); 2387da6c28aaSamw ASSERT(owner_sid); 238855bf511dSas dacl = smb_fsacl_inherit(fs_sd->sd_zdacl, is_dir, SMB_DACL_SECINFO, 2389da6c28aaSamw owner_sid->ks_id); 239055bf511dSas sacl = smb_fsacl_inherit(fs_sd->sd_zsacl, is_dir, SMB_SACL_SECINFO, 2391da6c28aaSamw (uid_t)-1); 2392da6c28aaSamw 239355bf511dSas if (sacl == NULL) 239455bf511dSas fs_sd->sd_secinfo &= ~SMB_SACL_SECINFO; 239555bf511dSas 239655bf511dSas smb_fsacl_free(fs_sd->sd_zdacl); 239755bf511dSas smb_fsacl_free(fs_sd->sd_zsacl); 2398da6c28aaSamw 2399da6c28aaSamw fs_sd->sd_zdacl = dacl; 2400da6c28aaSamw fs_sd->sd_zsacl = sacl; 2401da6c28aaSamw 2402da6c28aaSamw return (0); 2403da6c28aaSamw } 2404da6c28aaSamw 2405da6c28aaSamw /* 2406da6c28aaSamw * smb_fsop_eaccess 2407da6c28aaSamw * 2408da6c28aaSamw * Returns the effective permission of the given credential for the 2409da6c28aaSamw * specified object. 2410da6c28aaSamw * 2411da6c28aaSamw * This is just a workaround. We need VFS/FS support for this. 2412da6c28aaSamw */ 2413da6c28aaSamw void 2414da6c28aaSamw smb_fsop_eaccess(smb_request_t *sr, cred_t *cr, smb_node_t *snode, 2415da6c28aaSamw uint32_t *eaccess) 2416da6c28aaSamw { 2417da6c28aaSamw int access = 0; 2418da6c28aaSamw vnode_t *dir_vp; 2419da6c28aaSamw smb_node_t *unnamed_node; 2420da6c28aaSamw 2421da6c28aaSamw ASSERT(cr); 2422da6c28aaSamw ASSERT(snode); 2423da6c28aaSamw ASSERT(snode->n_magic == SMB_NODE_MAGIC); 2424da6c28aaSamw ASSERT(snode->n_state != SMB_NODE_STATE_DESTROYING); 2425da6c28aaSamw 2426da6c28aaSamw unnamed_node = SMB_IS_STREAM(snode); 2427da6c28aaSamw if (unnamed_node) { 2428da6c28aaSamw ASSERT(unnamed_node->n_magic == SMB_NODE_MAGIC); 2429da6c28aaSamw ASSERT(unnamed_node->n_state != SMB_NODE_STATE_DESTROYING); 2430da6c28aaSamw /* 2431da6c28aaSamw * Streams authorization should be performed against the 2432da6c28aaSamw * unnamed stream. 2433da6c28aaSamw */ 2434da6c28aaSamw snode = unnamed_node; 2435da6c28aaSamw } 2436da6c28aaSamw 2437da6c28aaSamw if (sr->tid_tree->t_flags & SMB_TREE_FLAG_ACEMASKONACCESS) { 2438da6c28aaSamw dir_vp = (snode->dir_snode) ? snode->dir_snode->vp : NULL; 2439da6c28aaSamw smb_vop_eaccess(snode->vp, (int *)eaccess, V_ACE_MASK, dir_vp, 2440da6c28aaSamw cr); 2441da6c28aaSamw return; 2442da6c28aaSamw } 2443da6c28aaSamw 2444da6c28aaSamw /* 2445da6c28aaSamw * FS doesn't understand 32-bit mask 2446da6c28aaSamw */ 2447da6c28aaSamw smb_vop_eaccess(snode->vp, &access, 0, NULL, cr); 2448da6c28aaSamw 2449da6c28aaSamw *eaccess = READ_CONTROL | FILE_READ_EA | FILE_READ_ATTRIBUTES; 2450da6c28aaSamw 2451da6c28aaSamw if (access & VREAD) 2452da6c28aaSamw *eaccess |= FILE_READ_DATA; 2453da6c28aaSamw 2454da6c28aaSamw if (access & VEXEC) 2455da6c28aaSamw *eaccess |= FILE_EXECUTE; 2456da6c28aaSamw 2457da6c28aaSamw if (access & VWRITE) 2458da6c28aaSamw *eaccess |= FILE_WRITE_DATA | FILE_WRITE_ATTRIBUTES | 2459da6c28aaSamw FILE_WRITE_EA | FILE_APPEND_DATA | FILE_DELETE_CHILD; 2460da6c28aaSamw } 246155bf511dSas 2462*dc20a302Sas /* 2463*dc20a302Sas * smb_fsop_shrlock 2464*dc20a302Sas * 2465*dc20a302Sas * For the current open request, check file sharing rules 2466*dc20a302Sas * against existing opens. 2467*dc20a302Sas * 2468*dc20a302Sas * Returns NT_STATUS_SHARING_VIOLATION if there is any 2469*dc20a302Sas * sharing conflict. Returns NT_STATUS_SUCCESS otherwise. 2470*dc20a302Sas * 2471*dc20a302Sas * Full system-wide share reservation synchronization is available 2472*dc20a302Sas * when the nbmand (non-blocking mandatory) mount option is set 2473*dc20a302Sas * (i.e. nbl_need_crit() is true) and nbmand critical regions are used. 2474*dc20a302Sas * This provides synchronization with NFS and local processes. The 2475*dc20a302Sas * critical regions are entered in VOP_SHRLOCK()/fs_shrlock() (called 2476*dc20a302Sas * from smb_open_subr()/smb_fsop_shrlock()/smb_vop_shrlock()) as well 2477*dc20a302Sas * as the CIFS rename and delete paths. 2478*dc20a302Sas * 2479*dc20a302Sas * The CIFS server will also enter the nbl critical region in the open, 2480*dc20a302Sas * rename, and delete paths when nbmand is not set. There is limited 2481*dc20a302Sas * coordination with local and VFS share reservations in this case. 2482*dc20a302Sas * Note that when the nbmand mount option is not set, the VFS layer 2483*dc20a302Sas * only processes advisory reservations and the delete mode is not checked. 2484*dc20a302Sas * 2485*dc20a302Sas * Whether or not the nbmand mount option is set, intra-CIFS share 2486*dc20a302Sas * checking is done in the open, delete, and rename paths using a CIFS 2487*dc20a302Sas * critical region (node->n_share_lock). 2488*dc20a302Sas */ 2489*dc20a302Sas 2490*dc20a302Sas uint32_t 2491*dc20a302Sas smb_fsop_shrlock(cred_t *cr, struct smb_node *node, uint32_t uniq_fid, 2492*dc20a302Sas uint32_t desired_access, uint32_t share_access) 2493*dc20a302Sas { 2494*dc20a302Sas int rc; 2495*dc20a302Sas 2496*dc20a302Sas if (node->attr.sa_vattr.va_type == VDIR) 2497*dc20a302Sas return (NT_STATUS_SUCCESS); 2498*dc20a302Sas 2499*dc20a302Sas /* Allow access if the request is just for meta data */ 2500*dc20a302Sas if ((desired_access & FILE_DATA_ALL) == 0) 2501*dc20a302Sas return (NT_STATUS_SUCCESS); 2502*dc20a302Sas 2503*dc20a302Sas rc = smb_node_open_check(node, cr, desired_access, share_access); 2504*dc20a302Sas if (rc) 2505*dc20a302Sas return (NT_STATUS_SHARING_VIOLATION); 2506*dc20a302Sas 2507*dc20a302Sas rc = smb_vop_shrlock(node->vp, uniq_fid, desired_access, share_access, 2508*dc20a302Sas cr); 2509*dc20a302Sas if (rc) 2510*dc20a302Sas return (NT_STATUS_SHARING_VIOLATION); 2511*dc20a302Sas 2512*dc20a302Sas return (NT_STATUS_SUCCESS); 2513*dc20a302Sas } 2514*dc20a302Sas 251555bf511dSas void 2516*dc20a302Sas smb_fsop_unshrlock(cred_t *cr, smb_node_t *node, uint32_t uniq_fid) 2517*dc20a302Sas { 2518*dc20a302Sas if (node->attr.sa_vattr.va_type == VDIR) 2519*dc20a302Sas return; 2520*dc20a302Sas 2521*dc20a302Sas (void) smb_vop_unshrlock(node->vp, uniq_fid, cr); 2522*dc20a302Sas } 2523*dc20a302Sas 2524*dc20a302Sas /* 2525*dc20a302Sas * smb_fsop_frlock_callback 2526*dc20a302Sas * 2527*dc20a302Sas * smb wrapper function for fs_frlock 2528*dc20a302Sas * this should never happen, as we are not attempting 2529*dc20a302Sas * to set Mandatory Locks, cmd = F_SETLK_NBMAND 2530*dc20a302Sas * 2531*dc20a302Sas */ 2532*dc20a302Sas 2533*dc20a302Sas static callb_cpr_t * 2534*dc20a302Sas /* ARGSUSED */ 2535*dc20a302Sas smb_fsop_frlock_callback(flk_cb_when_t when, void *error) 253655bf511dSas { 2537*dc20a302Sas return (0); 2538*dc20a302Sas } 2539*dc20a302Sas 2540*dc20a302Sas /* 2541*dc20a302Sas * smb_fs_frlock 2542*dc20a302Sas * 2543*dc20a302Sas * smb wrapper function for fs_frlock 2544*dc20a302Sas */ 2545*dc20a302Sas 2546*dc20a302Sas int 2547*dc20a302Sas smb_fsop_frlock(smb_request_t *sr, smb_node_t *node, smb_lock_t *lock, 2548*dc20a302Sas boolean_t unlock) 2549*dc20a302Sas { 2550*dc20a302Sas vnode_t *vp; 2551*dc20a302Sas flock64_t bf; 2552*dc20a302Sas cred_t *cr; 2553*dc20a302Sas caller_context_t *ct; 2554*dc20a302Sas int cmd; 2555*dc20a302Sas flk_callback_t flk_cb; 2556*dc20a302Sas offset_t offset = 0; 2557*dc20a302Sas int flag; 2558*dc20a302Sas int error; 2559*dc20a302Sas int i; 2560*dc20a302Sas 2561*dc20a302Sas flk_init_callback(&flk_cb, smb_fsop_frlock_callback, &error); 2562*dc20a302Sas cr = sr->user_cr; 2563*dc20a302Sas ct = &smb_ct; 2564*dc20a302Sas vp = node->vp; 2565*dc20a302Sas cmd = F_SETLK; 2566*dc20a302Sas 2567*dc20a302Sas if (unlock == B_TRUE) { 2568*dc20a302Sas bf.l_type = F_UNLCK; 2569*dc20a302Sas flag = 0; 2570*dc20a302Sas } else if (lock->l_type == SMB_LOCK_TYPE_READONLY) { 2571*dc20a302Sas bf.l_type = F_RDLCK; 2572*dc20a302Sas flag = FREAD; 2573*dc20a302Sas } else if (lock->l_type == SMB_LOCK_TYPE_READWRITE) { 2574*dc20a302Sas bf.l_type = F_WRLCK; 2575*dc20a302Sas flag = FWRITE; 2576*dc20a302Sas } 2577*dc20a302Sas 2578*dc20a302Sas bf.l_start = lock->l_start; 2579*dc20a302Sas bf.l_len = lock->l_length; 2580*dc20a302Sas bf.l_whence = 0; /* SEEK_SET */ 2581*dc20a302Sas bf.l_pid = lock->l_pid; 2582*dc20a302Sas bf.l_sysid = 0; 2583*dc20a302Sas 2584*dc20a302Sas for (i = 0; i < 4; i++) 2585*dc20a302Sas bf.l_pad[i] = 0; 2586*dc20a302Sas 2587*dc20a302Sas error = fs_frlock(vp, cmd, &bf, flag, offset, &flk_cb, cr, ct); 2588*dc20a302Sas return (error); 258955bf511dSas } 2590