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