1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
23  * Copyright 2020 Nexenta by DDN, Inc. All rights reserved.
24  */
25 
26 #include <sys/sid.h>
27 #include <sys/nbmlock.h>
28 #include <smbsrv/smb_fsops.h>
29 #include <smbsrv/smb_kproto.h>
30 #include <acl/acl_common.h>
31 #include <sys/fcntl.h>
32 #include <sys/filio.h>
33 #include <sys/flock.h>
34 #include <fs/fs_subr.h>
35 
36 extern caller_context_t smb_ct;
37 
38 static int smb_fsop_create_file_with_stream(smb_request_t *, cred_t *,
39     smb_node_t *, char *, char *, int, smb_attr_t *, smb_node_t **);
40 
41 static int smb_fsop_create_file(smb_request_t *, cred_t *, smb_node_t *,
42     char *, int, smb_attr_t *, smb_node_t **);
43 
44 #ifdef	_KERNEL
45 static int smb_fsop_create_with_sd(smb_request_t *, cred_t *, smb_node_t *,
46     char *, smb_attr_t *, smb_node_t **, smb_fssd_t *);
47 static int smb_fsop_sdinherit(smb_request_t *, smb_node_t *, smb_fssd_t *);
48 #endif	/* _KERNEL */
49 
50 /*
51  * The smb_fsop_* functions have knowledge of CIFS semantics.
52  *
53  * The smb_vop_* functions have minimal knowledge of CIFS semantics and
54  * serve as an interface to the VFS layer.
55  *
56  * Hence, smb_request_t and smb_node_t structures should not be passed
57  * from the smb_fsop_* layer to the smb_vop_* layer.
58  *
59  * In general, CIFS service code should only ever call smb_fsop_*
60  * functions directly, and never smb_vop_* functions directly.
61  *
62  * smb_fsop_* functions should call smb_vop_* functions where possible, instead
63  * of their smb_fsop_* counterparts.  However, there are times when
64  * this cannot be avoided.
65  */
66 
67 /*
68  * Note: Stream names cannot be mangled.
69  */
70 
71 /*
72  * smb_fsop_amask_to_omode
73  *
74  * Convert the access mask to the open mode (for use
75  * with the VOP_OPEN call).
76  *
77  * Note that opening a file for attribute only access
78  * will also translate into an FREAD or FWRITE open mode
79  * (i.e., it's not just for data).
80  *
81  * This is needed so that opens are tracked appropriately
82  * for oplock processing.
83  */
84 
85 int
smb_fsop_amask_to_omode(uint32_t access)86 smb_fsop_amask_to_omode(uint32_t access)
87 {
88 	int mode = 0;
89 
90 	if (access & (FILE_READ_DATA | FILE_EXECUTE |
91 	    FILE_READ_ATTRIBUTES | FILE_READ_EA))
92 		mode |= FREAD;
93 
94 	if (access & (FILE_WRITE_DATA | FILE_APPEND_DATA |
95 	    FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA))
96 		mode |= FWRITE;
97 
98 	if (access & FILE_APPEND_DATA)
99 		mode |= FAPPEND;
100 
101 	return (mode);
102 }
103 
104 int
smb_fsop_open(smb_node_t * node,int mode,cred_t * cred)105 smb_fsop_open(smb_node_t *node, int mode, cred_t *cred)
106 {
107 	/*
108 	 * Assuming that the same vnode is returned as we had before.
109 	 * (I.e., with certain types of files or file systems, a
110 	 * different vnode might be returned by VOP_OPEN)
111 	 */
112 	return (smb_vop_open(&node->vp, mode, cred));
113 }
114 
115 void
smb_fsop_close(smb_node_t * node,int mode,cred_t * cred)116 smb_fsop_close(smb_node_t *node, int mode, cred_t *cred)
117 {
118 	smb_vop_close(node->vp, mode, cred);
119 }
120 
121 #ifdef	_KERNEL
122 static int
smb_fsop_create_with_sd(smb_request_t * sr,cred_t * cr,smb_node_t * dnode,char * name,smb_attr_t * attr,smb_node_t ** ret_snode,smb_fssd_t * fs_sd)123 smb_fsop_create_with_sd(smb_request_t *sr, cred_t *cr,
124     smb_node_t *dnode, char *name,
125     smb_attr_t *attr, smb_node_t **ret_snode, smb_fssd_t *fs_sd)
126 {
127 	vsecattr_t *vsap;
128 	vsecattr_t vsecattr;
129 	smb_attr_t set_attr;
130 	acl_t *acl, *dacl, *sacl;
131 	vnode_t *vp;
132 	cred_t *kcr = zone_kcred();
133 	int aclbsize = 0;	/* size of acl list in bytes */
134 	int flags = 0;
135 	int rc;
136 	boolean_t is_dir;
137 
138 	ASSERT(fs_sd);
139 	ASSERT(ret_snode != NULL);
140 
141 	if (SMB_TREE_IS_CASEINSENSITIVE(sr))
142 		flags = SMB_IGNORE_CASE;
143 	if (SMB_TREE_SUPPORTS_CATIA(sr))
144 		flags |= SMB_CATIA;
145 
146 	ASSERT(cr);
147 
148 	is_dir = ((fs_sd->sd_flags & SMB_FSSD_FLAGS_DIR) != 0);
149 
150 	if (smb_tree_has_feature(sr->tid_tree, SMB_TREE_ACLONCREATE)) {
151 		dacl = fs_sd->sd_zdacl;
152 		sacl = fs_sd->sd_zsacl;
153 		if (dacl != NULL || sacl != NULL) {
154 			if (dacl && sacl) {
155 				acl = smb_fsacl_merge(dacl, sacl);
156 			} else if (dacl) {
157 				acl = dacl;
158 			} else {
159 				acl = sacl;
160 			}
161 
162 			rc = smb_fsacl_to_vsa(acl, &vsecattr, &aclbsize);
163 
164 			if (dacl && sacl)
165 				acl_free(acl);
166 
167 			if (rc != 0)
168 				return (rc);
169 
170 			vsap = &vsecattr;
171 		} else {
172 			vsap = NULL;
173 		}
174 
175 		/* The tree ACEs may prevent a create */
176 		rc = EACCES;
177 		if (is_dir) {
178 			if (SMB_TREE_HAS_ACCESS(sr, ACE_ADD_SUBDIRECTORY) != 0)
179 				rc = smb_vop_mkdir(dnode->vp, name, attr,
180 				    &vp, flags, cr, vsap);
181 		} else {
182 			if (SMB_TREE_HAS_ACCESS(sr, ACE_ADD_FILE) != 0)
183 				rc = smb_vop_create(dnode->vp, name, attr,
184 				    &vp, flags, cr, vsap);
185 		}
186 
187 		if (vsap != NULL)
188 			kmem_free(vsap->vsa_aclentp, aclbsize);
189 
190 		if (rc != 0)
191 			return (rc);
192 
193 		set_attr.sa_mask = 0;
194 
195 		/*
196 		 * Ideally we should be able to specify the owner and owning
197 		 * group at create time along with the ACL. Since we cannot
198 		 * do that right now, kcred is passed to smb_vop_setattr so it
199 		 * doesn't fail due to lack of permission.
200 		 */
201 		if (fs_sd->sd_secinfo & SMB_OWNER_SECINFO) {
202 			set_attr.sa_vattr.va_uid = fs_sd->sd_uid;
203 			set_attr.sa_mask |= SMB_AT_UID;
204 		}
205 
206 		if (fs_sd->sd_secinfo & SMB_GROUP_SECINFO) {
207 			set_attr.sa_vattr.va_gid = fs_sd->sd_gid;
208 			set_attr.sa_mask |= SMB_AT_GID;
209 		}
210 
211 		if (set_attr.sa_mask)
212 			rc = smb_vop_setattr(vp, NULL, &set_attr, 0, kcr);
213 
214 		if (rc == 0) {
215 			*ret_snode = smb_node_lookup(sr, &sr->arg.open, cr, vp,
216 			    name, dnode, NULL);
217 
218 			if (*ret_snode == NULL)
219 				rc = ENOMEM;
220 
221 			VN_RELE(vp);
222 		}
223 	} else {
224 		/*
225 		 * For filesystems that don't support ACL-on-create, try
226 		 * to set the specified SD after create, which could actually
227 		 * fail because of conflicts between inherited security
228 		 * attributes upon creation and the specified SD.
229 		 *
230 		 * Passing kcred to smb_fsop_sdwrite() to overcome this issue.
231 		 */
232 
233 		if (is_dir) {
234 			rc = smb_vop_mkdir(dnode->vp, name, attr, &vp,
235 			    flags, cr, NULL);
236 		} else {
237 			rc = smb_vop_create(dnode->vp, name, attr, &vp,
238 			    flags, cr, NULL);
239 		}
240 
241 		if (rc != 0)
242 			return (rc);
243 
244 		*ret_snode = smb_node_lookup(sr, &sr->arg.open, cr, vp,
245 		    name, dnode, NULL);
246 
247 		if (*ret_snode != NULL) {
248 			if (!smb_tree_has_feature(sr->tid_tree,
249 			    SMB_TREE_NFS_MOUNTED))
250 				rc = smb_fsop_sdwrite(sr, kcr, *ret_snode,
251 				    fs_sd, 1);
252 		} else {
253 			rc = ENOMEM;
254 		}
255 
256 		VN_RELE(vp);
257 	}
258 
259 	if (rc != 0) {
260 		if (is_dir)
261 			(void) smb_vop_rmdir(dnode->vp, name, flags, cr);
262 		else
263 			(void) smb_vop_remove(dnode->vp, name, flags, cr);
264 	}
265 
266 	return (rc);
267 }
268 #endif	/* _KERNEL */
269 
270 /*
271  * smb_fsop_create
272  *
273  * All SMB functions should use this wrapper to ensure that
274  * all the smb_vop_creates are performed with the appropriate credentials.
275  * Please document any direct calls to explain the reason for avoiding
276  * this wrapper.
277  *
278  * *ret_snode is returned with a reference upon success.  No reference is
279  * taken if an error is returned.
280  */
281 int
smb_fsop_create(smb_request_t * sr,cred_t * cr,smb_node_t * dnode,char * name,smb_attr_t * attr,smb_node_t ** ret_snode)282 smb_fsop_create(smb_request_t *sr, cred_t *cr, smb_node_t *dnode,
283     char *name, smb_attr_t *attr, smb_node_t **ret_snode)
284 {
285 	int	rc = 0;
286 	int	flags = 0;
287 	char	*fname, *sname;
288 	char	*longname = NULL;
289 
290 	ASSERT(cr);
291 	ASSERT(dnode);
292 	ASSERT(dnode->n_magic == SMB_NODE_MAGIC);
293 	ASSERT(dnode->n_state != SMB_NODE_STATE_DESTROYING);
294 
295 	ASSERT(ret_snode);
296 	*ret_snode = 0;
297 
298 	ASSERT(name);
299 	if (*name == 0)
300 		return (EINVAL);
301 
302 	ASSERT(sr);
303 	ASSERT(sr->tid_tree);
304 
305 	if (SMB_TREE_CONTAINS_NODE(sr, dnode) == 0)
306 		return (EACCES);
307 
308 	if (SMB_TREE_IS_READONLY(sr))
309 		return (EROFS);
310 
311 	if (SMB_TREE_IS_CASEINSENSITIVE(sr))
312 		flags = SMB_IGNORE_CASE;
313 	if (SMB_TREE_SUPPORTS_CATIA(sr))
314 		flags |= SMB_CATIA;
315 	if (SMB_TREE_SUPPORTS_ABE(sr))
316 		flags |= SMB_ABE;
317 
318 	if (smb_is_stream_name(name)) {
319 		fname = kmem_alloc(MAXNAMELEN, KM_SLEEP);
320 		sname = kmem_alloc(MAXNAMELEN, KM_SLEEP);
321 		smb_stream_parse_name(name, fname, sname);
322 
323 		rc = smb_fsop_create_file_with_stream(sr, cr, dnode,
324 		    fname, sname, flags, attr, ret_snode);
325 
326 		kmem_free(fname, MAXNAMELEN);
327 		kmem_free(sname, MAXNAMELEN);
328 		return (rc);
329 	}
330 
331 	/* Not a named stream */
332 
333 	if (SMB_TREE_SUPPORTS_SHORTNAMES(sr) && smb_maybe_mangled(name)) {
334 		longname = kmem_alloc(MAXNAMELEN, KM_SLEEP);
335 		rc = smb_unmangle(dnode, name, longname, MAXNAMELEN, flags);
336 		kmem_free(longname, MAXNAMELEN);
337 
338 		if (rc == 0)
339 			rc = EEXIST;
340 		if (rc != ENOENT)
341 			return (rc);
342 	}
343 
344 	rc = smb_fsop_create_file(sr, cr, dnode, name, flags,
345 	    attr, ret_snode);
346 	return (rc);
347 
348 }
349 
350 
351 /*
352  * smb_fsop_create_file_with_stream
353  *
354  * Create named stream (sname) on file (fname), creating the file if it
355  * doesn't exist.
356  * If we created the file and then creation of the named stream fails,
357  * we delete the file.
358  * Since we use the real file name for the smb_vop_remove we
359  * clear the SMB_IGNORE_CASE flag to ensure a case sensitive
360  * match.
361  *
362  * Note that some stream "types" are "restricted" and only
363  * internal callers (cr == kcred) can create those.
364  */
365 static int
smb_fsop_create_file_with_stream(smb_request_t * sr,cred_t * cr,smb_node_t * dnode,char * fname,char * sname,int flags,smb_attr_t * attr,smb_node_t ** ret_snode)366 smb_fsop_create_file_with_stream(smb_request_t *sr, cred_t *cr,
367     smb_node_t *dnode, char *fname, char *sname, int flags,
368     smb_attr_t *attr, smb_node_t **ret_snode)
369 {
370 	smb_node_t	*fnode;
371 	cred_t		*kcr = zone_kcred();
372 	int		rc = 0;
373 	boolean_t	fcreate = B_FALSE;
374 
375 	ASSERT(ret_snode != NULL);
376 
377 	if (cr != kcr && smb_strname_restricted(sname))
378 		return (EACCES);
379 
380 	/* Look up / create the unnamed stream, fname */
381 	rc = smb_fsop_lookup(sr, cr, flags | SMB_FOLLOW_LINKS,
382 	    sr->tid_tree->t_snode, dnode, fname, &fnode);
383 	if (rc == 0) {
384 		if (smb_fsop_access(sr, sr->user_cr, fnode,
385 		    sr->sr_open.desired_access) != 0) {
386 			smb_node_release(fnode);
387 			rc = EACCES;
388 		}
389 	} else if (rc == ENOENT) {
390 		fcreate = B_TRUE;
391 		rc = smb_fsop_create_file(sr, cr, dnode, fname, flags,
392 		    attr, &fnode);
393 	}
394 	if (rc != 0)
395 		return (rc);
396 
397 	rc = smb_fsop_create_stream(sr, cr, dnode, fnode, sname, flags, attr,
398 	    ret_snode);
399 
400 	if (rc != 0) {
401 		if (fcreate) {
402 			flags &= ~SMB_IGNORE_CASE;
403 			(void) smb_vop_remove(dnode->vp,
404 			    fnode->od_name, flags, cr);
405 		}
406 	}
407 
408 	smb_node_release(fnode);
409 	return (rc);
410 }
411 
412 /*
413  * smb_fsop_create_stream
414  *
415  * Create named stream (sname) on existing file (fnode).
416  *
417  * The second parameter of smb_vop_setattr() is set to
418  * NULL, even though an unnamed stream exists.  This is
419  * because we want to set the UID and GID on the named
420  * stream in this case for consistency with the (unnamed
421  * stream) file (see comments for smb_vop_setattr()).
422  *
423  * Note that some stream "types" are "restricted" and only
424  * internal callers (cr == kcred) can create those.
425  */
426 int
smb_fsop_create_stream(smb_request_t * sr,cred_t * cr,smb_node_t * dnode,smb_node_t * fnode,char * sname,int flags,smb_attr_t * attr,smb_node_t ** ret_snode)427 smb_fsop_create_stream(smb_request_t *sr, cred_t *cr,
428     smb_node_t *dnode, smb_node_t *fnode, char *sname, int flags,
429     smb_attr_t *attr, smb_node_t **ret_snode)
430 {
431 	smb_attr_t	fattr;
432 	vnode_t		*xattrdvp;
433 	vnode_t		*vp;
434 	cred_t		*kcr = zone_kcred();
435 	int		rc = 0;
436 
437 	ASSERT(ret_snode != NULL);
438 
439 	if (cr != kcr && smb_strname_restricted(sname))
440 		return (EACCES);
441 
442 	bzero(&fattr, sizeof (fattr));
443 	fattr.sa_mask = SMB_AT_UID | SMB_AT_GID;
444 	rc = smb_vop_getattr(fnode->vp, NULL, &fattr, 0, kcr);
445 
446 	if (rc == 0) {
447 		/* create the named stream, sname */
448 		rc = smb_vop_stream_create(fnode->vp, sname,
449 		    attr, &vp, &xattrdvp, flags, cr);
450 	}
451 	if (rc != 0)
452 		return (rc);
453 
454 	attr->sa_vattr.va_uid = fattr.sa_vattr.va_uid;
455 	attr->sa_vattr.va_gid = fattr.sa_vattr.va_gid;
456 	attr->sa_mask = SMB_AT_UID | SMB_AT_GID;
457 
458 	rc = smb_vop_setattr(vp, NULL, attr, 0, kcr);
459 	if (rc != 0) {
460 		VN_RELE(xattrdvp);
461 		VN_RELE(vp);
462 		return (rc);
463 	}
464 
465 	*ret_snode = smb_stream_node_lookup(sr, cr, fnode, xattrdvp,
466 	    vp, sname);
467 
468 	VN_RELE(xattrdvp);
469 	VN_RELE(vp);
470 
471 	if (*ret_snode == NULL)
472 		rc = ENOMEM;
473 
474 	/* notify change to the unnamed stream */
475 	if (rc == 0)
476 		smb_node_notify_change(dnode,
477 		    FILE_ACTION_ADDED_STREAM, fnode->od_name);
478 
479 	return (rc);
480 }
481 
482 /*
483  * smb_fsop_create_file
484  */
485 static int
smb_fsop_create_file(smb_request_t * sr,cred_t * cr,smb_node_t * dnode,char * name,int flags,smb_attr_t * attr,smb_node_t ** ret_snode)486 smb_fsop_create_file(smb_request_t *sr, cred_t *cr,
487     smb_node_t *dnode, char *name, int flags,
488     smb_attr_t *attr, smb_node_t **ret_snode)
489 {
490 	smb_arg_open_t	*op = &sr->sr_open;
491 	vnode_t		*vp;
492 	int		rc;
493 
494 	ASSERT(ret_snode != NULL);
495 
496 #ifdef	_KERNEL
497 	smb_fssd_t	fs_sd;
498 	uint32_t	secinfo;
499 	uint32_t	status;
500 
501 	if (op->sd) {
502 		/*
503 		 * SD sent by client in Windows format. Needs to be
504 		 * converted to FS format. Inherit DACL/SACL if they're not
505 		 * specified.
506 		 */
507 		secinfo = smb_sd_get_secinfo(op->sd);
508 
509 		if ((secinfo & SMB_SACL_SECINFO) != 0 &&
510 		    !smb_user_has_security_priv(sr->uid_user, cr))
511 			return (EPERM);
512 
513 		smb_fssd_init(&fs_sd, secinfo, 0);
514 
515 		status = smb_sd_tofs(op->sd, &fs_sd);
516 		if (status == NT_STATUS_SUCCESS) {
517 			rc = smb_fsop_sdinherit(sr, dnode, &fs_sd);
518 			if (rc == 0)
519 				rc = smb_fsop_create_with_sd(sr, cr, dnode,
520 				    name, attr, ret_snode, &fs_sd);
521 
522 		} else {
523 			rc = EINVAL;
524 		}
525 		smb_fssd_term(&fs_sd);
526 	} else if (sr->tid_tree->t_acltype == ACE_T) {
527 		/*
528 		 * No incoming SD and filesystem is ZFS
529 		 * Server applies Windows inheritance rules,
530 		 * see smb_fsop_sdinherit() comments as to why.
531 		 */
532 		smb_fssd_init(&fs_sd, 0, 0);
533 		rc = smb_fsop_sdinherit(sr, dnode, &fs_sd);
534 		if (rc == 0) {
535 			rc = smb_fsop_create_with_sd(sr, cr, dnode,
536 			    name, attr, ret_snode, &fs_sd);
537 		}
538 
539 		smb_fssd_term(&fs_sd);
540 	} else
541 #endif	/* _KERNEL */
542 	{
543 		/*
544 		 * No incoming SD and filesystem is not ZFS
545 		 * let the filesystem handles the inheritance.
546 		 */
547 		rc = smb_vop_create(dnode->vp, name, attr, &vp,
548 		    flags, cr, NULL);
549 
550 		if (rc == 0) {
551 			*ret_snode = smb_node_lookup(sr, op, cr, vp,
552 			    name, dnode, NULL);
553 
554 			if (*ret_snode == NULL)
555 				rc = ENOMEM;
556 
557 			VN_RELE(vp);
558 		}
559 
560 	}
561 
562 	if (rc == 0)
563 		smb_node_notify_change(dnode, FILE_ACTION_ADDED, name);
564 
565 	return (rc);
566 }
567 
568 /*
569  * smb_fsop_mkdir
570  *
571  * All SMB functions should use this wrapper to ensure that
572  * the the calls are performed with the appropriate credentials.
573  * Please document any direct call to explain the reason
574  * for avoiding this wrapper.
575  *
576  * It is assumed that a reference exists on snode coming into this routine.
577  *
578  * *ret_snode is returned with a reference upon success.  No reference is
579  * taken if an error is returned.
580  */
581 int
smb_fsop_mkdir(smb_request_t * sr,cred_t * cr,smb_node_t * dnode,char * name,smb_attr_t * attr,smb_node_t ** ret_snode)582 smb_fsop_mkdir(
583     smb_request_t *sr,
584     cred_t *cr,
585     smb_node_t *dnode,
586     char *name,
587     smb_attr_t *attr,
588     smb_node_t **ret_snode)
589 {
590 	struct open_param *op = &sr->arg.open;
591 	char *longname;
592 	vnode_t *vp;
593 	int flags = 0;
594 	int rc;
595 
596 #ifdef	_KERNEL
597 	smb_fssd_t fs_sd;
598 	uint32_t secinfo;
599 	uint32_t status;
600 #endif	/* _KERNEL */
601 
602 	ASSERT(cr);
603 	ASSERT(dnode);
604 	ASSERT(dnode->n_magic == SMB_NODE_MAGIC);
605 	ASSERT(dnode->n_state != SMB_NODE_STATE_DESTROYING);
606 
607 	ASSERT(ret_snode);
608 	*ret_snode = 0;
609 
610 	ASSERT(name);
611 	if (*name == 0)
612 		return (EINVAL);
613 
614 	ASSERT(sr);
615 	ASSERT(sr->tid_tree);
616 
617 	if (SMB_TREE_CONTAINS_NODE(sr, dnode) == 0)
618 		return (EACCES);
619 
620 	if (SMB_TREE_IS_READONLY(sr))
621 		return (EROFS);
622 	if (SMB_TREE_SUPPORTS_CATIA(sr))
623 		flags |= SMB_CATIA;
624 	if (SMB_TREE_SUPPORTS_ABE(sr))
625 		flags |= SMB_ABE;
626 
627 	if (SMB_TREE_SUPPORTS_SHORTNAMES(sr) && smb_maybe_mangled(name)) {
628 		longname = kmem_alloc(MAXNAMELEN, KM_SLEEP);
629 		rc = smb_unmangle(dnode, name, longname, MAXNAMELEN, flags);
630 		kmem_free(longname, MAXNAMELEN);
631 
632 		/*
633 		 * If the name passed in by the client has an unmangled
634 		 * equivalent that is found in the specified directory,
635 		 * then the mkdir cannot succeed.  Return EEXIST.
636 		 *
637 		 * Only if ENOENT is returned will a mkdir be attempted.
638 		 */
639 
640 		if (rc == 0)
641 			rc = EEXIST;
642 
643 		if (rc != ENOENT)
644 			return (rc);
645 	}
646 
647 	if (SMB_TREE_IS_CASEINSENSITIVE(sr))
648 		flags = SMB_IGNORE_CASE;
649 
650 #ifdef	_KERNEL
651 	if (op->sd) {
652 		/*
653 		 * SD sent by client in Windows format. Needs to be
654 		 * converted to FS format. Inherit DACL/SACL if they're not
655 		 * specified.
656 		 */
657 		secinfo = smb_sd_get_secinfo(op->sd);
658 
659 		if ((secinfo & SMB_SACL_SECINFO) != 0 &&
660 		    !smb_user_has_security_priv(sr->uid_user, cr))
661 			return (EPERM);
662 
663 		smb_fssd_init(&fs_sd, secinfo, SMB_FSSD_FLAGS_DIR);
664 
665 		status = smb_sd_tofs(op->sd, &fs_sd);
666 		if (status == NT_STATUS_SUCCESS) {
667 			rc = smb_fsop_sdinherit(sr, dnode, &fs_sd);
668 			if (rc == 0)
669 				rc = smb_fsop_create_with_sd(sr, cr, dnode,
670 				    name, attr, ret_snode, &fs_sd);
671 		}
672 		else
673 			rc = EINVAL;
674 		smb_fssd_term(&fs_sd);
675 	} else if (sr->tid_tree->t_acltype == ACE_T) {
676 		/*
677 		 * No incoming SD and filesystem is ZFS
678 		 * Server applies Windows inheritance rules,
679 		 * see smb_fsop_sdinherit() comments as to why.
680 		 */
681 		smb_fssd_init(&fs_sd, 0, SMB_FSSD_FLAGS_DIR);
682 		rc = smb_fsop_sdinherit(sr, dnode, &fs_sd);
683 		if (rc == 0) {
684 			rc = smb_fsop_create_with_sd(sr, cr, dnode,
685 			    name, attr, ret_snode, &fs_sd);
686 		}
687 
688 		smb_fssd_term(&fs_sd);
689 
690 	} else
691 #endif	/* _KERNEL */
692 	{
693 		rc = smb_vop_mkdir(dnode->vp, name, attr, &vp, flags, cr,
694 		    NULL);
695 
696 		if (rc == 0) {
697 			*ret_snode = smb_node_lookup(sr, op, cr, vp, name,
698 			    dnode, NULL);
699 
700 			if (*ret_snode == NULL)
701 				rc = ENOMEM;
702 
703 			VN_RELE(vp);
704 		}
705 	}
706 
707 	if (rc == 0)
708 		smb_node_notify_change(dnode, FILE_ACTION_ADDED, name);
709 
710 	return (rc);
711 }
712 
713 /*
714  * smb_fsop_remove
715  *
716  * All SMB functions should use this wrapper to ensure that
717  * the the calls are performed with the appropriate credentials.
718  * Please document any direct call to explain the reason
719  * for avoiding this wrapper.
720  *
721  * It is assumed that a reference exists on snode coming into this routine.
722  *
723  * A null smb_request might be passed to this function.
724  *
725  * Note that some stream "types" are "restricted" and only
726  * internal callers (cr == kcred) can remove those.
727  */
728 int
smb_fsop_remove(smb_request_t * sr,cred_t * cr,smb_node_t * dnode,char * name,uint32_t flags)729 smb_fsop_remove(
730     smb_request_t	*sr,
731     cred_t		*cr,
732     smb_node_t		*dnode,
733     char		*name,
734     uint32_t		flags)
735 {
736 	smb_node_t	*fnode;
737 	char		*longname;
738 	char		*fname;
739 	char		*sname;
740 	int		rc;
741 
742 	ASSERT(cr);
743 	/*
744 	 * The state of the node could be SMB_NODE_STATE_DESTROYING if this
745 	 * function is called during the deletion of the node (because of
746 	 * DELETE_ON_CLOSE).
747 	 */
748 	ASSERT(dnode);
749 	ASSERT(dnode->n_magic == SMB_NODE_MAGIC);
750 
751 	if (SMB_TREE_CONTAINS_NODE(sr, dnode) == 0 ||
752 	    SMB_TREE_HAS_ACCESS(sr, ACE_DELETE) == 0)
753 		return (EACCES);
754 
755 	if (SMB_TREE_IS_READONLY(sr))
756 		return (EROFS);
757 
758 	fname = kmem_alloc(MAXNAMELEN, KM_SLEEP);
759 	sname = kmem_alloc(MAXNAMELEN, KM_SLEEP);
760 
761 	if (dnode->flags & NODE_XATTR_DIR) {
762 		if (cr != zone_kcred() && smb_strname_restricted(name)) {
763 			rc = EACCES;
764 			goto out;
765 		}
766 
767 		fnode = dnode->n_dnode;
768 		rc = smb_vop_stream_remove(fnode->vp, name, flags, cr);
769 
770 		/* notify change to the unnamed stream */
771 		if ((rc == 0) && fnode->n_dnode) {
772 			smb_node_notify_change(fnode->n_dnode,
773 			    FILE_ACTION_REMOVED_STREAM, fnode->od_name);
774 		}
775 	} else if (smb_is_stream_name(name)) {
776 		smb_stream_parse_name(name, fname, sname);
777 
778 		if (cr != zone_kcred() && smb_strname_restricted(sname)) {
779 			rc = EACCES;
780 			goto out;
781 		}
782 
783 		/*
784 		 * Look up the unnamed stream (i.e. fname).
785 		 * Unmangle processing will be done on fname
786 		 * as well as any link target.
787 		 */
788 
789 		rc = smb_fsop_lookup(sr, cr, flags | SMB_FOLLOW_LINKS,
790 		    sr->tid_tree->t_snode, dnode, fname, &fnode);
791 
792 		if (rc != 0) {
793 			goto out;
794 		}
795 
796 		/*
797 		 * XXX
798 		 * Need to find out what permission is required by NTFS
799 		 * to remove a stream.
800 		 */
801 		rc = smb_vop_stream_remove(fnode->vp, sname, flags, cr);
802 
803 		smb_node_release(fnode);
804 
805 		/* notify change to the unnamed stream */
806 		if (rc == 0) {
807 			smb_node_notify_change(dnode,
808 			    FILE_ACTION_REMOVED_STREAM, fname);
809 		}
810 	} else {
811 		rc = smb_vop_remove(dnode->vp, name, flags, cr);
812 
813 		if (rc == ENOENT) {
814 			if (!SMB_TREE_SUPPORTS_SHORTNAMES(sr) ||
815 			    !smb_maybe_mangled(name)) {
816 				goto out;
817 			}
818 			longname = kmem_alloc(MAXNAMELEN, KM_SLEEP);
819 
820 			if (SMB_TREE_SUPPORTS_ABE(sr))
821 				flags |= SMB_ABE;
822 
823 			rc = smb_unmangle(dnode, name, longname, MAXNAMELEN,
824 			    flags);
825 
826 			if (rc == 0) {
827 				/*
828 				 * longname is the real (case-sensitive)
829 				 * on-disk name.
830 				 * We make sure we do a remove on this exact
831 				 * name, as the name was mangled and denotes
832 				 * a unique file.
833 				 */
834 				flags &= ~SMB_IGNORE_CASE;
835 				rc = smb_vop_remove(dnode->vp, longname,
836 				    flags, cr);
837 			}
838 			kmem_free(longname, MAXNAMELEN);
839 		}
840 		if (rc == 0) {
841 			smb_node_notify_change(dnode,
842 			    FILE_ACTION_REMOVED, name);
843 		}
844 	}
845 
846 out:
847 	kmem_free(fname, MAXNAMELEN);
848 	kmem_free(sname, MAXNAMELEN);
849 
850 	return (rc);
851 }
852 
853 /*
854  * smb_fsop_remove_streams
855  *
856  * This function removes a file's streams without removing the
857  * file itself.
858  *
859  * It is assumed that fnode is not a link.
860  */
861 uint32_t
smb_fsop_remove_streams(smb_request_t * sr,cred_t * cr,smb_node_t * fnode)862 smb_fsop_remove_streams(smb_request_t *sr, cred_t *cr, smb_node_t *fnode)
863 {
864 	int rc, flags = 0;
865 	smb_odir_t *od;
866 	smb_odirent_t *odirent;
867 	uint32_t status;
868 	boolean_t eos;
869 
870 	ASSERT(sr);
871 	ASSERT(cr);
872 	ASSERT(fnode);
873 	ASSERT(fnode->n_magic == SMB_NODE_MAGIC);
874 	ASSERT(fnode->n_state != SMB_NODE_STATE_DESTROYING);
875 
876 	if (SMB_TREE_CONTAINS_NODE(sr, fnode) == 0)
877 		return (NT_STATUS_ACCESS_DENIED);
878 
879 	if (SMB_TREE_IS_READONLY(sr))
880 		return (NT_STATUS_ACCESS_DENIED);
881 
882 	if (SMB_TREE_IS_CASEINSENSITIVE(sr))
883 		flags = SMB_IGNORE_CASE;
884 
885 	if (SMB_TREE_SUPPORTS_CATIA(sr))
886 		flags |= SMB_CATIA;
887 
888 	status = smb_odir_openat(sr, fnode, &od);
889 	switch (status) {
890 	case 0:
891 		break;
892 	case NT_STATUS_OBJECT_NAME_NOT_FOUND:
893 	case NT_STATUS_NO_SUCH_FILE:
894 	case NT_STATUS_NOT_SUPPORTED:
895 		/* No streams to remove. */
896 		return (0);
897 	default:
898 		return (status);
899 	}
900 
901 	odirent = kmem_alloc(sizeof (smb_odirent_t), KM_SLEEP);
902 	for (;;) {
903 		rc = smb_odir_read(sr, od, odirent, &eos);
904 		if ((rc != 0) || (eos))
905 			break;
906 		(void) smb_vop_remove(od->d_dnode->vp, odirent->od_name,
907 		    flags, cr);
908 	}
909 	kmem_free(odirent, sizeof (smb_odirent_t));
910 	if (eos && rc == ENOENT)
911 		rc = 0;
912 
913 	smb_odir_close(od);
914 	smb_odir_release(od);
915 	if (rc)
916 		status = smb_errno2status(rc);
917 	return (status);
918 }
919 
920 /*
921  * smb_fsop_rmdir
922  *
923  * All SMB functions should use this wrapper to ensure that
924  * the the calls are performed with the appropriate credentials.
925  * Please document any direct call to explain the reason
926  * for avoiding this wrapper.
927  *
928  * It is assumed that a reference exists on snode coming into this routine.
929  */
930 int
smb_fsop_rmdir(smb_request_t * sr,cred_t * cr,smb_node_t * dnode,char * name,uint32_t flags)931 smb_fsop_rmdir(
932     smb_request_t	*sr,
933     cred_t		*cr,
934     smb_node_t		*dnode,
935     char		*name,
936     uint32_t		flags)
937 {
938 	int		rc;
939 	char		*longname;
940 
941 	ASSERT(cr);
942 	/*
943 	 * The state of the node could be SMB_NODE_STATE_DESTROYING if this
944 	 * function is called during the deletion of the node (because of
945 	 * DELETE_ON_CLOSE).
946 	 */
947 	ASSERT(dnode);
948 	ASSERT(dnode->n_magic == SMB_NODE_MAGIC);
949 
950 	if (SMB_TREE_CONTAINS_NODE(sr, dnode) == 0 ||
951 	    SMB_TREE_HAS_ACCESS(sr, ACE_DELETE_CHILD) == 0)
952 		return (EACCES);
953 
954 	if (SMB_TREE_IS_READONLY(sr))
955 		return (EROFS);
956 
957 	rc = smb_vop_rmdir(dnode->vp, name, flags, cr);
958 
959 	if (rc == ENOENT) {
960 		if (!SMB_TREE_SUPPORTS_SHORTNAMES(sr) ||
961 		    !smb_maybe_mangled(name)) {
962 			return (rc);
963 		}
964 
965 		longname = kmem_alloc(MAXNAMELEN, KM_SLEEP);
966 
967 		if (SMB_TREE_SUPPORTS_ABE(sr))
968 			flags |= SMB_ABE;
969 		rc = smb_unmangle(dnode, name, longname, MAXNAMELEN, flags);
970 
971 		if (rc == 0) {
972 			/*
973 			 * longname is the real (case-sensitive)
974 			 * on-disk name.
975 			 * We make sure we do a rmdir on this exact
976 			 * name, as the name was mangled and denotes
977 			 * a unique directory.
978 			 */
979 			flags &= ~SMB_IGNORE_CASE;
980 			rc = smb_vop_rmdir(dnode->vp, longname, flags, cr);
981 		}
982 
983 		kmem_free(longname, MAXNAMELEN);
984 	}
985 
986 	if (rc == 0)
987 		smb_node_notify_change(dnode, FILE_ACTION_REMOVED, name);
988 
989 	return (rc);
990 }
991 
992 /*
993  * smb_fsop_getattr
994  *
995  * All SMB functions should use this wrapper to ensure that
996  * the the calls are performed with the appropriate credentials.
997  * Please document any direct call to explain the reason
998  * for avoiding this wrapper.
999  *
1000  * It is assumed that a reference exists on snode coming into this routine.
1001  */
1002 int
smb_fsop_getattr(smb_request_t * sr,cred_t * cr,smb_node_t * snode,smb_attr_t * attr)1003 smb_fsop_getattr(smb_request_t *sr, cred_t *cr, smb_node_t *snode,
1004     smb_attr_t *attr)
1005 {
1006 	smb_node_t *unnamed_node;
1007 	vnode_t *unnamed_vp = NULL;
1008 	uint32_t status;
1009 	uint32_t access = 0;
1010 	int flags = 0;
1011 	int rc;
1012 
1013 	ASSERT(cr);
1014 	ASSERT(snode);
1015 	ASSERT(snode->n_magic == SMB_NODE_MAGIC);
1016 	ASSERT(snode->n_state != SMB_NODE_STATE_DESTROYING);
1017 
1018 	if (SMB_TREE_CONTAINS_NODE(sr, snode) == 0 ||
1019 	    SMB_TREE_HAS_ACCESS(sr, ACE_READ_ATTRIBUTES) == 0)
1020 		return (EACCES);
1021 
1022 	/* sr could be NULL in some cases */
1023 	if (sr && sr->fid_ofile) {
1024 		/* if uid and/or gid is requested */
1025 		if (attr->sa_mask & (SMB_AT_UID|SMB_AT_GID))
1026 			access |= READ_CONTROL;
1027 
1028 		/* if anything else is also requested */
1029 		if (attr->sa_mask & ~(SMB_AT_UID|SMB_AT_GID))
1030 			access |= FILE_READ_ATTRIBUTES;
1031 
1032 		status = smb_ofile_access(sr->fid_ofile, cr, access);
1033 		if (status != NT_STATUS_SUCCESS)
1034 			return (EACCES);
1035 
1036 		if (smb_tree_has_feature(sr->tid_tree,
1037 		    SMB_TREE_ACEMASKONACCESS))
1038 			flags = ATTR_NOACLCHECK;
1039 	}
1040 
1041 	unnamed_node = SMB_IS_STREAM(snode);
1042 
1043 	if (unnamed_node) {
1044 		ASSERT(unnamed_node->n_magic == SMB_NODE_MAGIC);
1045 		ASSERT(unnamed_node->n_state != SMB_NODE_STATE_DESTROYING);
1046 		unnamed_vp = unnamed_node->vp;
1047 	}
1048 
1049 	rc = smb_vop_getattr(snode->vp, unnamed_vp, attr, flags, cr);
1050 
1051 	if ((rc == 0) && smb_node_is_dfslink(snode)) {
1052 		/* a DFS link should be treated as a directory */
1053 		attr->sa_dosattr |= FILE_ATTRIBUTE_DIRECTORY;
1054 	}
1055 
1056 	return (rc);
1057 }
1058 
1059 /*
1060  * smb_fsop_link
1061  *
1062  * All SMB functions should use this smb_vop_link wrapper to ensure that
1063  * the smb_vop_link is performed with the appropriate credentials.
1064  * Please document any direct call to smb_vop_link to explain the reason
1065  * for avoiding this wrapper.
1066  *
1067  * It is assumed that references exist on from_dnode and to_dnode coming
1068  * into this routine.
1069  */
1070 int
smb_fsop_link(smb_request_t * sr,cred_t * cr,smb_node_t * from_fnode,smb_node_t * to_dnode,char * to_name)1071 smb_fsop_link(smb_request_t *sr, cred_t *cr, smb_node_t *from_fnode,
1072     smb_node_t *to_dnode, char *to_name)
1073 {
1074 	char	*longname = NULL;
1075 	int	flags = 0;
1076 	int	rc;
1077 
1078 	ASSERT(sr);
1079 	ASSERT(sr->tid_tree);
1080 	ASSERT(cr);
1081 	ASSERT(to_dnode);
1082 	ASSERT(to_dnode->n_magic == SMB_NODE_MAGIC);
1083 	ASSERT(to_dnode->n_state != SMB_NODE_STATE_DESTROYING);
1084 	ASSERT(from_fnode);
1085 	ASSERT(from_fnode->n_magic == SMB_NODE_MAGIC);
1086 	ASSERT(from_fnode->n_state != SMB_NODE_STATE_DESTROYING);
1087 
1088 	if (SMB_TREE_CONTAINS_NODE(sr, from_fnode) == 0)
1089 		return (EACCES);
1090 
1091 	if (SMB_TREE_CONTAINS_NODE(sr, to_dnode) == 0)
1092 		return (EACCES);
1093 
1094 	if (SMB_TREE_IS_READONLY(sr))
1095 		return (EROFS);
1096 
1097 	if (SMB_TREE_IS_CASEINSENSITIVE(sr))
1098 		flags = SMB_IGNORE_CASE;
1099 	if (SMB_TREE_SUPPORTS_CATIA(sr))
1100 		flags |= SMB_CATIA;
1101 	if (SMB_TREE_SUPPORTS_ABE(sr))
1102 		flags |= SMB_ABE;
1103 
1104 	if (SMB_TREE_SUPPORTS_SHORTNAMES(sr) && smb_maybe_mangled(to_name)) {
1105 		longname = kmem_alloc(MAXNAMELEN, KM_SLEEP);
1106 		rc = smb_unmangle(to_dnode, to_name, longname,
1107 		    MAXNAMELEN, flags);
1108 		kmem_free(longname, MAXNAMELEN);
1109 
1110 		if (rc == 0)
1111 			rc = EEXIST;
1112 		if (rc != ENOENT)
1113 			return (rc);
1114 	}
1115 
1116 	rc = smb_vop_link(to_dnode->vp, from_fnode->vp, to_name, flags, cr);
1117 
1118 	if (rc == 0)
1119 		smb_node_notify_change(to_dnode, FILE_ACTION_ADDED, to_name);
1120 
1121 	return (rc);
1122 }
1123 
1124 /*
1125  * smb_fsop_rename
1126  *
1127  * All SMB functions should use this smb_vop_rename wrapper to ensure that
1128  * the smb_vop_rename is performed with the appropriate credentials.
1129  * Please document any direct call to smb_vop_rename to explain the reason
1130  * for avoiding this wrapper.
1131  *
1132  * It is assumed that references exist on from_dnode and to_dnode coming
1133  * into this routine.
1134  */
1135 int
smb_fsop_rename(smb_request_t * sr,cred_t * cr,smb_node_t * from_dnode,char * from_name,smb_node_t * to_dnode,char * to_name)1136 smb_fsop_rename(
1137     smb_request_t *sr,
1138     cred_t *cr,
1139     smb_node_t *from_dnode,
1140     char *from_name,
1141     smb_node_t *to_dnode,
1142     char *to_name)
1143 {
1144 	smb_node_t *from_snode;
1145 	smb_attr_t from_attr;
1146 	vnode_t *from_vp;
1147 	int flags = 0, ret_flags;
1148 	int rc;
1149 	boolean_t isdir;
1150 
1151 	ASSERT(cr);
1152 	ASSERT(from_dnode);
1153 	ASSERT(from_dnode->n_magic == SMB_NODE_MAGIC);
1154 	ASSERT(from_dnode->n_state != SMB_NODE_STATE_DESTROYING);
1155 
1156 	ASSERT(to_dnode);
1157 	ASSERT(to_dnode->n_magic == SMB_NODE_MAGIC);
1158 	ASSERT(to_dnode->n_state != SMB_NODE_STATE_DESTROYING);
1159 
1160 	if (SMB_TREE_CONTAINS_NODE(sr, from_dnode) == 0)
1161 		return (EACCES);
1162 
1163 	if (SMB_TREE_CONTAINS_NODE(sr, to_dnode) == 0)
1164 		return (EACCES);
1165 
1166 	ASSERT(sr);
1167 	ASSERT(sr->tid_tree);
1168 	if (SMB_TREE_IS_READONLY(sr))
1169 		return (EROFS);
1170 
1171 	/*
1172 	 * Note: There is no need to check SMB_TREE_IS_CASEINSENSITIVE
1173 	 * here.
1174 	 *
1175 	 * A case-sensitive rename is always done in this routine
1176 	 * because we are using the on-disk name from an earlier lookup.
1177 	 * If a mangled name was passed in by the caller (denoting a
1178 	 * deterministic lookup), then the exact file must be renamed
1179 	 * (i.e. SMB_IGNORE_CASE must not be passed to VOP_RENAME, or
1180 	 * else the underlying file system might return a "first-match"
1181 	 * on this on-disk name, possibly resulting in the wrong file).
1182 	 */
1183 
1184 	if (SMB_TREE_SUPPORTS_CATIA(sr))
1185 		flags |= SMB_CATIA;
1186 
1187 	/*
1188 	 * XXX: Lock required through smb_node_release() below?
1189 	 */
1190 
1191 	rc = smb_vop_lookup(from_dnode->vp, from_name, &from_vp, NULL,
1192 	    flags, &ret_flags, NULL, &from_attr, cr);
1193 
1194 	if (rc != 0)
1195 		return (rc);
1196 
1197 	if (from_attr.sa_dosattr & FILE_ATTRIBUTE_REPARSE_POINT) {
1198 		VN_RELE(from_vp);
1199 		return (EACCES);
1200 	}
1201 
1202 	isdir = ((from_attr.sa_dosattr & FILE_ATTRIBUTE_DIRECTORY) != 0);
1203 
1204 	if ((isdir && SMB_TREE_HAS_ACCESS(sr,
1205 	    ACE_DELETE_CHILD | ACE_ADD_SUBDIRECTORY) !=
1206 	    (ACE_DELETE_CHILD | ACE_ADD_SUBDIRECTORY)) ||
1207 	    (!isdir && SMB_TREE_HAS_ACCESS(sr, ACE_DELETE | ACE_ADD_FILE) !=
1208 	    (ACE_DELETE | ACE_ADD_FILE))) {
1209 		VN_RELE(from_vp);
1210 		return (EACCES);
1211 	}
1212 
1213 	/*
1214 	 * SMB checks access on open and retains an access granted
1215 	 * mask for use while the file is open.  ACL changes should
1216 	 * not affect access to an open file.
1217 	 *
1218 	 * If the rename is being performed on an ofile:
1219 	 * - Check the ofile's access granted mask to see if the
1220 	 *   rename is permitted - requires DELETE access.
1221 	 * - If the file system does access checking, set the
1222 	 *   ATTR_NOACLCHECK flag to ensure that the file system
1223 	 *   does not check permissions on subsequent calls.
1224 	 */
1225 	if (sr && sr->fid_ofile) {
1226 		rc = smb_ofile_access(sr->fid_ofile, cr, DELETE);
1227 		if (rc != NT_STATUS_SUCCESS) {
1228 			VN_RELE(from_vp);
1229 			return (EACCES);
1230 		}
1231 
1232 		if (smb_tree_has_feature(sr->tid_tree,
1233 		    SMB_TREE_ACEMASKONACCESS))
1234 			flags = ATTR_NOACLCHECK;
1235 	}
1236 
1237 	rc = smb_vop_rename(from_dnode->vp, from_name, to_dnode->vp,
1238 	    to_name, flags, cr);
1239 
1240 	if (rc == 0) {
1241 		from_snode = smb_node_lookup(sr, NULL, cr, from_vp, from_name,
1242 		    from_dnode, NULL);
1243 
1244 		if (from_snode == NULL) {
1245 			rc = ENOMEM;
1246 		} else {
1247 			smb_node_rename(from_dnode, from_snode,
1248 			    to_dnode, to_name);
1249 			smb_node_release(from_snode);
1250 		}
1251 	}
1252 	VN_RELE(from_vp);
1253 
1254 	if (rc == 0) {
1255 		if (from_dnode == to_dnode) {
1256 			smb_node_notify_change(from_dnode,
1257 			    FILE_ACTION_RENAMED_OLD_NAME, from_name);
1258 			smb_node_notify_change(to_dnode,
1259 			    FILE_ACTION_RENAMED_NEW_NAME, to_name);
1260 		} else {
1261 			smb_node_notify_change(from_dnode,
1262 			    FILE_ACTION_REMOVED, from_name);
1263 			smb_node_notify_change(to_dnode,
1264 			    FILE_ACTION_ADDED, to_name);
1265 		}
1266 	}
1267 
1268 	/* XXX: unlock */
1269 
1270 	return (rc);
1271 }
1272 
1273 /*
1274  * smb_fsop_setattr
1275  *
1276  * All SMB functions should use this wrapper to ensure that
1277  * the the calls are performed with the appropriate credentials.
1278  * Please document any direct call to explain the reason
1279  * for avoiding this wrapper.
1280  *
1281  * It is assumed that a reference exists on snode coming into
1282  * this function.
1283  * A null smb_request might be passed to this function.
1284  */
1285 int
smb_fsop_setattr(smb_request_t * sr,cred_t * cr,smb_node_t * snode,smb_attr_t * set_attr)1286 smb_fsop_setattr(
1287     smb_request_t	*sr,
1288     cred_t		*cr,
1289     smb_node_t		*snode,
1290     smb_attr_t		*set_attr)
1291 {
1292 	smb_node_t *unnamed_node;
1293 	vnode_t *unnamed_vp = NULL;
1294 	uint32_t status;
1295 	uint32_t access;
1296 	int rc = 0;
1297 	int flags = 0;
1298 	uint_t sa_mask;
1299 
1300 	ASSERT(cr);
1301 	ASSERT(snode);
1302 	ASSERT(snode->n_magic == SMB_NODE_MAGIC);
1303 	ASSERT(snode->n_state != SMB_NODE_STATE_DESTROYING);
1304 
1305 	if (SMB_TREE_CONTAINS_NODE(sr, snode) == 0)
1306 		return (EACCES);
1307 
1308 	if (SMB_TREE_IS_READONLY(sr))
1309 		return (EROFS);
1310 
1311 	if (SMB_TREE_HAS_ACCESS(sr,
1312 	    ACE_WRITE_ATTRIBUTES | ACE_WRITE_NAMED_ATTRS) == 0)
1313 		return (EACCES);
1314 
1315 	/*
1316 	 * SMB checks access on open and retains an access granted
1317 	 * mask for use while the file is open.  ACL changes should
1318 	 * not affect access to an open file.
1319 	 *
1320 	 * If the setattr is being performed on an ofile:
1321 	 * - Check the ofile's access granted mask to see if the
1322 	 *   setattr is permitted.
1323 	 *   UID, GID - require WRITE_OWNER
1324 	 *   SIZE, ALLOCSZ - require FILE_WRITE_DATA
1325 	 *   all other attributes require FILE_WRITE_ATTRIBUTES
1326 	 *
1327 	 * - If the file system does access checking, set the
1328 	 *   ATTR_NOACLCHECK flag to ensure that the file system
1329 	 *   does not check permissions on subsequent calls.
1330 	 */
1331 	if (sr && sr->fid_ofile) {
1332 		sa_mask = set_attr->sa_mask;
1333 		access = 0;
1334 
1335 		if (sa_mask & (SMB_AT_SIZE | SMB_AT_ALLOCSZ)) {
1336 			access |= FILE_WRITE_DATA;
1337 			sa_mask &= ~(SMB_AT_SIZE | SMB_AT_ALLOCSZ);
1338 		}
1339 
1340 		if (sa_mask & (SMB_AT_UID|SMB_AT_GID)) {
1341 			access |= WRITE_OWNER;
1342 			sa_mask &= ~(SMB_AT_UID|SMB_AT_GID);
1343 		}
1344 
1345 		if (sa_mask)
1346 			access |= FILE_WRITE_ATTRIBUTES;
1347 
1348 		status = smb_ofile_access(sr->fid_ofile, cr, access);
1349 		if (status != NT_STATUS_SUCCESS)
1350 			return (EACCES);
1351 
1352 		if (smb_tree_has_feature(sr->tid_tree,
1353 		    SMB_TREE_ACEMASKONACCESS))
1354 			flags = ATTR_NOACLCHECK;
1355 	}
1356 
1357 	unnamed_node = SMB_IS_STREAM(snode);
1358 
1359 	if (unnamed_node) {
1360 		ASSERT(unnamed_node->n_magic == SMB_NODE_MAGIC);
1361 		ASSERT(unnamed_node->n_state != SMB_NODE_STATE_DESTROYING);
1362 		unnamed_vp = unnamed_node->vp;
1363 	}
1364 
1365 	rc = smb_vop_setattr(snode->vp, unnamed_vp, set_attr, flags, cr);
1366 	return (rc);
1367 }
1368 
1369 /*
1370  * Support for SMB2 setinfo FileValidDataLengthInformation.
1371  * Free (zero out) data in the range off, off+len
1372  */
1373 int
smb_fsop_freesp(smb_request_t * sr,cred_t * cr,smb_ofile_t * ofile,off64_t off,off64_t len)1374 smb_fsop_freesp(
1375     smb_request_t	*sr,
1376     cred_t		*cr,
1377     smb_ofile_t		*ofile,
1378     off64_t		off,
1379     off64_t		len)
1380 {
1381 	flock64_t flk;
1382 	smb_node_t *node = ofile->f_node;
1383 	uint32_t status;
1384 	uint32_t access = FILE_WRITE_DATA;
1385 	int rc;
1386 
1387 	ASSERT(cr);
1388 	ASSERT(node);
1389 	ASSERT(node->n_magic == SMB_NODE_MAGIC);
1390 	ASSERT(node->n_state != SMB_NODE_STATE_DESTROYING);
1391 
1392 	if (SMB_TREE_CONTAINS_NODE(sr, node) == 0)
1393 		return (EACCES);
1394 
1395 	if (SMB_TREE_IS_READONLY(sr))
1396 		return (EROFS);
1397 
1398 	if (SMB_TREE_HAS_ACCESS(sr, access) == 0)
1399 		return (EACCES);
1400 
1401 	/*
1402 	 * SMB checks access on open and retains an access granted
1403 	 * mask for use while the file is open.  ACL changes should
1404 	 * not affect access to an open file.
1405 	 *
1406 	 * If the setattr is being performed on an ofile:
1407 	 * - Check the ofile's access granted mask to see if this
1408 	 *   modification should be permitted (FILE_WRITE_DATA)
1409 	 */
1410 	status = smb_ofile_access(sr->fid_ofile, cr, access);
1411 	if (status != NT_STATUS_SUCCESS)
1412 		return (EACCES);
1413 
1414 	bzero(&flk, sizeof (flk));
1415 	flk.l_start = off;
1416 	flk.l_len = len;
1417 
1418 	rc = smb_vop_space(node->vp, F_FREESP, &flk, FWRITE, 0LL, cr);
1419 	return (rc);
1420 }
1421 
1422 /*
1423  * smb_fsop_read
1424  *
1425  * All SMB functions should use this wrapper to ensure that
1426  * the the calls are performed with the appropriate credentials.
1427  * Please document any direct call to explain the reason
1428  * for avoiding this wrapper.
1429  *
1430  * It is assumed that a reference exists on snode coming into this routine.
1431  * Note that ofile may be different from sr->fid_ofile, or may be NULL.
1432  */
1433 int
smb_fsop_read(smb_request_t * sr,cred_t * cr,smb_node_t * snode,smb_ofile_t * ofile,uio_t * uio,int ioflag)1434 smb_fsop_read(smb_request_t *sr, cred_t *cr, smb_node_t *snode,
1435     smb_ofile_t *ofile, uio_t *uio, int ioflag)
1436 {
1437 	caller_context_t ct;
1438 	cred_t *kcr = zone_kcred();
1439 	uint32_t amask;
1440 	int svmand;
1441 	int rc;
1442 
1443 	ASSERT(cr);
1444 	ASSERT(snode);
1445 	ASSERT(snode->n_magic == SMB_NODE_MAGIC);
1446 	ASSERT(snode->n_state != SMB_NODE_STATE_DESTROYING);
1447 
1448 	ASSERT(sr);
1449 
1450 	if (ofile != NULL) {
1451 		/*
1452 		 * Check tree access.  Not SMB_TREE_HAS_ACCESS
1453 		 * because we need to use ofile->f_tree
1454 		 */
1455 		if ((ofile->f_tree->t_access & ACE_READ_DATA) == 0)
1456 			return (EACCES);
1457 
1458 		/*
1459 		 * Check ofile access.  Use in-line smb_ofile_access
1460 		 * so we can check both amask bits at the same time.
1461 		 * If any bit in amask is granted, allow this read.
1462 		 */
1463 		amask = FILE_READ_DATA;
1464 		if (sr->smb_flg2 & SMB_FLAGS2_READ_IF_EXECUTE)
1465 			amask |= FILE_EXECUTE;
1466 		if (cr != kcr && (ofile->f_granted_access & amask) == 0)
1467 			return (EACCES);
1468 	}
1469 
1470 	/*
1471 	 * Streams permission are checked against the unnamed stream,
1472 	 * but in FS level they have their own permissions. To avoid
1473 	 * rejection by FS due to lack of permission on the actual
1474 	 * extended attr kcred is passed for streams.
1475 	 */
1476 	if (SMB_IS_STREAM(snode))
1477 		cr = kcr;
1478 
1479 	smb_node_start_crit(snode, RW_READER);
1480 	rc = nbl_svmand(snode->vp, kcr, &svmand);
1481 	if (rc) {
1482 		smb_node_end_crit(snode);
1483 		return (rc);
1484 	}
1485 
1486 	/*
1487 	 * Note: SMB allows a zero-byte read, which should not
1488 	 * conflict with any locks.  However nbl_lock_conflict
1489 	 * takes a zero-byte length as lock to EOF, so we must
1490 	 * special case that here.
1491 	 */
1492 	if (uio->uio_resid > 0) {
1493 		ct = smb_ct;
1494 		if (ofile != NULL)
1495 			ct.cc_pid = ofile->f_uniqid;
1496 		rc = nbl_lock_conflict(snode->vp, NBL_READ, uio->uio_loffset,
1497 		    uio->uio_resid, svmand, &ct);
1498 		if (rc != 0) {
1499 			smb_node_end_crit(snode);
1500 			return (ERANGE);
1501 		}
1502 	}
1503 
1504 	rc = smb_vop_read(snode->vp, uio, ioflag, cr);
1505 	smb_node_end_crit(snode);
1506 
1507 	return (rc);
1508 }
1509 
1510 /*
1511  * smb_fsop_write
1512  *
1513  * It is assumed that a reference exists on snode coming into this routine.
1514  * Note that ofile may be different from sr->fid_ofile, or may be NULL.
1515  */
1516 int
smb_fsop_write(smb_request_t * sr,cred_t * cr,smb_node_t * snode,smb_ofile_t * ofile,uio_t * uio,uint32_t * lcount,int ioflag)1517 smb_fsop_write(
1518     smb_request_t *sr,
1519     cred_t *cr,
1520     smb_node_t *snode,
1521     smb_ofile_t *ofile,
1522     uio_t *uio,
1523     uint32_t *lcount,
1524     int ioflag)
1525 {
1526 	caller_context_t ct;
1527 	smb_attr_t attr;
1528 	cred_t *kcr = zone_kcred();
1529 	smb_node_t *u_node;
1530 	vnode_t *u_vp = NULL;
1531 	vnode_t *vp;
1532 	uint32_t amask;
1533 	int svmand;
1534 	int rc;
1535 
1536 	ASSERT(cr);
1537 	ASSERT(snode);
1538 	ASSERT(snode->n_magic == SMB_NODE_MAGIC);
1539 	ASSERT(snode->n_state != SMB_NODE_STATE_DESTROYING);
1540 
1541 	ASSERT(sr);
1542 	vp = snode->vp;
1543 
1544 	if (ofile != NULL) {
1545 		amask = FILE_WRITE_DATA | FILE_APPEND_DATA;
1546 
1547 		/* Check tree access. */
1548 		if ((ofile->f_tree->t_access & amask) == 0)
1549 			return (EROFS);
1550 
1551 		/*
1552 		 * Check ofile access.  Use in-line smb_ofile_access
1553 		 * so we can check both amask bits at the same time.
1554 		 * If any bit in amask is granted, allow this write.
1555 		 */
1556 		if (cr != kcr && (ofile->f_granted_access & amask) == 0)
1557 			return (EACCES);
1558 	}
1559 
1560 	/*
1561 	 * Streams permission are checked against the unnamed stream,
1562 	 * but in FS level they have their own permissions. To avoid
1563 	 * rejection by FS due to lack of permission on the actual
1564 	 * extended attr kcred is passed for streams.
1565 	 */
1566 	u_node = SMB_IS_STREAM(snode);
1567 	if (u_node != NULL) {
1568 		ASSERT(u_node->n_magic == SMB_NODE_MAGIC);
1569 		ASSERT(u_node->n_state != SMB_NODE_STATE_DESTROYING);
1570 		u_vp = u_node->vp;
1571 		cr = kcr;
1572 	}
1573 
1574 	smb_node_start_crit(snode, RW_READER);
1575 	rc = nbl_svmand(vp, kcr, &svmand);
1576 	if (rc) {
1577 		smb_node_end_crit(snode);
1578 		return (rc);
1579 	}
1580 
1581 	/*
1582 	 * Note: SMB allows a zero-byte write, which should not
1583 	 * conflict with any locks.  However nbl_lock_conflict
1584 	 * takes a zero-byte length as lock to EOF, so we must
1585 	 * special case that here.
1586 	 */
1587 	if (uio->uio_resid > 0) {
1588 		ct = smb_ct;
1589 		if (ofile != NULL)
1590 			ct.cc_pid = ofile->f_uniqid;
1591 		rc = nbl_lock_conflict(vp, NBL_WRITE, uio->uio_loffset,
1592 		    uio->uio_resid, svmand, &ct);
1593 		if (rc != 0) {
1594 			smb_node_end_crit(snode);
1595 			return (ERANGE);
1596 		}
1597 	}
1598 
1599 	rc = smb_vop_write(vp, uio, ioflag, lcount, cr);
1600 
1601 	/*
1602 	 * Once the mtime has been set via this ofile, the
1603 	 * automatic mtime changes from writes via this ofile
1604 	 * should cease, preserving the mtime that was set.
1605 	 * See: [MS-FSA] 2.1.5.14 and smb_node_setattr.
1606 	 *
1607 	 * The VFS interface does not offer a way to ask it to
1608 	 * skip the mtime updates, so we simulate the desired
1609 	 * behavior by re-setting the mtime after writes on a
1610 	 * handle where the mtime has been set.
1611 	 */
1612 	if (ofile != NULL &&
1613 	    (ofile->f_pending_attr.sa_mask & SMB_AT_MTIME) != 0) {
1614 		bcopy(&ofile->f_pending_attr, &attr, sizeof (attr));
1615 		attr.sa_mask = SMB_AT_MTIME;
1616 		(void) smb_vop_setattr(vp, u_vp, &attr, 0, kcr);
1617 	}
1618 
1619 	smb_node_end_crit(snode);
1620 
1621 	return (rc);
1622 }
1623 
1624 /*
1625  * Find the next allocated range starting at or after
1626  * the offset (*datap), returning the start/end of
1627  * that range in (*datap, *holep)
1628  */
1629 int
smb_fsop_next_alloc_range(cred_t * cr,smb_node_t * node,off64_t * datap,off64_t * holep)1630 smb_fsop_next_alloc_range(
1631     cred_t *cr,
1632     smb_node_t *node,
1633     off64_t *datap,
1634     off64_t *holep)
1635 {
1636 	int err;
1637 
1638 	err = smb_vop_ioctl(node->vp, _FIO_SEEK_DATA, datap, cr);
1639 	if (err != 0)
1640 		return (err);
1641 
1642 	*holep = *datap;
1643 	err = smb_vop_ioctl(node->vp, _FIO_SEEK_HOLE, holep, cr);
1644 
1645 	return (err);
1646 }
1647 
1648 /*
1649  * smb_fsop_statfs
1650  *
1651  * This is a wrapper function used for stat operations.
1652  */
1653 int
smb_fsop_statfs(cred_t * cr,smb_node_t * snode,struct statvfs64 * statp)1654 smb_fsop_statfs(
1655     cred_t *cr,
1656     smb_node_t *snode,
1657     struct statvfs64 *statp)
1658 {
1659 	ASSERT(cr);
1660 	ASSERT(snode);
1661 	ASSERT(snode->n_magic == SMB_NODE_MAGIC);
1662 	ASSERT(snode->n_state != SMB_NODE_STATE_DESTROYING);
1663 
1664 	return (smb_vop_statfs(snode->vp, statp, cr));
1665 }
1666 
1667 /*
1668  * smb_fsop_access
1669  *
1670  * Named streams do not have separate permissions from the associated
1671  * unnamed stream.  Thus, if node is a named stream, the permissions
1672  * check will be performed on the associated unnamed stream.
1673  *
1674  * However, our named streams do have their own quarantine attribute,
1675  * separate from that on the unnamed stream. If READ or EXECUTE
1676  * access has been requested on a named stream, an additional access
1677  * check is performed on the named stream in case it has been
1678  * quarantined.  kcred is used to avoid issues with the permissions
1679  * set on the extended attribute file representing the named stream.
1680  *
1681  * Note that some stream "types" are "restricted" and only
1682  * internal callers (cr == kcred) can access those.
1683  */
1684 int
smb_fsop_access(smb_request_t * sr,cred_t * cr,smb_node_t * snode,uint32_t faccess)1685 smb_fsop_access(smb_request_t *sr, cred_t *cr, smb_node_t *snode,
1686     uint32_t faccess)
1687 {
1688 	int access = 0;
1689 	int error;
1690 	vnode_t *dir_vp;
1691 	boolean_t acl_check = B_TRUE;
1692 	smb_node_t *unnamed_node;
1693 
1694 	ASSERT(sr);
1695 	ASSERT(cr);
1696 	ASSERT(snode);
1697 	ASSERT(snode->n_magic == SMB_NODE_MAGIC);
1698 	ASSERT(snode->n_state != SMB_NODE_STATE_DESTROYING);
1699 
1700 	if (SMB_TREE_IS_READONLY(sr)) {
1701 		if (faccess & (FILE_WRITE_DATA|FILE_APPEND_DATA|
1702 		    FILE_WRITE_EA|FILE_DELETE_CHILD|FILE_WRITE_ATTRIBUTES|
1703 		    DELETE|WRITE_DAC|WRITE_OWNER)) {
1704 			return (NT_STATUS_ACCESS_DENIED);
1705 		}
1706 	}
1707 
1708 	if (smb_node_is_reparse(snode) && (faccess & DELETE))
1709 		return (NT_STATUS_ACCESS_DENIED);
1710 
1711 	unnamed_node = SMB_IS_STREAM(snode);
1712 	if (unnamed_node) {
1713 		cred_t *kcr = zone_kcred();
1714 
1715 		ASSERT(unnamed_node->n_magic == SMB_NODE_MAGIC);
1716 		ASSERT(unnamed_node->n_state != SMB_NODE_STATE_DESTROYING);
1717 
1718 		if (cr != kcr && smb_strname_restricted(snode->od_name))
1719 			return (NT_STATUS_ACCESS_DENIED);
1720 
1721 		/*
1722 		 * Perform VREAD access check on the named stream in case it
1723 		 * is quarantined. kcred is passed to smb_vop_access so it
1724 		 * doesn't fail due to lack of permission.
1725 		 */
1726 		if (faccess & (FILE_READ_DATA | FILE_EXECUTE)) {
1727 			error = smb_vop_access(snode->vp, VREAD,
1728 			    0, NULL, kcr);
1729 			if (error)
1730 				return (NT_STATUS_ACCESS_DENIED);
1731 		}
1732 
1733 		/*
1734 		 * Streams authorization should be performed against the
1735 		 * unnamed stream.
1736 		 */
1737 		snode = unnamed_node;
1738 	}
1739 
1740 	if (faccess & ACCESS_SYSTEM_SECURITY) {
1741 		/*
1742 		 * This permission is required for reading/writing SACL and
1743 		 * it's not part of DACL. It's only granted via proper
1744 		 * privileges.
1745 		 */
1746 		if (!smb_user_has_security_priv(sr->uid_user, cr))
1747 			return (NT_STATUS_PRIVILEGE_NOT_HELD);
1748 
1749 		faccess &= ~ACCESS_SYSTEM_SECURITY;
1750 	}
1751 
1752 	/* Links don't have ACL */
1753 	if ((!smb_tree_has_feature(sr->tid_tree, SMB_TREE_ACEMASKONACCESS)) ||
1754 	    smb_node_is_symlink(snode))
1755 		acl_check = B_FALSE;
1756 
1757 	/* Deny access based on the share access mask */
1758 
1759 	if ((faccess & ~sr->tid_tree->t_access) != 0)
1760 		return (NT_STATUS_ACCESS_DENIED);
1761 
1762 	if (acl_check) {
1763 		dir_vp = (snode->n_dnode) ? snode->n_dnode->vp : NULL;
1764 		error = smb_vop_access(snode->vp, faccess, V_ACE_MASK, dir_vp,
1765 		    cr);
1766 	} else {
1767 		/*
1768 		 * FS doesn't understand 32-bit mask, need to map
1769 		 */
1770 		if (faccess & (FILE_WRITE_DATA | FILE_APPEND_DATA))
1771 			access |= VWRITE;
1772 
1773 		if (faccess & FILE_READ_DATA)
1774 			access |= VREAD;
1775 
1776 		if (faccess & FILE_EXECUTE)
1777 			access |= VEXEC;
1778 
1779 		error = smb_vop_access(snode->vp, access, 0, NULL, cr);
1780 	}
1781 
1782 	return ((error) ? NT_STATUS_ACCESS_DENIED : NT_STATUS_SUCCESS);
1783 }
1784 
1785 /*
1786  * smb_fsop_lookup_name()
1787  *
1788  * Lookup both the file and stream specified in 'name'.
1789  * If name indicates that the file is a stream file, perform
1790  * stream specific lookup, otherwise call smb_fsop_lookup.
1791  *
1792  * On success, returns the found node in *ret_snode. This will be either a named
1793  * or unnamed stream node, depending on the name specified.
1794  *
1795  * Return an error if the looked-up file is in outside the tree.
1796  * (Required when invoked from open path.)
1797  *
1798  * Case sensitivity flags (SMB_IGNORE_CASE, SMB_CASE_SENSITIVE):
1799  * if SMB_CASE_SENSITIVE is set, the SMB_IGNORE_CASE flag will NOT be set
1800  * based on the tree's case sensitivity. However, if the SMB_IGNORE_CASE
1801  * flag is set in the flags value passed as a parameter, a case insensitive
1802  * lookup WILL be done (regardless of whether SMB_CASE_SENSITIVE is set
1803  * or not).
1804  */
1805 
1806 int
smb_fsop_lookup_name(smb_request_t * sr,cred_t * cr,int flags,smb_node_t * root_node,smb_node_t * dnode,char * name,smb_node_t ** ret_snode)1807 smb_fsop_lookup_name(
1808     smb_request_t *sr,
1809     cred_t	*cr,
1810     int		flags,
1811     smb_node_t	*root_node,
1812     smb_node_t	*dnode,
1813     char	*name,
1814     smb_node_t	**ret_snode)
1815 {
1816 	char *sname = NULL;
1817 	int rc;
1818 	smb_node_t *tmp_node;
1819 
1820 	ASSERT(ret_snode != NULL);
1821 
1822 	rc = smb_fsop_lookup_file(sr, cr, flags, root_node, dnode, name,
1823 	    &sname, ret_snode);
1824 
1825 	if (rc != 0 || sname == NULL)
1826 		return (rc);
1827 
1828 	tmp_node = *ret_snode;
1829 	rc = smb_fsop_lookup_stream(sr, cr, flags, root_node, tmp_node, sname,
1830 	    ret_snode);
1831 	kmem_free(sname, MAXNAMELEN);
1832 	smb_node_release(tmp_node);
1833 
1834 	return (rc);
1835 }
1836 
1837 /*
1838  * smb_fsop_lookup_file()
1839  *
1840  * Look up of the file portion of 'name'. If a Stream is specified,
1841  * return the stream name in 'sname', which this allocates.
1842  * The caller must free 'sname'.
1843  *
1844  * Return an error if the looked-up file is outside the tree.
1845  * (Required when invoked from open path.)
1846  *
1847  * Case sensitivity flags (SMB_IGNORE_CASE, SMB_CASE_SENSITIVE):
1848  * if SMB_CASE_SENSITIVE is set, the SMB_IGNORE_CASE flag will NOT be set
1849  * based on the tree's case sensitivity. However, if the SMB_IGNORE_CASE
1850  * flag is set in the flags value passed as a parameter, a case insensitive
1851  * lookup WILL be done (regardless of whether SMB_CASE_SENSITIVE is set
1852  * or not).
1853  */
1854 
1855 int
smb_fsop_lookup_file(smb_request_t * sr,cred_t * cr,int flags,smb_node_t * root_node,smb_node_t * dnode,char * name,char ** sname,smb_node_t ** ret_snode)1856 smb_fsop_lookup_file(
1857     smb_request_t *sr,
1858     cred_t	*cr,
1859     int		flags,
1860     smb_node_t	*root_node,
1861     smb_node_t	*dnode,
1862     char	*name,
1863     char	**sname,
1864     smb_node_t	**ret_snode)
1865 {
1866 	char		*fname;
1867 	int		rc;
1868 
1869 	ASSERT(cr);
1870 	ASSERT(dnode);
1871 	ASSERT(dnode->n_magic == SMB_NODE_MAGIC);
1872 	ASSERT(dnode->n_state != SMB_NODE_STATE_DESTROYING);
1873 	ASSERT(ret_snode != NULL);
1874 
1875 	/*
1876 	 * The following check is required for streams processing, below
1877 	 */
1878 
1879 	if (!(flags & SMB_CASE_SENSITIVE)) {
1880 		if (SMB_TREE_IS_CASEINSENSITIVE(sr))
1881 			flags |= SMB_IGNORE_CASE;
1882 	}
1883 
1884 	*sname = NULL;
1885 	if (smb_is_stream_name(name)) {
1886 		*sname = kmem_alloc(MAXNAMELEN, KM_SLEEP);
1887 		fname = kmem_alloc(MAXNAMELEN, KM_SLEEP);
1888 		smb_stream_parse_name(name, fname, *sname);
1889 
1890 		/*
1891 		 * Look up the unnamed stream (i.e. fname).
1892 		 * Unmangle processing will be done on fname
1893 		 * as well as any link target.
1894 		 */
1895 		rc = smb_fsop_lookup(sr, cr, flags, root_node, dnode,
1896 		    fname, ret_snode);
1897 		kmem_free(fname, MAXNAMELEN);
1898 	} else {
1899 		rc = smb_fsop_lookup(sr, cr, flags, root_node, dnode, name,
1900 		    ret_snode);
1901 	}
1902 
1903 	if (rc == 0) {
1904 		ASSERT(ret_snode);
1905 		if (SMB_TREE_CONTAINS_NODE(sr, *ret_snode) == 0) {
1906 			smb_node_release(*ret_snode);
1907 			*ret_snode = NULL;
1908 			rc = EACCES;
1909 		}
1910 	}
1911 
1912 	if (rc != 0 && *sname != NULL) {
1913 		kmem_free(*sname, MAXNAMELEN);
1914 		*sname = NULL;
1915 	}
1916 	return (rc);
1917 }
1918 
1919 /*
1920  * smb_fsop_lookup_stream
1921  *
1922  * The file exists, see if the stream exists.
1923  */
1924 int
smb_fsop_lookup_stream(smb_request_t * sr,cred_t * cr,int flags,smb_node_t * root_node,smb_node_t * fnode,char * sname,smb_node_t ** ret_snode)1925 smb_fsop_lookup_stream(
1926     smb_request_t *sr,
1927     cred_t *cr,
1928     int flags,
1929     smb_node_t *root_node,
1930     smb_node_t *fnode,
1931     char *sname,
1932     smb_node_t **ret_snode)
1933 {
1934 	char		*od_name;
1935 	vnode_t		*xattrdirvp;
1936 	vnode_t		*vp;
1937 	int rc;
1938 
1939 	/*
1940 	 * The following check is required for streams processing, below
1941 	 */
1942 
1943 	if (!(flags & SMB_CASE_SENSITIVE)) {
1944 		if (SMB_TREE_IS_CASEINSENSITIVE(sr))
1945 			flags |= SMB_IGNORE_CASE;
1946 	}
1947 
1948 	od_name = kmem_alloc(MAXNAMELEN, KM_SLEEP);
1949 
1950 	/*
1951 	 * od_name is the on-disk name of the stream, except
1952 	 * without the prepended stream prefix (SMB_STREAM_PREFIX)
1953 	 */
1954 
1955 	rc = smb_vop_stream_lookup(fnode->vp, sname, &vp, od_name,
1956 	    &xattrdirvp, flags, root_node->vp, cr);
1957 
1958 	if (rc != 0) {
1959 		kmem_free(od_name, MAXNAMELEN);
1960 		return (rc);
1961 	}
1962 
1963 	*ret_snode = smb_stream_node_lookup(sr, cr, fnode, xattrdirvp,
1964 	    vp, od_name);
1965 
1966 	kmem_free(od_name, MAXNAMELEN);
1967 	VN_RELE(xattrdirvp);
1968 	VN_RELE(vp);
1969 
1970 	if (*ret_snode == NULL)
1971 		return (ENOMEM);
1972 
1973 	return (rc);
1974 }
1975 
1976 /*
1977  * smb_fsop_lookup
1978  *
1979  * All SMB functions should use this smb_vop_lookup wrapper to ensure that
1980  * the smb_vop_lookup is performed with the appropriate credentials and using
1981  * case insensitive compares. Please document any direct call to smb_vop_lookup
1982  * to explain the reason for avoiding this wrapper.
1983  *
1984  * It is assumed that a reference exists on dnode coming into this routine
1985  * (and that it is safe from deallocation).
1986  *
1987  * Same with the root_node.
1988  *
1989  * *ret_snode is returned with a reference upon success.  No reference is
1990  * taken if an error is returned.
1991  *
1992  * Note: The returned ret_snode may be in a child mount.  This is ok for
1993  * readdir.
1994  *
1995  * Other smb_fsop_* routines will call SMB_TREE_CONTAINS_NODE() to prevent
1996  * operations on files not in the parent mount.
1997  *
1998  * Case sensitivity flags (SMB_IGNORE_CASE, SMB_CASE_SENSITIVE):
1999  * if SMB_CASE_SENSITIVE is set, the SMB_IGNORE_CASE flag will NOT be set
2000  * based on the tree's case sensitivity. However, if the SMB_IGNORE_CASE
2001  * flag is set in the flags value passed as a parameter, a case insensitive
2002  * lookup WILL be done (regardless of whether SMB_CASE_SENSITIVE is set
2003  * or not).
2004  */
2005 int
smb_fsop_lookup(smb_request_t * sr,cred_t * cr,int flags,smb_node_t * root_node,smb_node_t * dnode,char * name,smb_node_t ** ret_snode)2006 smb_fsop_lookup(
2007     smb_request_t *sr,
2008     cred_t	*cr,
2009     int		flags,
2010     smb_node_t	*root_node,
2011     smb_node_t	*dnode,
2012     char	*name,
2013     smb_node_t	**ret_snode)
2014 {
2015 	smb_node_t *lnk_target_node;
2016 	smb_node_t *lnk_dnode;
2017 	char *longname;
2018 	char *od_name;
2019 	vnode_t *vp;
2020 	int rc;
2021 	int ret_flags;
2022 	smb_attr_t attr;
2023 
2024 	ASSERT(cr);
2025 	ASSERT(dnode);
2026 	ASSERT(dnode->n_magic == SMB_NODE_MAGIC);
2027 	ASSERT(dnode->n_state != SMB_NODE_STATE_DESTROYING);
2028 
2029 	if (name == NULL)
2030 		return (EINVAL);
2031 
2032 	if (SMB_TREE_CONTAINS_NODE(sr, dnode) == 0)
2033 		return (EACCES);
2034 
2035 	if (!(flags & SMB_CASE_SENSITIVE)) {
2036 		if (SMB_TREE_IS_CASEINSENSITIVE(sr))
2037 			flags |= SMB_IGNORE_CASE;
2038 	}
2039 	if (SMB_TREE_SUPPORTS_CATIA(sr))
2040 		flags |= SMB_CATIA;
2041 	if (SMB_TREE_SUPPORTS_ABE(sr))
2042 		flags |= SMB_ABE;
2043 
2044 	/*
2045 	 * Can have "" or "." when opening named streams on a directory.
2046 	 */
2047 	if (name[0] == '\0' || (name[0] == '.' && name[1] == '\0')) {
2048 		smb_node_ref(dnode);
2049 		*ret_snode = dnode;
2050 		return (0);
2051 	}
2052 
2053 	od_name = kmem_alloc(MAXNAMELEN, KM_SLEEP);
2054 
2055 	rc = smb_vop_lookup(dnode->vp, name, &vp, od_name, flags,
2056 	    &ret_flags, root_node ? root_node->vp : NULL, &attr, cr);
2057 
2058 	if (rc != 0) {
2059 		if (!SMB_TREE_SUPPORTS_SHORTNAMES(sr) ||
2060 		    !smb_maybe_mangled(name)) {
2061 			kmem_free(od_name, MAXNAMELEN);
2062 			return (rc);
2063 		}
2064 
2065 		longname = kmem_alloc(MAXNAMELEN, KM_SLEEP);
2066 		rc = smb_unmangle(dnode, name, longname, MAXNAMELEN, flags);
2067 		if (rc != 0) {
2068 			kmem_free(od_name, MAXNAMELEN);
2069 			kmem_free(longname, MAXNAMELEN);
2070 			return (rc);
2071 		}
2072 
2073 		/*
2074 		 * longname is the real (case-sensitive)
2075 		 * on-disk name.
2076 		 * We make sure we do a lookup on this exact
2077 		 * name, as the name was mangled and denotes
2078 		 * a unique file.
2079 		 */
2080 
2081 		if (flags & SMB_IGNORE_CASE)
2082 			flags &= ~SMB_IGNORE_CASE;
2083 
2084 		rc = smb_vop_lookup(dnode->vp, longname, &vp, od_name,
2085 		    flags, &ret_flags, root_node ? root_node->vp : NULL, &attr,
2086 		    cr);
2087 
2088 		kmem_free(longname, MAXNAMELEN);
2089 
2090 		if (rc != 0) {
2091 			kmem_free(od_name, MAXNAMELEN);
2092 			return (rc);
2093 		}
2094 	}
2095 
2096 	if ((flags & SMB_FOLLOW_LINKS) && (vp->v_type == VLNK) &&
2097 	    ((attr.sa_dosattr & FILE_ATTRIBUTE_REPARSE_POINT) == 0)) {
2098 		rc = smb_pathname(sr, od_name, FOLLOW, root_node, dnode,
2099 		    &lnk_dnode, &lnk_target_node, cr, NULL);
2100 
2101 		if (rc != 0) {
2102 			/*
2103 			 * The link is assumed to be for the last component
2104 			 * of a path.  Hence any ENOTDIR error will be returned
2105 			 * as ENOENT.
2106 			 */
2107 			if (rc == ENOTDIR)
2108 				rc = ENOENT;
2109 
2110 			VN_RELE(vp);
2111 			kmem_free(od_name, MAXNAMELEN);
2112 			return (rc);
2113 		}
2114 
2115 		/*
2116 		 * Release the original VLNK vnode
2117 		 */
2118 
2119 		VN_RELE(vp);
2120 		vp = lnk_target_node->vp;
2121 
2122 		rc = smb_vop_traverse_check(&vp);
2123 
2124 		if (rc != 0) {
2125 			smb_node_release(lnk_dnode);
2126 			smb_node_release(lnk_target_node);
2127 			kmem_free(od_name, MAXNAMELEN);
2128 			return (rc);
2129 		}
2130 
2131 		/*
2132 		 * smb_vop_traverse_check() may have returned a different vnode
2133 		 */
2134 
2135 		if (lnk_target_node->vp == vp) {
2136 			*ret_snode = lnk_target_node;
2137 		} else {
2138 			*ret_snode = smb_node_lookup(sr, NULL, cr, vp,
2139 			    lnk_target_node->od_name, lnk_dnode, NULL);
2140 			VN_RELE(vp);
2141 
2142 			if (*ret_snode == NULL)
2143 				rc = ENOMEM;
2144 			smb_node_release(lnk_target_node);
2145 		}
2146 
2147 		smb_node_release(lnk_dnode);
2148 
2149 	} else {
2150 
2151 		rc = smb_vop_traverse_check(&vp);
2152 		if (rc) {
2153 			VN_RELE(vp);
2154 			kmem_free(od_name, MAXNAMELEN);
2155 			return (rc);
2156 		}
2157 
2158 		*ret_snode = smb_node_lookup(sr, NULL, cr, vp, od_name,
2159 		    dnode, NULL);
2160 		VN_RELE(vp);
2161 
2162 		if (*ret_snode == NULL)
2163 			rc = ENOMEM;
2164 	}
2165 
2166 	kmem_free(od_name, MAXNAMELEN);
2167 	return (rc);
2168 }
2169 
2170 int /*ARGSUSED*/
smb_fsop_commit(smb_request_t * sr,cred_t * cr,smb_node_t * snode)2171 smb_fsop_commit(smb_request_t *sr, cred_t *cr, smb_node_t *snode)
2172 {
2173 	ASSERT(cr);
2174 	ASSERT(snode);
2175 	ASSERT(snode->n_magic == SMB_NODE_MAGIC);
2176 	ASSERT(snode->n_state != SMB_NODE_STATE_DESTROYING);
2177 
2178 	ASSERT(sr);
2179 	ASSERT(sr->tid_tree);
2180 	if (SMB_TREE_IS_READONLY(sr))
2181 		return (EROFS);
2182 
2183 	return (smb_vop_commit(snode->vp, cr));
2184 }
2185 
2186 /*
2187  * smb_fsop_aclread
2188  *
2189  * Retrieve filesystem ACL. Depends on requested ACLs in
2190  * fs_sd->sd_secinfo, it'll set DACL and SACL pointers in
2191  * fs_sd. Note that requesting a DACL/SACL doesn't mean that
2192  * the corresponding field in fs_sd should be non-NULL upon
2193  * return, since the target ACL might not contain that type of
2194  * entries.
2195  *
2196  * Returned ACL is always in ACE_T (aka ZFS) format.
2197  * If successful the allocated memory for the ACL should be freed
2198  * using smb_fsacl_free() or smb_fssd_term()
2199  */
2200 int
smb_fsop_aclread(smb_request_t * sr,cred_t * cr,smb_node_t * snode,smb_fssd_t * fs_sd)2201 smb_fsop_aclread(smb_request_t *sr, cred_t *cr, smb_node_t *snode,
2202     smb_fssd_t *fs_sd)
2203 {
2204 	int error = 0;
2205 	int flags = 0;
2206 	int access = 0;
2207 	acl_t *acl;
2208 
2209 	ASSERT(cr);
2210 
2211 	/* Can't query security on named streams */
2212 	if (SMB_IS_STREAM(snode) != NULL)
2213 		return (EINVAL);
2214 
2215 	if (SMB_TREE_HAS_ACCESS(sr, ACE_READ_ACL) == 0)
2216 		return (EACCES);
2217 
2218 	if (sr->fid_ofile) {
2219 		if (fs_sd->sd_secinfo & SMB_DACL_SECINFO)
2220 			access = READ_CONTROL;
2221 
2222 		if (fs_sd->sd_secinfo & SMB_SACL_SECINFO)
2223 			access |= ACCESS_SYSTEM_SECURITY;
2224 
2225 		error = smb_ofile_access(sr->fid_ofile, cr, access);
2226 		if (error != NT_STATUS_SUCCESS) {
2227 			return (EACCES);
2228 		}
2229 	}
2230 
2231 
2232 	if (smb_tree_has_feature(sr->tid_tree, SMB_TREE_ACEMASKONACCESS))
2233 		flags = ATTR_NOACLCHECK;
2234 
2235 	error = smb_vop_acl_read(snode->vp, &acl, flags,
2236 	    sr->tid_tree->t_acltype, cr);
2237 	if (error != 0) {
2238 		return (error);
2239 	}
2240 
2241 	error = acl_translate(acl, _ACL_ACE_ENABLED,
2242 	    smb_node_is_dir(snode), fs_sd->sd_uid, fs_sd->sd_gid);
2243 
2244 	if (error == 0) {
2245 		smb_fsacl_split(acl, &fs_sd->sd_zdacl, &fs_sd->sd_zsacl,
2246 		    fs_sd->sd_secinfo);
2247 	}
2248 
2249 	acl_free(acl);
2250 	return (error);
2251 }
2252 
2253 /*
2254  * smb_fsop_aclwrite
2255  *
2256  * Stores the filesystem ACL provided in fs_sd->sd_acl.
2257  */
2258 int
smb_fsop_aclwrite(smb_request_t * sr,cred_t * cr,smb_node_t * snode,smb_fssd_t * fs_sd)2259 smb_fsop_aclwrite(smb_request_t *sr, cred_t *cr, smb_node_t *snode,
2260     smb_fssd_t *fs_sd)
2261 {
2262 	int target_flavor;
2263 	int error = 0;
2264 	int flags = 0;
2265 	int access = 0;
2266 	acl_t *acl, *dacl, *sacl;
2267 
2268 	ASSERT(cr);
2269 
2270 	ASSERT(sr);
2271 	ASSERT(sr->tid_tree);
2272 	if (SMB_TREE_IS_READONLY(sr))
2273 		return (EROFS);
2274 
2275 	/* Can't set security on named streams */
2276 	if (SMB_IS_STREAM(snode) != NULL)
2277 		return (EINVAL);
2278 
2279 	if (SMB_TREE_HAS_ACCESS(sr, ACE_WRITE_ACL) == 0)
2280 		return (EACCES);
2281 
2282 	if (sr->fid_ofile) {
2283 		if (fs_sd->sd_secinfo & SMB_DACL_SECINFO)
2284 			access = WRITE_DAC;
2285 
2286 		if (fs_sd->sd_secinfo & SMB_SACL_SECINFO)
2287 			access |= ACCESS_SYSTEM_SECURITY;
2288 
2289 		error = smb_ofile_access(sr->fid_ofile, cr, access);
2290 		if (error != NT_STATUS_SUCCESS)
2291 			return (EACCES);
2292 	}
2293 
2294 	switch (sr->tid_tree->t_acltype) {
2295 	case ACLENT_T:
2296 		target_flavor = _ACL_ACLENT_ENABLED;
2297 		break;
2298 
2299 	case ACE_T:
2300 		target_flavor = _ACL_ACE_ENABLED;
2301 		break;
2302 	default:
2303 		return (EINVAL);
2304 	}
2305 
2306 	dacl = fs_sd->sd_zdacl;
2307 	sacl = fs_sd->sd_zsacl;
2308 
2309 	ASSERT(dacl || sacl);
2310 	if ((dacl == NULL) && (sacl == NULL))
2311 		return (EINVAL);
2312 
2313 	if (dacl && sacl)
2314 		acl = smb_fsacl_merge(dacl, sacl);
2315 	else if (dacl)
2316 		acl = dacl;
2317 	else
2318 		acl = sacl;
2319 
2320 	error = acl_translate(acl, target_flavor, smb_node_is_dir(snode),
2321 	    fs_sd->sd_uid, fs_sd->sd_gid);
2322 	if (error == 0) {
2323 		if (smb_tree_has_feature(sr->tid_tree,
2324 		    SMB_TREE_ACEMASKONACCESS))
2325 			flags = ATTR_NOACLCHECK;
2326 
2327 		error = smb_vop_acl_write(snode->vp, acl, flags, cr);
2328 	}
2329 
2330 	if (dacl && sacl)
2331 		acl_free(acl);
2332 
2333 	return (error);
2334 }
2335 
2336 acl_type_t
smb_fsop_acltype(smb_node_t * snode)2337 smb_fsop_acltype(smb_node_t *snode)
2338 {
2339 	return (smb_vop_acl_type(snode->vp));
2340 }
2341 
2342 /*
2343  * smb_fsop_sdread
2344  *
2345  * Read the requested security descriptor items from filesystem.
2346  * The items are specified in fs_sd->sd_secinfo.
2347  */
2348 int
smb_fsop_sdread(smb_request_t * sr,cred_t * cr,smb_node_t * snode,smb_fssd_t * fs_sd)2349 smb_fsop_sdread(smb_request_t *sr, cred_t *cr, smb_node_t *snode,
2350     smb_fssd_t *fs_sd)
2351 {
2352 	int error = 0;
2353 	int getowner = 0;
2354 	cred_t *ga_cred;
2355 	smb_attr_t attr;
2356 
2357 	ASSERT(cr);
2358 	ASSERT(fs_sd);
2359 
2360 	/* Can't query security on named streams */
2361 	if (SMB_IS_STREAM(snode) != NULL)
2362 		return (EINVAL);
2363 
2364 	/*
2365 	 * File's uid/gid is fetched in two cases:
2366 	 *
2367 	 * 1. it's explicitly requested
2368 	 *
2369 	 * 2. target ACL is ACE_T (ZFS ACL). They're needed for
2370 	 *    owner@/group@ entries. In this case kcred should be used
2371 	 *    because uid/gid are fetched on behalf of smb server.
2372 	 */
2373 	if (fs_sd->sd_secinfo & (SMB_OWNER_SECINFO | SMB_GROUP_SECINFO)) {
2374 		getowner = 1;
2375 		ga_cred = cr;
2376 	} else if (sr->tid_tree->t_acltype == ACE_T) {
2377 		getowner = 1;
2378 		ga_cred = zone_kcred();
2379 	}
2380 
2381 	if (getowner) {
2382 		/*
2383 		 * Windows require READ_CONTROL to read owner/group SID since
2384 		 * they're part of Security Descriptor.
2385 		 * ZFS only requires read_attribute. Need to have a explicit
2386 		 * access check here.
2387 		 */
2388 		if (sr->fid_ofile == NULL) {
2389 			error = smb_fsop_access(sr, ga_cred, snode,
2390 			    READ_CONTROL);
2391 			if (error)
2392 				return (EACCES);
2393 		}
2394 
2395 		attr.sa_mask = SMB_AT_UID | SMB_AT_GID;
2396 		error = smb_fsop_getattr(sr, ga_cred, snode, &attr);
2397 		if (error == 0) {
2398 			fs_sd->sd_uid = attr.sa_vattr.va_uid;
2399 			fs_sd->sd_gid = attr.sa_vattr.va_gid;
2400 		} else {
2401 			return (error);
2402 		}
2403 	}
2404 
2405 	if (fs_sd->sd_secinfo & SMB_ACL_SECINFO) {
2406 		error = smb_fsop_aclread(sr, cr, snode, fs_sd);
2407 	}
2408 
2409 	return (error);
2410 }
2411 
2412 /*
2413  * smb_fsop_sdmerge
2414  *
2415  * From SMB point of view DACL and SACL are two separate list
2416  * which can be manipulated independently without one affecting
2417  * the other, but entries for both DACL and SACL will end up
2418  * in the same ACL if target filesystem supports ACE_T ACLs.
2419  *
2420  * So, if either DACL or SACL is present in the client set request
2421  * the entries corresponding to the non-present ACL shouldn't
2422  * be touched in the FS ACL.
2423  *
2424  * fs_sd parameter contains DACL and SACL specified by SMB
2425  * client to be set on a file/directory. The client could
2426  * specify both or one of these ACLs (if none is specified
2427  * we don't get this far). When both DACL and SACL are given
2428  * by client the existing ACL should be overwritten. If only
2429  * one of them is specified the entries corresponding to the other
2430  * ACL should not be touched. For example, if only DACL
2431  * is specified in input fs_sd, the function reads audit entries
2432  * of the existing ACL of the file and point fs_sd->sd_zsdacl
2433  * pointer to the fetched SACL, this way when smb_fsop_sdwrite()
2434  * function is called the passed fs_sd would point to the specified
2435  * DACL by client and fetched SACL from filesystem, so the file
2436  * will end up with correct ACL.
2437  */
2438 static int
smb_fsop_sdmerge(smb_request_t * sr,smb_node_t * snode,smb_fssd_t * fs_sd)2439 smb_fsop_sdmerge(smb_request_t *sr, smb_node_t *snode, smb_fssd_t *fs_sd)
2440 {
2441 	smb_fssd_t cur_sd;
2442 	cred_t *kcr = zone_kcred();
2443 	int error = 0;
2444 
2445 	if (sr->tid_tree->t_acltype != ACE_T)
2446 		/* Don't bother if target FS doesn't support ACE_T */
2447 		return (0);
2448 
2449 	if ((fs_sd->sd_secinfo & SMB_ACL_SECINFO) != SMB_ACL_SECINFO) {
2450 		if (fs_sd->sd_secinfo & SMB_DACL_SECINFO) {
2451 			/*
2452 			 * Don't overwrite existing audit entries
2453 			 */
2454 			smb_fssd_init(&cur_sd, SMB_SACL_SECINFO,
2455 			    fs_sd->sd_flags);
2456 
2457 			error = smb_fsop_sdread(sr, kcr, snode, &cur_sd);
2458 			if (error == 0) {
2459 				ASSERT(fs_sd->sd_zsacl == NULL);
2460 				fs_sd->sd_zsacl = cur_sd.sd_zsacl;
2461 				if (fs_sd->sd_zsacl && fs_sd->sd_zdacl)
2462 					fs_sd->sd_zsacl->acl_flags =
2463 					    fs_sd->sd_zdacl->acl_flags;
2464 			}
2465 		} else {
2466 			/*
2467 			 * Don't overwrite existing access entries
2468 			 */
2469 			smb_fssd_init(&cur_sd, SMB_DACL_SECINFO,
2470 			    fs_sd->sd_flags);
2471 
2472 			error = smb_fsop_sdread(sr, kcr, snode, &cur_sd);
2473 			if (error == 0) {
2474 				ASSERT(fs_sd->sd_zdacl == NULL);
2475 				fs_sd->sd_zdacl = cur_sd.sd_zdacl;
2476 				if (fs_sd->sd_zdacl && fs_sd->sd_zsacl)
2477 					fs_sd->sd_zdacl->acl_flags =
2478 					    fs_sd->sd_zsacl->acl_flags;
2479 			}
2480 		}
2481 
2482 		if (error)
2483 			smb_fssd_term(&cur_sd);
2484 	}
2485 
2486 	return (error);
2487 }
2488 
2489 /*
2490  * smb_fsop_sdwrite
2491  *
2492  * Stores the given uid, gid and acl in filesystem.
2493  * Provided items in fs_sd are specified by fs_sd->sd_secinfo.
2494  *
2495  * A SMB security descriptor could contain owner, primary group,
2496  * DACL and SACL. Setting an SD should be atomic but here it has to
2497  * be done via two separate FS operations: VOP_SETATTR and
2498  * VOP_SETSECATTR. Therefore, this function has to simulate the
2499  * atomicity as well as it can.
2500  *
2501  * Get the current uid, gid before setting the new uid/gid
2502  * so if smb_fsop_aclwrite fails they can be restored. root cred is
2503  * used to get currend uid/gid since this operation is performed on
2504  * behalf of the server not the user.
2505  *
2506  * If setting uid/gid fails with EPERM it means that and invalid
2507  * owner has been specified. Callers should translate this to
2508  * STATUS_INVALID_OWNER which is not the normal mapping for EPERM
2509  * in upper layers, so EPERM is mapped to EBADE.
2510  *
2511  * If 'overwrite' is non-zero, then the existing ACL is ignored.
2512  */
2513 int
smb_fsop_sdwrite(smb_request_t * sr,cred_t * cr,smb_node_t * snode,smb_fssd_t * fs_sd,int overwrite)2514 smb_fsop_sdwrite(smb_request_t *sr, cred_t *cr, smb_node_t *snode,
2515     smb_fssd_t *fs_sd, int overwrite)
2516 {
2517 	smb_attr_t set_attr;
2518 	smb_attr_t orig_attr;
2519 	cred_t *kcr = zone_kcred();
2520 	int error = 0;
2521 	int access = 0;
2522 
2523 	ASSERT(cr);
2524 	ASSERT(fs_sd);
2525 
2526 	ASSERT(sr);
2527 	ASSERT(sr->tid_tree);
2528 	if (SMB_TREE_IS_READONLY(sr))
2529 		return (EROFS);
2530 
2531 	/* Can't set security on named streams */
2532 	if (SMB_IS_STREAM(snode) != NULL)
2533 		return (EINVAL);
2534 
2535 	bzero(&set_attr, sizeof (smb_attr_t));
2536 
2537 	if (fs_sd->sd_secinfo & SMB_OWNER_SECINFO) {
2538 		set_attr.sa_vattr.va_uid = fs_sd->sd_uid;
2539 		set_attr.sa_mask |= SMB_AT_UID;
2540 		access |= WRITE_OWNER;
2541 	}
2542 
2543 	if (fs_sd->sd_secinfo & SMB_GROUP_SECINFO) {
2544 		set_attr.sa_vattr.va_gid = fs_sd->sd_gid;
2545 		set_attr.sa_mask |= SMB_AT_GID;
2546 		access |= WRITE_OWNER;
2547 	}
2548 
2549 	if (fs_sd->sd_secinfo & SMB_DACL_SECINFO)
2550 		access |= WRITE_DAC;
2551 
2552 	if (fs_sd->sd_secinfo & SMB_SACL_SECINFO)
2553 		access |= ACCESS_SYSTEM_SECURITY;
2554 
2555 	if (sr->fid_ofile)
2556 		error = smb_ofile_access(sr->fid_ofile, cr, access);
2557 	else
2558 		error = smb_fsop_access(sr, cr, snode, access);
2559 
2560 	if (error)
2561 		return (EACCES);
2562 
2563 	if (set_attr.sa_mask) {
2564 		orig_attr.sa_mask = SMB_AT_UID | SMB_AT_GID;
2565 		error = smb_fsop_getattr(sr, kcr, snode, &orig_attr);
2566 		if (error == 0) {
2567 			error = smb_fsop_setattr(sr, cr, snode, &set_attr);
2568 			if (error == EPERM)
2569 				error = EBADE;
2570 		}
2571 
2572 		if (error)
2573 			return (error);
2574 	}
2575 
2576 	if (fs_sd->sd_secinfo & SMB_ACL_SECINFO) {
2577 		if (overwrite == 0)
2578 			error = smb_fsop_sdmerge(sr, snode, fs_sd);
2579 
2580 		if (error == 0)
2581 			error = smb_fsop_aclwrite(sr, cr, snode, fs_sd);
2582 
2583 		if (error != 0) {
2584 			/*
2585 			 * Revert uid/gid changes if required.
2586 			 */
2587 			if (set_attr.sa_mask) {
2588 				orig_attr.sa_mask = set_attr.sa_mask;
2589 				(void) smb_fsop_setattr(sr, kcr, snode,
2590 				    &orig_attr);
2591 			}
2592 		}
2593 	}
2594 
2595 	return (error);
2596 }
2597 
2598 #ifdef	_KERNEL
2599 /*
2600  * smb_fsop_sdinherit
2601  *
2602  * Inherit the security descriptor from the parent container.
2603  * This function is called after FS has created the file/folder
2604  * so if this doesn't do anything it means FS inheritance is
2605  * in place.
2606  *
2607  * Do inheritance for ZFS internally.
2608  *
2609  * If we want to let ZFS does the inheritance the
2610  * following setting should be true:
2611  *
2612  *  - aclinherit = passthrough
2613  *  - aclmode = passthrough
2614  *  - smbd umask = 0777
2615  *
2616  * This will result in right effective permissions but
2617  * ZFS will always add 6 ACEs for owner, owning group
2618  * and others to be POSIX compliant. This is not what
2619  * Windows clients/users expect, so we decided that CIFS
2620  * implements Windows rules and overwrite whatever ZFS
2621  * comes up with. This way we also don't have to care
2622  * about ZFS aclinherit and aclmode settings.
2623  */
2624 static int
smb_fsop_sdinherit(smb_request_t * sr,smb_node_t * dnode,smb_fssd_t * fs_sd)2625 smb_fsop_sdinherit(smb_request_t *sr, smb_node_t *dnode, smb_fssd_t *fs_sd)
2626 {
2627 	acl_t *dacl = NULL;
2628 	acl_t *sacl = NULL;
2629 	int is_dir;
2630 	int error;
2631 	uint32_t secinfo;
2632 	smb_fssd_t pfs_sd;
2633 
2634 	ASSERT(fs_sd);
2635 
2636 	secinfo = fs_sd->sd_secinfo;
2637 
2638 	/* Anything to do? */
2639 	if ((secinfo & SMB_ACL_SECINFO) == SMB_ACL_SECINFO)
2640 		return (0);
2641 
2642 	/*
2643 	 * No forced inheritance for non-ZFS filesystems.
2644 	 */
2645 	if (sr->tid_tree->t_acltype != ACE_T)
2646 		return (0);
2647 
2648 	smb_fssd_init(&pfs_sd, SMB_ACL_SECINFO, fs_sd->sd_flags);
2649 
2650 	/* Fetch parent directory's ACL */
2651 	error = smb_fsop_sdread(sr, zone_kcred(), dnode, &pfs_sd);
2652 	if (error) {
2653 		return (error);
2654 	}
2655 
2656 	is_dir = (fs_sd->sd_flags & SMB_FSSD_FLAGS_DIR);
2657 	if ((secinfo & SMB_DACL_SECINFO) == 0) {
2658 		dacl = smb_fsacl_inherit(pfs_sd.sd_zdacl, is_dir,
2659 		    SMB_DACL_SECINFO, sr->user_cr);
2660 		fs_sd->sd_zdacl = dacl;
2661 	}
2662 
2663 	if ((secinfo & SMB_SACL_SECINFO) == 0) {
2664 		sacl = smb_fsacl_inherit(pfs_sd.sd_zsacl, is_dir,
2665 		    SMB_SACL_SECINFO, sr->user_cr);
2666 		fs_sd->sd_zsacl = sacl;
2667 	}
2668 
2669 	smb_fsacl_free(pfs_sd.sd_zdacl);
2670 	smb_fsacl_free(pfs_sd.sd_zsacl);
2671 	return (0);
2672 }
2673 #endif	/* _KERNEL */
2674 
2675 /*
2676  * smb_fsop_eaccess
2677  *
2678  * Returns the effective permission of the given credential for the
2679  * specified object.
2680  *
2681  * This is just a workaround. We need VFS/FS support for this.
2682  */
2683 void
smb_fsop_eaccess(smb_request_t * sr,cred_t * cr,smb_node_t * snode,uint32_t * eaccess)2684 smb_fsop_eaccess(smb_request_t *sr, cred_t *cr, smb_node_t *snode,
2685     uint32_t *eaccess)
2686 {
2687 	int access = 0;
2688 	vnode_t *dir_vp;
2689 	smb_node_t *unnamed_node;
2690 
2691 	ASSERT(cr);
2692 	ASSERT(snode);
2693 	ASSERT(snode->n_magic == SMB_NODE_MAGIC);
2694 	ASSERT(snode->n_state != SMB_NODE_STATE_DESTROYING);
2695 
2696 	unnamed_node = SMB_IS_STREAM(snode);
2697 	if (unnamed_node) {
2698 		ASSERT(unnamed_node->n_magic == SMB_NODE_MAGIC);
2699 		ASSERT(unnamed_node->n_state != SMB_NODE_STATE_DESTROYING);
2700 		/*
2701 		 * Streams authorization should be performed against the
2702 		 * unnamed stream.
2703 		 */
2704 		snode = unnamed_node;
2705 	}
2706 
2707 	if (smb_tree_has_feature(sr->tid_tree, SMB_TREE_ACEMASKONACCESS)) {
2708 		dir_vp = (snode->n_dnode) ? snode->n_dnode->vp : NULL;
2709 		smb_vop_eaccess(snode->vp, (int *)eaccess, V_ACE_MASK, dir_vp,
2710 		    cr);
2711 		return;
2712 	}
2713 
2714 	/*
2715 	 * FS doesn't understand 32-bit mask
2716 	 */
2717 	smb_vop_eaccess(snode->vp, &access, 0, NULL, cr);
2718 	access &= sr->tid_tree->t_access;
2719 
2720 	*eaccess = READ_CONTROL | FILE_READ_EA | FILE_READ_ATTRIBUTES;
2721 
2722 	if (access & VREAD)
2723 		*eaccess |= FILE_READ_DATA;
2724 
2725 	if (access & VEXEC)
2726 		*eaccess |= FILE_EXECUTE;
2727 
2728 	if (access & VWRITE)
2729 		*eaccess |= FILE_WRITE_DATA | FILE_WRITE_ATTRIBUTES |
2730 		    FILE_WRITE_EA | FILE_APPEND_DATA | FILE_DELETE_CHILD;
2731 
2732 	if (access & (VREAD | VWRITE))
2733 		*eaccess |= SYNCHRONIZE;
2734 
2735 #ifdef	_FAKE_KERNEL
2736 	/* Should be: if (we are the owner)... */
2737 	if (access & VWRITE)
2738 		*eaccess |= DELETE | WRITE_DAC | WRITE_OWNER;
2739 #endif
2740 }
2741 
2742 /*
2743  * smb_fsop_shrlock
2744  *
2745  * For the current open request, check file sharing rules
2746  * against existing opens.
2747  *
2748  * Returns NT_STATUS_SHARING_VIOLATION if there is any
2749  * sharing conflict.  Returns NT_STATUS_SUCCESS otherwise.
2750  *
2751  * Full system-wide share reservation synchronization is available
2752  * when the nbmand (non-blocking mandatory) mount option is set
2753  * (i.e. nbl_need_crit() is true) and nbmand critical regions are used.
2754  * This provides synchronization with NFS and local processes.  The
2755  * critical regions are entered in VOP_SHRLOCK()/fs_shrlock() (called
2756  * from smb_open_subr()/smb_fsop_shrlock()/smb_vop_shrlock()) as well
2757  * as the CIFS rename and delete paths.
2758  *
2759  * The CIFS server will also enter the nbl critical region in the open,
2760  * rename, and delete paths when nbmand is not set.  There is limited
2761  * coordination with local and VFS share reservations in this case.
2762  * Note that when the nbmand mount option is not set, the VFS layer
2763  * only processes advisory reservations and the delete mode is not checked.
2764  *
2765  * Whether or not the nbmand mount option is set, intra-CIFS share
2766  * checking is done in the open, delete, and rename paths using a CIFS
2767  * critical region (node->n_share_lock).
2768  */
2769 uint32_t
smb_fsop_shrlock(cred_t * cr,smb_node_t * node,uint32_t uniq_fid,uint32_t desired_access,uint32_t share_access)2770 smb_fsop_shrlock(cred_t *cr, smb_node_t *node, uint32_t uniq_fid,
2771     uint32_t desired_access, uint32_t share_access)
2772 {
2773 	int rc;
2774 
2775 	/* Allow access if the request is just for meta data */
2776 	if ((desired_access & FILE_DATA_ALL) == 0)
2777 		return (NT_STATUS_SUCCESS);
2778 
2779 	rc = smb_node_open_check(node, desired_access, share_access);
2780 	if (rc)
2781 		return (NT_STATUS_SHARING_VIOLATION);
2782 
2783 	rc = smb_vop_shrlock(node->vp, uniq_fid, desired_access, share_access,
2784 	    cr);
2785 	if (rc)
2786 		return (NT_STATUS_SHARING_VIOLATION);
2787 
2788 	return (NT_STATUS_SUCCESS);
2789 }
2790 
2791 void
smb_fsop_unshrlock(cred_t * cr,smb_node_t * node,uint32_t uniq_fid)2792 smb_fsop_unshrlock(cred_t *cr, smb_node_t *node, uint32_t uniq_fid)
2793 {
2794 	(void) smb_vop_unshrlock(node->vp, uniq_fid, cr);
2795 }
2796 
2797 int
smb_fsop_frlock(smb_node_t * node,smb_lock_t * lock,boolean_t unlock,cred_t * cr)2798 smb_fsop_frlock(smb_node_t *node, smb_lock_t *lock, boolean_t unlock,
2799     cred_t *cr)
2800 {
2801 	flock64_t bf;
2802 	int flag = F_REMOTELOCK;
2803 
2804 	/*
2805 	 * VOP_FRLOCK() will not be called if:
2806 	 *
2807 	 * 1) The lock has a range of zero bytes. The semantics of Windows and
2808 	 *    POSIX are different. In the case of POSIX it asks for the locking
2809 	 *    of all the bytes from the offset provided until the end of the
2810 	 *    file. In the case of Windows a range of zero locks nothing and
2811 	 *    doesn't conflict with any other lock.
2812 	 *
2813 	 * 2) The lock rolls over (start + lenght < start). Solaris will assert
2814 	 *    if such a request is submitted. This will not create
2815 	 *    incompatibilities between POSIX and Windows. In the Windows world,
2816 	 *    if a client submits such a lock, the server will not lock any
2817 	 *    bytes. Interestingly if the same lock (same offset and length) is
2818 	 *    resubmitted Windows will consider that there is an overlap and
2819 	 *    the granting rules will then apply.
2820 	 *
2821 	 * 3) The SMB-level process IDs (smb_pid) are not passed down to the
2822 	 *    POSIX level in l_pid because (a) the rules about lock PIDs are
2823 	 *    different in SMB, and (b) we're putting our ofile f_uniqid in
2824 	 *    the POSIX l_pid field to segregate locks per SMB ofile.
2825 	 *    (We're also using a "remote" system ID in l_sysid.)
2826 	 *    All SMB locking PIDs are handled at the SMB level and
2827 	 *    not exposed in POSIX locking.
2828 	 */
2829 	if ((lock->l_length == 0) ||
2830 	    ((lock->l_start + lock->l_length - 1) < lock->l_start))
2831 		return (0);
2832 
2833 	bzero(&bf, sizeof (bf));
2834 
2835 	if (unlock) {
2836 		bf.l_type = F_UNLCK;
2837 	} else if (lock->l_type == SMB_LOCK_TYPE_READONLY) {
2838 		bf.l_type = F_RDLCK;
2839 		flag |= FREAD;
2840 	} else if (lock->l_type == SMB_LOCK_TYPE_READWRITE) {
2841 		bf.l_type = F_WRLCK;
2842 		flag |= FWRITE;
2843 	}
2844 
2845 	bf.l_start = lock->l_start;
2846 	bf.l_len = lock->l_length;
2847 	bf.l_pid = lock->l_file->f_uniqid;
2848 	bf.l_sysid = smb_ct.cc_sysid;
2849 
2850 	return (smb_vop_frlock(node->vp, cr, flag, &bf));
2851 }
2852