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