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 /*
23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright 2017 Nexenta Systems, Inc.  All rights reserved.
25  */
26 
27 /*
28  * SMB specific functions
29  */
30 #include <stdio.h>
31 #include <string.h>
32 #include <ctype.h>
33 #include <stdlib.h>
34 #include <unistd.h>
35 #include <zone.h>
36 #include <errno.h>
37 #include <locale.h>
38 #include <fcntl.h>
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 #include <syslog.h>
42 #include "libshare.h"
43 #include "libshare_impl.h"
44 #include <pwd.h>
45 #include <limits.h>
46 #include <libscf.h>
47 #include <libscf_priv.h>
48 #include <strings.h>
49 #include "libshare_smb.h"
50 #include <rpcsvc/daemon_utils.h>
51 #include <smbsrv/smb_share.h>
52 #include <smbsrv/smbinfo.h>
53 #include <smbsrv/libsmb.h>
54 #include <libdlpi.h>
55 
56 #define	SMB_CSC_BUFSZ		64
57 
58 #define	SMB_VALID_SUB_CHRS	"UDhMLmIiSPu"	/* substitution characters */
59 
60 /* internal functions */
61 static int smb_share_init(void);
62 static void smb_share_fini(void);
63 static int smb_enable_share(sa_share_t);
64 static int smb_share_changed(sa_share_t);
65 static int smb_resource_changed(sa_resource_t);
66 static int smb_rename_resource(sa_handle_t, sa_resource_t, char *);
67 static int smb_disable_share(sa_share_t share, char *);
68 static int smb_validate_property(sa_handle_t, sa_property_t, sa_optionset_t);
69 static int smb_set_proto_prop(sa_property_t);
70 static sa_protocol_properties_t smb_get_proto_set(void);
71 static char *smb_get_status(void);
72 static int smb_parse_optstring(sa_group_t, char *);
73 static char *smb_format_options(sa_group_t, int);
74 
75 static int smb_enable_service(void);
76 
77 static int range_check_validator(int, char *);
78 static int range_check_validator_zero_ok(int, char *);
79 static int string_length_check_validator(int, char *);
80 static int print_enable_validator(int, char *);
81 static int true_false_validator(int, char *);
82 static int ipv4_validator(int, char *);
83 static int hostname_validator(int, char *);
84 static int path_validator(int, char *);
85 static int cmd_validator(int, char *);
86 static int disposition_validator(int, char *);
87 static int protocol_validator(int, char *);
88 static int require_validator(int, char *);
89 
90 static int smb_enable_resource(sa_resource_t);
91 static int smb_disable_resource(sa_resource_t);
92 static uint64_t smb_share_features(void);
93 static int smb_list_transient(sa_handle_t);
94 
95 static int smb_build_shareinfo(sa_share_t, sa_resource_t, smb_share_t *);
96 static void smb_csc_option(const char *, smb_share_t *);
97 static char *smb_csc_name(const smb_share_t *);
98 static sa_group_t smb_get_defaultgrp(sa_handle_t);
99 static int interface_validator(int, char *);
100 static int smb_update_optionset_props(sa_handle_t, sa_resource_t, nvlist_t *);
101 
102 static boolean_t smb_saprop_getbool(sa_optionset_t, char *, boolean_t);
103 static boolean_t smb_saprop_getstr(sa_optionset_t, char *, char *, size_t);
104 
105 static struct {
106 	char *value;
107 	uint32_t flag;
108 } cscopt[] = {
109 	{ "disabled",	SMB_SHRF_CSC_DISABLED },
110 	{ "manual",	SMB_SHRF_CSC_MANUAL },
111 	{ "auto",	SMB_SHRF_CSC_AUTO },
112 	{ "vdo",	SMB_SHRF_CSC_VDO }
113 };
114 
115 /* size of basic format allocation */
116 #define	OPT_CHUNK	1024
117 
118 /* size of string for types - big enough to hold "dependency" */
119 #define	SCFTYPE_LEN	32
120 
121 /*
122  * Indexes of entries in smb_proto_options table.
123  * Changes to smb_proto_options table may require
124  * an update to these values.
125  */
126 #define	PROTO_OPT_WINS1			6
127 #define	PROTO_OPT_WINS_EXCLUDE		8
128 
129 typedef struct smb_hostifs_walker {
130 	const char	*hiw_ifname;
131 	boolean_t	hiw_matchfound;
132 } smb_hostifs_walker_t;
133 
134 
135 /*
136  * ops vector that provides the protocol specific info and operations
137  * for share management.
138  */
139 
140 struct sa_plugin_ops sa_plugin_ops = {
141 	SA_PLUGIN_VERSION,
142 	SMB_PROTOCOL_NAME,
143 	smb_share_init,
144 	smb_share_fini,
145 	smb_enable_share,
146 	smb_disable_share,
147 	smb_validate_property,
148 	NULL,	/* valid_space */
149 	NULL,	/* security_prop */
150 	smb_parse_optstring,
151 	smb_format_options,
152 	smb_set_proto_prop,
153 	smb_get_proto_set,
154 	smb_get_status,
155 	NULL,	/* space_alias */
156 	NULL,	/* update_legacy */
157 	NULL,	/* delete_legacy */
158 	smb_share_changed,
159 	smb_enable_resource,
160 	smb_disable_resource,
161 	smb_share_features,
162 	smb_list_transient,
163 	smb_resource_changed,
164 	smb_rename_resource,
165 	NULL,	/* run_command */
166 	NULL,	/* command_help */
167 	NULL	/* delete_proto_section */
168 };
169 
170 struct option_defs optdefs[] = {
171 	{ SHOPT_AD_CONTAINER,	OPT_TYPE_STRING },
172 	{ SHOPT_ABE,		OPT_TYPE_BOOLEAN },
173 	{ SHOPT_NAME,		OPT_TYPE_NAME },
174 	{ SHOPT_RO,		OPT_TYPE_ACCLIST },
175 	{ SHOPT_RW,		OPT_TYPE_ACCLIST },
176 	{ SHOPT_NONE,		OPT_TYPE_ACCLIST },
177 	{ SHOPT_CATIA,		OPT_TYPE_BOOLEAN },
178 	{ SHOPT_CSC,		OPT_TYPE_CSC },
179 	{ SHOPT_GUEST,		OPT_TYPE_BOOLEAN },
180 	{ SHOPT_DFSROOT,	OPT_TYPE_BOOLEAN },
181 	{ SHOPT_DESCRIPTION,	OPT_TYPE_STRING },
182 	{ SHOPT_CA,		OPT_TYPE_BOOLEAN },
183 	{ SHOPT_FSO,		OPT_TYPE_BOOLEAN },
184 	{ SHOPT_QUOTAS,		OPT_TYPE_BOOLEAN },
185 	{ SHOPT_ENCRYPT,	OPT_TYPE_STRING },
186 	{ NULL, 0 }
187 };
188 
189 /*
190  * findopt(name)
191  *
192  * Lookup option "name" in the option table and return the table
193  * index.
194  */
195 static int
findopt(char * name)196 findopt(char *name)
197 {
198 	int i;
199 	if (name != NULL) {
200 		for (i = 0; optdefs[i].tag != NULL; i++) {
201 			if (strcmp(optdefs[i].tag, name) == 0)
202 				return (i);
203 		}
204 	}
205 	return (-1);
206 }
207 
208 /*
209  * is_a_number(number)
210  *
211  * is the string a number in one of the forms we want to use?
212  */
213 static boolean_t
is_a_number(char * number)214 is_a_number(char *number)
215 {
216 	boolean_t isnum = B_TRUE;
217 	boolean_t ishex = B_FALSE;
218 
219 	if (number == NULL || *number == '\0')
220 		return (B_FALSE);
221 
222 	if (strncasecmp(number, "0x", 2) == 0) {
223 		number += 2;
224 		ishex = B_TRUE;
225 	} else if (*number == '-') {
226 		number++;
227 	}
228 
229 	while (isnum && (*number != '\0')) {
230 		isnum = (ishex) ? isxdigit(*number) : isdigit(*number);
231 		number++;
232 	}
233 
234 	return (isnum);
235 }
236 
237 /*
238  * check ro vs rw values.  Over time this may get beefed up.
239  * for now it just does simple checks.
240  */
241 
242 static int
check_rorw(char * v1,char * v2)243 check_rorw(char *v1, char *v2)
244 {
245 	int ret = SA_OK;
246 	if (strcmp(v1, v2) == 0)
247 		ret = SA_VALUE_CONFLICT;
248 	return (ret);
249 }
250 
251 /*
252  * validresource(name)
253  *
254  * Check that name only has valid characters in it. The current valid
255  * set are the printable characters but not including:
256  *	" / \ [ ] : | < > + ; , ? * = \t
257  * Note that space is included and there is a maximum length.
258  */
259 static boolean_t
validresource(const char * name)260 validresource(const char *name)
261 {
262 	const char *cp;
263 	size_t len;
264 
265 	if (name == NULL)
266 		return (B_FALSE);
267 
268 	len = strlen(name);
269 	if (len == 0 || len > SA_MAX_RESOURCE_NAME)
270 		return (B_FALSE);
271 
272 	if (strpbrk(name, "\"/\\[]:|<>+;,?*=\t") != NULL) {
273 		return (B_FALSE);
274 	}
275 
276 	for (cp = name; *cp != '\0'; cp++)
277 		if (iscntrl(*cp))
278 			return (B_FALSE);
279 
280 	return (B_TRUE);
281 }
282 
283 /*
284  * Check that the client-side caching (CSC) option value is valid.
285  */
286 static boolean_t
validcsc(const char * value)287 validcsc(const char *value)
288 {
289 	int i;
290 
291 	for (i = 0; i < (sizeof (cscopt) / sizeof (cscopt[0])); ++i) {
292 		if (strcasecmp(value, cscopt[i].value) == 0)
293 			return (B_TRUE);
294 	}
295 
296 	return (B_FALSE);
297 }
298 
299 /*
300  * smb_isonline()
301  *
302  * Determine if the SMF service instance is in the online state or
303  * not. A number of operations depend on this state.
304  */
305 static boolean_t
smb_isonline(void)306 smb_isonline(void)
307 {
308 	char *str;
309 	boolean_t ret = B_FALSE;
310 
311 	if ((str = smf_get_state(SMBD_DEFAULT_INSTANCE_FMRI)) != NULL) {
312 		ret = (strcmp(str, SCF_STATE_STRING_ONLINE) == 0);
313 		free(str);
314 	}
315 	return (ret);
316 }
317 
318 /*
319  * smb_isdisabled()
320  *
321  * Determine if the SMF service instance is in the disabled state or
322  * not. A number of operations depend on this state.
323  */
324 static boolean_t
smb_isdisabled(void)325 smb_isdisabled(void)
326 {
327 	char *str;
328 	boolean_t ret = B_FALSE;
329 
330 	if ((str = smf_get_state(SMBD_DEFAULT_INSTANCE_FMRI)) != NULL) {
331 		ret = (strcmp(str, SCF_STATE_STRING_DISABLED) == 0);
332 		free(str);
333 	}
334 	return (ret);
335 }
336 
337 /*
338  * smb_isautoenable()
339  *
340  * Determine if the SMF service instance auto_enabled set or not. A
341  * number of operations depend on this state.  The property not being
342  * set or being set to true means autoenable.  Only being set to false
343  * is not autoenabled.
344  */
345 static boolean_t
smb_isautoenable(void)346 smb_isautoenable(void)
347 {
348 	boolean_t ret = B_TRUE;
349 	scf_simple_prop_t *prop;
350 	uint8_t *retstr;
351 
352 	prop = scf_simple_prop_get(NULL, SMBD_DEFAULT_INSTANCE_FMRI,
353 	    "application", "auto_enable");
354 	if (prop != NULL) {
355 		retstr = scf_simple_prop_next_boolean(prop);
356 		ret = *retstr != 0;
357 		scf_simple_prop_free(prop);
358 	}
359 	return (ret);
360 }
361 
362 /*
363  * smb_ismaint()
364  *
365  * Determine if the SMF service instance is in the disabled state or
366  * not. A number of operations depend on this state.
367  */
368 static boolean_t
smb_ismaint(void)369 smb_ismaint(void)
370 {
371 	char *str;
372 	boolean_t ret = B_FALSE;
373 
374 	if ((str = smf_get_state(SMBD_DEFAULT_INSTANCE_FMRI)) != NULL) {
375 		ret = (strcmp(str, SCF_STATE_STRING_MAINT) == 0);
376 		free(str);
377 	}
378 	return (ret);
379 }
380 
381 /*
382  * smb_enable_share tells the implementation that it is to enable the share.
383  * This entails converting the path and options into the appropriate ioctl
384  * calls. It is assumed that all error checking of paths, etc. were
385  * done earlier.
386  */
387 static int
smb_enable_share(sa_share_t share)388 smb_enable_share(sa_share_t share)
389 {
390 	char *path;
391 	smb_share_t si;
392 	sa_resource_t resource;
393 	boolean_t iszfs;
394 	int err = SA_OK;
395 	boolean_t online;
396 
397 	/*
398 	 * Don't support Trusted Extensions.
399 	 */
400 	if (is_system_labeled()) {
401 		(void) printf(dgettext(TEXT_DOMAIN,
402 		    "SMB: service not supported with Trusted Extensions\n"));
403 		return (SA_NOT_SUPPORTED);
404 	}
405 
406 	/* get the path since it is important in several places */
407 	path = sa_get_share_attr(share, "path");
408 	if (path == NULL)
409 		return (SA_NO_SUCH_PATH);
410 
411 	/*
412 	 * If administratively disabled, don't try to start anything.
413 	 */
414 	online = smb_isonline();
415 	if (!online && !smb_isautoenable() && smb_isdisabled())
416 		goto done;
417 
418 	iszfs = sa_path_is_zfs(path);
419 
420 	if (!online) {
421 		err = smb_enable_service();
422 		if (err != SA_OK) {
423 			(void) printf(dgettext(TEXT_DOMAIN,
424 			    "SMB: Unable to enable service\n"));
425 		} else {
426 			online = B_TRUE;
427 		}
428 	}
429 
430 	/*
431 	 * Don't bother trying to start shares if the service isn't
432 	 * running.
433 	 */
434 	if (!online)
435 		goto done;
436 
437 	/* Each share can have multiple resources */
438 	for (resource = sa_get_share_resource(share, NULL);
439 	    resource != NULL;
440 	    resource = sa_get_next_resource(resource)) {
441 		err = smb_build_shareinfo(share, resource, &si);
442 		if (err != SA_OK) {
443 			sa_free_attr_string(path);
444 			return (err);
445 		}
446 
447 		if (!iszfs) {
448 			err = smb_share_create(&si);
449 		} else {
450 			share_t sh;
451 
452 			(void) sa_sharetab_fill_zfs(share, &sh, "smb");
453 			err = sa_share_zfs(share, resource, (char *)path, &sh,
454 			    &si, ZFS_SHARE_SMB);
455 			if (err != SA_OK) {
456 				errno = err;
457 				err = -1;
458 			}
459 			sa_emptyshare(&sh);
460 		}
461 	}
462 	if (!iszfs)
463 		(void) sa_update_sharetab(share, "smb");
464 done:
465 	sa_free_attr_string(path);
466 
467 	return (err == NERR_DuplicateShare ? 0 : err);
468 }
469 
470 /*
471  * This is the share for CIFS all shares have resource names.
472  * Enable tells the smb server to update its hash. If it fails
473  * because smb server is down, we just ignore as smb server loads
474  * the resources from sharemanager at startup.
475  */
476 
477 static int
smb_enable_resource(sa_resource_t resource)478 smb_enable_resource(sa_resource_t resource)
479 {
480 	sa_share_t share;
481 	smb_share_t si;
482 	int ret = SA_OK;
483 	int err;
484 	boolean_t isonline;
485 
486 	share = sa_get_resource_parent(resource);
487 	if (share == NULL)
488 		return (SA_NO_SUCH_PATH);
489 
490 	/*
491 	 * If administratively disabled, don't try to start anything.
492 	 */
493 	isonline = smb_isonline();
494 	if (!isonline && !smb_isautoenable() && smb_isdisabled())
495 		return (SA_OK);
496 
497 	if (!isonline) {
498 		(void) smb_enable_service();
499 
500 		if (!smb_isonline())
501 			return (SA_OK);
502 	}
503 
504 	if ((ret = smb_build_shareinfo(share, resource, &si)) != SA_OK)
505 		return (ret);
506 
507 	/*
508 	 * Attempt to add the share. Any error that occurs if it was
509 	 * online is an error but don't count NERR_DuplicateName if
510 	 * smb/server had to be brought online since bringing the
511 	 * service up will enable the share that was just added prior
512 	 * to the attempt to enable.
513 	 */
514 	err = smb_share_create(&si);
515 	if (err == NERR_Success || !(!isonline && err == NERR_DuplicateName))
516 		(void) sa_update_sharetab(share, "smb");
517 	else
518 		return (SA_NOT_SHARED);
519 
520 	return (SA_OK);
521 }
522 
523 /*
524  * Remove it from smb server hash.
525  */
526 static int
smb_disable_resource(sa_resource_t resource)527 smb_disable_resource(sa_resource_t resource)
528 {
529 	char *rname;
530 	uint32_t res;
531 	sa_share_t share;
532 
533 	rname = sa_get_resource_attr(resource, "name");
534 	if (rname == NULL)
535 		return (SA_NO_SUCH_RESOURCE);
536 
537 	if (smb_isonline()) {
538 		res = smb_share_delete(rname);
539 		if (res != NERR_Success &&
540 		    res != NERR_NetNameNotFound) {
541 			sa_free_attr_string(rname);
542 			return (SA_CONFIG_ERR);
543 		}
544 	}
545 
546 	sa_free_attr_string(rname);
547 
548 	share = sa_get_resource_parent(resource);
549 	if (share != NULL) {
550 		rname = sa_get_share_attr(share, "path");
551 		if (rname != NULL) {
552 			sa_handle_t handle;
553 
554 			handle = sa_find_group_handle((sa_group_t)resource);
555 			(void) sa_delete_sharetab(handle, rname, "smb");
556 			sa_free_attr_string(rname);
557 		}
558 	}
559 	/*
560 	 * Always return OK as smb/server may be down and
561 	 * Shares will be picked up when loaded.
562 	 */
563 	return (SA_OK);
564 }
565 
566 /*
567  * smb_share_changed(sa_share_t share)
568  *
569  * The specified share has changed.
570  */
571 static int
smb_share_changed(sa_share_t share)572 smb_share_changed(sa_share_t share)
573 {
574 	char *path;
575 	sa_resource_t resource;
576 
577 	if (!smb_isonline())
578 		return (SA_OK);
579 
580 	/* get the path since it is important in several places */
581 	path = sa_get_share_attr(share, "path");
582 	if (path == NULL)
583 		return (SA_NO_SUCH_PATH);
584 
585 	for (resource = sa_get_share_resource(share, NULL);
586 	    resource != NULL;
587 	    resource = sa_get_next_resource(resource))
588 		(void) smb_resource_changed(resource);
589 
590 	sa_free_attr_string(path);
591 
592 	return (SA_OK);
593 }
594 
595 /*
596  * smb_resource_changed(sa_resource_t resource)
597  *
598  * The specified resource has changed.
599  */
600 static int
smb_resource_changed(sa_resource_t resource)601 smb_resource_changed(sa_resource_t resource)
602 {
603 	uint32_t res;
604 	sa_share_t share;
605 	smb_share_t si;
606 
607 	if (!smb_isonline())
608 		return (SA_OK);
609 
610 	if ((share = sa_get_resource_parent(resource)) == NULL)
611 		return (SA_CONFIG_ERR);
612 
613 	if ((res = smb_build_shareinfo(share, resource, &si)) != SA_OK)
614 		return (res);
615 
616 	res = smb_share_modify(&si);
617 
618 	if (res != NERR_Success)
619 		return (SA_CONFIG_ERR);
620 
621 	return (smb_enable_service());
622 }
623 
624 /*
625  * smb_disable_share(sa_share_t share, char *path)
626  *
627  * Unshare the specified share. Note that "path" is the same
628  * path as what is in the "share" object. It is passed in to avoid an
629  * additional lookup. A missing "path" value makes this a no-op
630  * function.
631  */
632 static int
smb_disable_share(sa_share_t share,char * path)633 smb_disable_share(sa_share_t share, char *path)
634 {
635 	char *rname;
636 	sa_resource_t resource;
637 	sa_group_t parent;
638 	boolean_t iszfs;
639 	int err = SA_OK;
640 	int ret = SA_OK;
641 	sa_handle_t handle;
642 	boolean_t first = B_TRUE; /* work around sharetab issue */
643 
644 	if (path == NULL)
645 		return (ret);
646 
647 	/*
648 	 * If the share is in a ZFS group we need to handle it
649 	 * differently.  Just being on a ZFS file system isn't
650 	 * enough since we may be in a legacy share case.
651 	 */
652 	parent = sa_get_parent_group(share);
653 	iszfs = sa_group_is_zfs(parent);
654 
655 	if (!smb_isonline())
656 		goto done;
657 
658 	for (resource = sa_get_share_resource(share, NULL);
659 	    resource != NULL;
660 	    resource = sa_get_next_resource(resource)) {
661 		rname = sa_get_resource_attr(resource, "name");
662 		if (rname == NULL) {
663 			continue;
664 		}
665 		if (!iszfs) {
666 			err = smb_share_delete(rname);
667 			switch (err) {
668 			case NERR_NetNameNotFound:
669 			case NERR_Success:
670 				err = SA_OK;
671 				break;
672 			default:
673 				err = SA_CONFIG_ERR;
674 				break;
675 			}
676 		} else {
677 			share_t sh;
678 
679 			(void) sa_sharetab_fill_zfs(share, &sh, "smb");
680 			err = sa_share_zfs(share, resource, (char *)path, &sh,
681 			    rname, ZFS_UNSHARE_SMB);
682 			if (err != SA_OK) {
683 				switch (err) {
684 				case EINVAL:
685 				case ENOENT:
686 					err = SA_OK;
687 					break;
688 				default:
689 					/*
690 					 * If we are no longer the first case,
691 					 * we don't care about the sa_share_zfs
692 					 * err if it is -1. This works around
693 					 * a problem in sharefs and should be
694 					 * removed when sharefs supports
695 					 * multiple entries per path.
696 					 */
697 					if (!first)
698 						err = SA_OK;
699 					else
700 						err = SA_SYSTEM_ERR;
701 					break;
702 				}
703 			}
704 
705 			first = B_FALSE;
706 
707 			sa_emptyshare(&sh);
708 		}
709 
710 		if (err != SA_OK)
711 			ret = err;
712 		sa_free_attr_string(rname);
713 	}
714 done:
715 	if (!iszfs) {
716 		handle = sa_find_group_handle((sa_group_t)share);
717 		if (handle != NULL)
718 			(void) sa_delete_sharetab(handle, path, "smb");
719 		else
720 			ret = SA_SYSTEM_ERR;
721 	}
722 	return (ret);
723 }
724 
725 /*
726  * smb_validate_property(handle, property, parent)
727  *
728  * Check that the property has a legitimate value for its type.
729  * Handle isn't currently used but may need to be in the future.
730  */
731 
732 /*ARGSUSED*/
733 static int
smb_validate_property(sa_handle_t handle,sa_property_t property,sa_optionset_t parent)734 smb_validate_property(sa_handle_t handle, sa_property_t property,
735     sa_optionset_t parent)
736 {
737 	int ret = SA_OK;
738 	char *propname;
739 	int optindex;
740 	sa_group_t parent_group;
741 	char *value;
742 	char *other;
743 
744 	propname = sa_get_property_attr(property, "type");
745 
746 	if ((optindex = findopt(propname)) < 0)
747 		ret = SA_NO_SUCH_PROP;
748 
749 	/* need to validate value range here as well */
750 	if (ret == SA_OK) {
751 		parent_group = sa_get_parent_group((sa_share_t)parent);
752 		if (optdefs[optindex].share && !sa_is_share(parent_group))
753 			ret = SA_PROP_SHARE_ONLY;
754 	}
755 	if (ret != SA_OK) {
756 		if (propname != NULL)
757 			sa_free_attr_string(propname);
758 		return (ret);
759 	}
760 
761 	value = sa_get_property_attr(property, "value");
762 	if (value != NULL) {
763 		/* first basic type checking */
764 		switch (optdefs[optindex].type) {
765 		case OPT_TYPE_NUMBER:
766 			/* check that the value is all digits */
767 			if (!is_a_number(value))
768 				ret = SA_BAD_VALUE;
769 			break;
770 		case OPT_TYPE_BOOLEAN:
771 			ret = true_false_validator(0, value);
772 			break;
773 		case OPT_TYPE_NAME:
774 			/*
775 			 * Make sure no invalid characters
776 			 */
777 			if (!validresource(value))
778 				ret = SA_BAD_VALUE;
779 			break;
780 		case OPT_TYPE_STRING:
781 			/* whatever is here should be ok */
782 			break;
783 		case OPT_TYPE_CSC:
784 			if (!validcsc(value))
785 				ret = SA_BAD_VALUE;
786 			break;
787 		case OPT_TYPE_ACCLIST: {
788 			sa_property_t oprop;
789 			char *ovalue;
790 			/*
791 			 * access list handling. Should eventually
792 			 * validate that all the values make sense.
793 			 * Also, ro and rw may have cross value
794 			 * conflicts.
795 			 */
796 			if (parent == NULL)
797 				break;
798 			if (strcmp(propname, SHOPT_RO) == 0)
799 				other = SHOPT_RW;
800 			else if (strcmp(propname, SHOPT_RW) == 0)
801 				other = SHOPT_RO;
802 			else
803 				other = NULL;
804 			if (other == NULL)
805 				break;
806 
807 			/* compare rw(ro) with ro(rw) */
808 			oprop = sa_get_property(parent, other);
809 			if (oprop == NULL)
810 				break;
811 			/*
812 			 * only potential
813 			 * confusion if other
814 			 * exists
815 			 */
816 			ovalue = sa_get_property_attr(oprop, "value");
817 			if (ovalue != NULL) {
818 				ret = check_rorw(value, ovalue);
819 				sa_free_attr_string(ovalue);
820 			}
821 			break;
822 		}
823 		default:
824 			break;
825 		}
826 	}
827 
828 	if (value != NULL)
829 		sa_free_attr_string(value);
830 	if (ret == SA_OK && optdefs[optindex].check != NULL)
831 		/* do the property specific check */
832 		ret = optdefs[optindex].check(property);
833 
834 	if (propname != NULL)
835 		sa_free_attr_string(propname);
836 	return (ret);
837 }
838 
839 /*
840  * Protocol management functions
841  *
842  * properties defined in the default files are defined in
843  * proto_option_defs for parsing and validation.
844  */
845 
846 struct smb_proto_option_defs {
847 	int smb_index;
848 	int32_t minval;
849 	int32_t maxval; /* In case of length of string this should be max */
850 	int (*validator)(int, char *);
851 	int32_t	refresh;
852 } smb_proto_options[] = {
853 	{ SMB_CI_SYS_CMNT, 0, MAX_VALUE_BUFLEN,
854 	    string_length_check_validator, SMB_REFRESH_REFRESH },
855 	{ SMB_CI_MAX_WORKERS, SMB_PI_MAX_WORKERS_MIN, SMB_PI_MAX_WORKERS_MAX,
856 	    range_check_validator, SMB_REFRESH_REFRESH },
857 	{ SMB_CI_NETBIOS_ENABLE, 0, 0, true_false_validator,
858 	    SMB_REFRESH_REFRESH },
859 	{ SMB_CI_NBSCOPE, 0, MAX_VALUE_BUFLEN,
860 	    string_length_check_validator, 0 },
861 	{ SMB_CI_LM_LEVEL, 2, 5, range_check_validator, 0 },
862 	{ SMB_CI_KEEPALIVE, 20, 5400, range_check_validator_zero_ok,
863 	    SMB_REFRESH_REFRESH },
864 	{ SMB_CI_WINS_SRV1, 0, MAX_VALUE_BUFLEN,
865 	    ipv4_validator, SMB_REFRESH_REFRESH },
866 	{ SMB_CI_WINS_SRV2, 0, MAX_VALUE_BUFLEN,
867 	    ipv4_validator, SMB_REFRESH_REFRESH },
868 	{ SMB_CI_WINS_EXCL, 0, MAX_VALUE_BUFLEN,
869 	    interface_validator, SMB_REFRESH_REFRESH },
870 	{ SMB_CI_SIGNING_ENABLE, 0, 0, true_false_validator,
871 	    SMB_REFRESH_REFRESH },
872 	{ SMB_CI_SIGNING_REQD, 0, 0, true_false_validator,
873 	    SMB_REFRESH_REFRESH },
874 	{ SMB_CI_RESTRICT_ANON, 0, 0, true_false_validator,
875 	    SMB_REFRESH_REFRESH },
876 	{ SMB_CI_DOMAIN_SRV, 0, MAX_VALUE_BUFLEN,
877 	    hostname_validator, SMB_REFRESH_REFRESH },
878 	{ SMB_CI_ADS_SITE, 0, MAX_VALUE_BUFLEN,
879 	    string_length_check_validator, SMB_REFRESH_REFRESH },
880 	{ SMB_CI_DYNDNS_ENABLE, 0, 0, true_false_validator, 0 },
881 	{ SMB_CI_AUTOHOME_MAP, 0, MAX_VALUE_BUFLEN, path_validator, 0 },
882 	{ SMB_CI_IPV6_ENABLE, 0, 0, true_false_validator,
883 	    SMB_REFRESH_REFRESH },
884 	{ SMB_CI_PRINT_ENABLE, 0, 0, print_enable_validator,
885 	    SMB_REFRESH_REFRESH },
886 	{ SMB_CI_TRAVERSE_MOUNTS, 0, 0, true_false_validator,
887 	    SMB_REFRESH_REFRESH },
888 	{ SMB_CI_MAP, 0, MAX_VALUE_BUFLEN, cmd_validator, SMB_REFRESH_REFRESH },
889 	{ SMB_CI_UNMAP, 0, MAX_VALUE_BUFLEN, cmd_validator,
890 	    SMB_REFRESH_REFRESH },
891 	{ SMB_CI_DISPOSITION, 0, MAX_VALUE_BUFLEN,
892 	    disposition_validator, SMB_REFRESH_REFRESH },
893 	{ SMB_CI_MAX_PROTOCOL, 0, MAX_VALUE_BUFLEN, protocol_validator,
894 	    SMB_REFRESH_REFRESH },
895 	{ SMB_CI_ENCRYPT, 0, MAX_VALUE_BUFLEN, require_validator,
896 	    SMB_REFRESH_REFRESH },
897 	{ SMB_CI_MIN_PROTOCOL, 0, MAX_VALUE_BUFLEN, protocol_validator,
898 	    SMB_REFRESH_REFRESH },
899 	{ SMB_CI_BYPASS_TRAVERSE_CHECKING, 0, 0, true_false_validator,
900 	    SMB_REFRESH_REFRESH },
901 	{ SMB_CI_OPLOCK_ENABLE, 0, 0, true_false_validator,
902 	    SMB_REFRESH_REFRESH },
903 };
904 
905 #define	SMB_OPT_NUM \
906 	(sizeof (smb_proto_options) / sizeof (smb_proto_options[0]))
907 
908 static int
require_validator(int index,char * value)909 require_validator(int index, char *value)
910 {
911 	if (string_length_check_validator(index, value) != SA_OK)
912 		return (SA_BAD_VALUE);
913 
914 	if (strcmp(value, "required") == 0)
915 		return (SA_OK);
916 
917 	if (strcmp(value, "disabled") == 0)
918 		return (SA_OK);
919 
920 	if (strcmp(value, "enabled") == 0)
921 		return (SA_OK);
922 
923 	return (SA_BAD_VALUE);
924 }
925 
926 /*
927  * Check the range of value as int range.
928  */
929 static int
range_check_validator(int index,char * value)930 range_check_validator(int index, char *value)
931 {
932 	int ret = SA_OK;
933 
934 	if (!is_a_number(value)) {
935 		ret = SA_BAD_VALUE;
936 	} else {
937 		int val;
938 		val = strtoul(value, NULL, 0);
939 		if (val < smb_proto_options[index].minval ||
940 		    val > smb_proto_options[index].maxval)
941 			ret = SA_BAD_VALUE;
942 	}
943 	return (ret);
944 }
945 
946 /*
947  * Check the range of value as int range.
948  */
949 static int
range_check_validator_zero_ok(int index,char * value)950 range_check_validator_zero_ok(int index, char *value)
951 {
952 	int ret = SA_OK;
953 
954 	if (!is_a_number(value)) {
955 		ret = SA_BAD_VALUE;
956 	} else {
957 		int val;
958 		val = strtoul(value, NULL, 0);
959 		if (val == 0)
960 			ret = SA_OK;
961 		else {
962 			if (val < smb_proto_options[index].minval ||
963 			    val > smb_proto_options[index].maxval)
964 			ret = SA_BAD_VALUE;
965 		}
966 	}
967 	return (ret);
968 }
969 
970 /*
971  * Check the length of the string
972  */
973 static int
string_length_check_validator(int index,char * value)974 string_length_check_validator(int index, char *value)
975 {
976 	int ret = SA_OK;
977 
978 	if (value == NULL)
979 		return (SA_BAD_VALUE);
980 	if (strlen(value) > smb_proto_options[index].maxval)
981 		ret = SA_BAD_VALUE;
982 	return (ret);
983 }
984 
985 /*
986  * Check yes/no
987  */
988 /*ARGSUSED*/
989 static int
true_false_validator(int index,char * value)990 true_false_validator(int index, char *value)
991 {
992 	if (value == NULL)
993 		return (SA_BAD_VALUE);
994 	if ((strcasecmp(value, "true") == 0) ||
995 	    (strcasecmp(value, "false") == 0))
996 		return (SA_OK);
997 	return (SA_BAD_VALUE);
998 }
999 
1000 /*
1001  * If printing support is compiled in, this is the same as:
1002  * true_false_validator.  Otherwise, only allow false.
1003  */
1004 /*ARGSUSED*/
1005 static int
print_enable_validator(int index,char * value)1006 print_enable_validator(int index, char *value)
1007 {
1008 	if (value == NULL)
1009 		return (SA_BAD_VALUE);
1010 
1011 #ifdef	HAVE_CUPS
1012 	if (strcasecmp(value, "true") == 0)
1013 		return (SA_OK);
1014 #endif
1015 	if (strcasecmp(value, "false") == 0)
1016 		return (SA_OK);
1017 
1018 	return (SA_BAD_VALUE);
1019 }
1020 
1021 /*
1022  * Check IP v4 address.
1023  */
1024 /*ARGSUSED*/
1025 static int
ipv4_validator(int index,char * value)1026 ipv4_validator(int index, char *value)
1027 {
1028 	char sbytes[16];
1029 
1030 	if (value == NULL)
1031 		return (SA_OK);
1032 
1033 	if (strlen(value) == 0)
1034 		return (SA_OK);
1035 
1036 	if (inet_pton(AF_INET, value, (void *)sbytes) != 1)
1037 		return (SA_BAD_VALUE);
1038 
1039 	return (SA_OK);
1040 }
1041 
1042 /*
1043  * Check that the specified name is an IP address (v4 or v6) or a hostname.
1044  * Per RFC 1035 and 1123, names may contain alphanumeric characters, hyphens
1045  * and dots.  The first and last character of a label must be alphanumeric.
1046  * Interior characters may be alphanumeric or hypens.
1047  *
1048  * Domain names should not contain underscores but we allow them because
1049  * Windows names are often in non-compliance with this rule.
1050  */
1051 /*ARGSUSED*/
1052 static int
hostname_validator(int index,char * value)1053 hostname_validator(int index, char *value)
1054 {
1055 	char		sbytes[INET6_ADDRSTRLEN];
1056 	boolean_t	new_label = B_TRUE;
1057 	char		*p;
1058 	char		label_terminator;
1059 	int		len;
1060 
1061 	if (value == NULL)
1062 		return (SA_OK);
1063 
1064 	if ((len = strlen(value)) == 0)
1065 		return (SA_OK);
1066 
1067 	if (inet_pton(AF_INET, value, (void *)sbytes) == 1)
1068 		return (SA_OK);
1069 
1070 	if (inet_pton(AF_INET6, value, (void *)sbytes) == 1)
1071 		return (SA_OK);
1072 
1073 	if (len >= MAXHOSTNAMELEN)
1074 		return (SA_BAD_VALUE);
1075 
1076 	if (strspn(value, "0123456789.") == len)
1077 		return (SA_BAD_VALUE);
1078 
1079 	label_terminator = *value;
1080 
1081 	for (p = value; *p != '\0'; ++p) {
1082 		if (new_label) {
1083 			if (!isalnum(*p))
1084 				return (SA_BAD_VALUE);
1085 			new_label = B_FALSE;
1086 			label_terminator = *p;
1087 			continue;
1088 		}
1089 
1090 		if (*p == '.') {
1091 			if (!isalnum(label_terminator))
1092 				return (SA_BAD_VALUE);
1093 			new_label = B_TRUE;
1094 			label_terminator = *p;
1095 			continue;
1096 		}
1097 
1098 		label_terminator = *p;
1099 
1100 		if (isalnum(*p) || *p == '-' || *p == '_')
1101 			continue;
1102 
1103 		return (SA_BAD_VALUE);
1104 	}
1105 
1106 	if (!isalnum(label_terminator))
1107 		return (SA_BAD_VALUE);
1108 
1109 	return (SA_OK);
1110 }
1111 
1112 /*
1113  * Call back function for dlpi_walk.
1114  * Returns TRUE if interface name exists on the host.
1115  */
1116 static boolean_t
smb_get_interface(const char * ifname,void * arg)1117 smb_get_interface(const char *ifname, void *arg)
1118 {
1119 	smb_hostifs_walker_t *iterp = arg;
1120 
1121 	iterp->hiw_matchfound = (strcmp(ifname, iterp->hiw_ifname) == 0);
1122 
1123 	return (iterp->hiw_matchfound);
1124 }
1125 
1126 /*
1127  * Checks to see if the input interface exists on the host.
1128  * Returns B_TRUE if the match is found, B_FALSE otherwise.
1129  */
1130 static boolean_t
smb_validate_interface(const char * ifname)1131 smb_validate_interface(const char *ifname)
1132 {
1133 	smb_hostifs_walker_t	iter;
1134 
1135 	if ((ifname == NULL) || (*ifname == '\0'))
1136 		return (B_FALSE);
1137 
1138 	iter.hiw_ifname = ifname;
1139 	iter.hiw_matchfound = B_FALSE;
1140 	dlpi_walk(smb_get_interface, &iter, 0);
1141 
1142 	return (iter.hiw_matchfound);
1143 }
1144 
1145 /*
1146  * Check valid interfaces. Interface names value can be NULL or empty.
1147  * Returns SA_BAD_VALUE if interface cannot be found on the host.
1148  */
1149 /*ARGSUSED*/
1150 static int
interface_validator(int index,char * value)1151 interface_validator(int index, char *value)
1152 {
1153 	char buf[16];
1154 	int ret = SA_OK;
1155 	char *ifname, *tmp, *p;
1156 
1157 	if (value == NULL || *value == '\0')
1158 		return (ret);
1159 
1160 	if (strlen(value) > MAX_VALUE_BUFLEN)
1161 		return (SA_BAD_VALUE);
1162 
1163 	if ((p = strdup(value)) == NULL)
1164 		return (SA_NO_MEMORY);
1165 
1166 	tmp = p;
1167 	while ((ifname = strsep(&tmp, ",")) != NULL) {
1168 		if (*ifname == '\0') {
1169 			ret = SA_BAD_VALUE;
1170 			break;
1171 		}
1172 
1173 		if (!smb_validate_interface(ifname)) {
1174 			if (inet_pton(AF_INET, ifname, (void *)buf) == 0) {
1175 				ret = SA_BAD_VALUE;
1176 				break;
1177 			}
1178 		}
1179 	}
1180 
1181 	free(p);
1182 	return (ret);
1183 }
1184 
1185 /*
1186  * Check path
1187  */
1188 /*ARGSUSED*/
1189 static int
path_validator(int index,char * path)1190 path_validator(int index, char *path)
1191 {
1192 	struct stat buffer;
1193 	int fd, status;
1194 
1195 	if (path == NULL)
1196 		return (SA_BAD_VALUE);
1197 
1198 	fd = open(path, O_RDONLY);
1199 	if (fd < 0)
1200 		return (SA_BAD_VALUE);
1201 
1202 	status = fstat(fd, &buffer);
1203 	(void) close(fd);
1204 
1205 	if (status < 0)
1206 		return (SA_BAD_VALUE);
1207 
1208 	if (buffer.st_mode & S_IFDIR)
1209 		return (SA_OK);
1210 	return (SA_BAD_VALUE);
1211 }
1212 
1213 /*
1214  * the protoset holds the defined options so we don't have to read
1215  * them multiple times
1216  */
1217 static sa_protocol_properties_t protoset;
1218 
1219 static int
findprotoopt(char * name)1220 findprotoopt(char *name)
1221 {
1222 	int i;
1223 	char *sc_name;
1224 
1225 	for (i = 0; i < SMB_OPT_NUM; i++) {
1226 		sc_name = smb_config_getname(smb_proto_options[i].smb_index);
1227 		if (strcasecmp(sc_name, name) == 0)
1228 			return (i);
1229 	}
1230 
1231 	return (-1);
1232 }
1233 
1234 /*
1235  * smb_load_proto_properties()
1236  *
1237  * read the smb config values from SMF.
1238  */
1239 
1240 static int
smb_load_proto_properties()1241 smb_load_proto_properties()
1242 {
1243 	sa_property_t prop;
1244 	char value[MAX_VALUE_BUFLEN];
1245 	char *name;
1246 	int index;
1247 	int ret = SA_OK;
1248 	int rc;
1249 
1250 	protoset = sa_create_protocol_properties(SMB_PROTOCOL_NAME);
1251 	if (protoset == NULL)
1252 		return (SA_NO_MEMORY);
1253 
1254 	for (index = 0; index < SMB_OPT_NUM && ret == SA_OK; index++) {
1255 		rc = smb_config_get(smb_proto_options[index].smb_index,
1256 		    value, sizeof (value));
1257 		if (rc != SMBD_SMF_OK)
1258 			continue;
1259 		name = smb_config_getname(smb_proto_options[index].smb_index);
1260 		prop = sa_create_property(name, value);
1261 		if (prop != NULL)
1262 			ret = sa_add_protocol_property(protoset, prop);
1263 		else
1264 			ret = SA_NO_MEMORY;
1265 	}
1266 	return (ret);
1267 }
1268 
1269 /*
1270  * smb_share_init()
1271  *
1272  * Initialize the smb plugin.
1273  */
1274 
1275 static int
smb_share_init(void)1276 smb_share_init(void)
1277 {
1278 	if (sa_plugin_ops.sa_init != smb_share_init)
1279 		return (SA_SYSTEM_ERR);
1280 
1281 	smb_share_door_clnt_init();
1282 	return (smb_load_proto_properties());
1283 }
1284 
1285 /*
1286  * smb_share_fini()
1287  *
1288  */
1289 static void
smb_share_fini(void)1290 smb_share_fini(void)
1291 {
1292 	xmlFreeNode(protoset);
1293 	protoset = NULL;
1294 
1295 	smb_share_door_clnt_fini();
1296 }
1297 
1298 /*
1299  * smb_get_proto_set()
1300  *
1301  * Return an optionset with all the protocol specific properties in
1302  * it.
1303  */
1304 static sa_protocol_properties_t
smb_get_proto_set(void)1305 smb_get_proto_set(void)
1306 {
1307 	return (protoset);
1308 }
1309 
1310 /*
1311  * smb_enable_dependencies()
1312  *
1313  * SMBD_DEFAULT_INSTANCE_FMRI may have some dependencies that aren't
1314  * enabled. This will attempt to enable all of them.
1315  */
1316 static void
smb_enable_dependencies(const char * fmri)1317 smb_enable_dependencies(const char *fmri)
1318 {
1319 	scf_handle_t *handle;
1320 	scf_service_t *service;
1321 	scf_instance_t *inst = NULL;
1322 	scf_iter_t *iter;
1323 	scf_property_t *prop;
1324 	scf_value_t *value;
1325 	scf_propertygroup_t *pg;
1326 	scf_scope_t *scope;
1327 	char type[SCFTYPE_LEN];
1328 	char *dependency;
1329 	char *servname;
1330 	int maxlen;
1331 
1332 	/*
1333 	 * Get all required handles and storage.
1334 	 */
1335 	handle = scf_handle_create(SCF_VERSION);
1336 	if (handle == NULL)
1337 		return;
1338 
1339 	if (scf_handle_bind(handle) != 0) {
1340 		scf_handle_destroy(handle);
1341 		return;
1342 	}
1343 
1344 	maxlen = scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH);
1345 	if (maxlen == (ssize_t)-1)
1346 		maxlen = MAXPATHLEN;
1347 
1348 	dependency = malloc(maxlen);
1349 
1350 	service = scf_service_create(handle);
1351 
1352 	iter = scf_iter_create(handle);
1353 
1354 	pg = scf_pg_create(handle);
1355 
1356 	prop = scf_property_create(handle);
1357 
1358 	value = scf_value_create(handle);
1359 
1360 	scope = scf_scope_create(handle);
1361 
1362 	if (service == NULL || iter == NULL || pg == NULL || prop == NULL ||
1363 	    value == NULL || scope == NULL || dependency == NULL)
1364 		goto done;
1365 
1366 	/*
1367 	 *  We passed in the FMRI for the default instance but for
1368 	 *  some things we need the simple form so construct it. Since
1369 	 *  we reuse the storage that dependency points to, we need to
1370 	 *  use the servname early.
1371 	 */
1372 	(void) snprintf(dependency, maxlen, "%s", fmri + sizeof ("svc:"));
1373 	servname = strrchr(dependency, ':');
1374 	if (servname == NULL)
1375 		goto done;
1376 	*servname = '\0';
1377 	servname = dependency;
1378 
1379 	/*
1380 	 * Setup to iterate over the service property groups, only
1381 	 * looking at those that are "dependency" types. The "entity"
1382 	 * property will have the FMRI of the service we are dependent
1383 	 * on.
1384 	 */
1385 	if (scf_handle_get_scope(handle, SCF_SCOPE_LOCAL, scope) != 0)
1386 		goto done;
1387 
1388 	if (scf_scope_get_service(scope, servname, service) != 0)
1389 		goto done;
1390 
1391 	if (scf_iter_service_pgs(iter, service) != 0)
1392 		goto done;
1393 
1394 	while (scf_iter_next_pg(iter, pg) > 0) {
1395 		char *services[2];
1396 		/*
1397 		 * Have a property group for the service. See if it is
1398 		 * a dependency pg and only do operations on those.
1399 		 */
1400 		if (scf_pg_get_type(pg, type, SCFTYPE_LEN) <= 0)
1401 			continue;
1402 
1403 		if (strncmp(type, SCF_GROUP_DEPENDENCY, SCFTYPE_LEN) != 0)
1404 			continue;
1405 		/*
1406 		 * Have a dependency.  Attempt to enable it.
1407 		 */
1408 		if (scf_pg_get_property(pg, SCF_PROPERTY_ENTITIES, prop) != 0)
1409 			continue;
1410 
1411 		if (scf_property_get_value(prop, value) != 0)
1412 			continue;
1413 
1414 		services[1] = NULL;
1415 
1416 		if (scf_value_get_as_string(value, dependency, maxlen) > 0) {
1417 			services[0] = dependency;
1418 			_check_services(services);
1419 		}
1420 	}
1421 
1422 done:
1423 	if (dependency != NULL)
1424 		free(dependency);
1425 	if (value != NULL)
1426 		scf_value_destroy(value);
1427 	if (prop != NULL)
1428 		scf_property_destroy(prop);
1429 	if (pg != NULL)
1430 		scf_pg_destroy(pg);
1431 	if (iter != NULL)
1432 		scf_iter_destroy(iter);
1433 	if (scope != NULL)
1434 		scf_scope_destroy(scope);
1435 	if (inst != NULL)
1436 		scf_instance_destroy(inst);
1437 	if (service != NULL)
1438 		scf_service_destroy(service);
1439 
1440 	(void) scf_handle_unbind(handle);
1441 	scf_handle_destroy(handle);
1442 }
1443 
1444 /*
1445  * How long to wait for service to come online
1446  */
1447 #define	WAIT_FOR_SERVICE	15
1448 
1449 /*
1450  * smb_enable_service()
1451  *
1452  */
1453 static int
smb_enable_service(void)1454 smb_enable_service(void)
1455 {
1456 	int i;
1457 	int ret = SA_OK;
1458 	char *service[] = { SMBD_DEFAULT_INSTANCE_FMRI, NULL };
1459 
1460 	if (!smb_isonline()) {
1461 		/*
1462 		 * Attempt to start the idmap, and other dependent
1463 		 * services, first.  If it fails, the SMB service will
1464 		 * ultimately fail so we use that as the error.  If we
1465 		 * don't try to enable idmap, smb won't start the
1466 		 * first time unless the admin has done it
1467 		 * manually. The service could be administratively
1468 		 * disabled so we won't always get started.
1469 		 */
1470 		smb_enable_dependencies(SMBD_DEFAULT_INSTANCE_FMRI);
1471 		_check_services(service);
1472 
1473 		/* Wait for service to come online */
1474 		for (i = 0; i < WAIT_FOR_SERVICE; i++) {
1475 			if (smb_isonline()) {
1476 				ret =  SA_OK;
1477 				break;
1478 			} else if (smb_ismaint()) {
1479 				/* maintenance requires help */
1480 				ret = SA_SYSTEM_ERR;
1481 				break;
1482 			} else {
1483 				/* try another time */
1484 				ret = SA_BUSY;
1485 				(void) sleep(1);
1486 			}
1487 		}
1488 	}
1489 	return (ret);
1490 }
1491 
1492 /*
1493  * smb_validate_proto_prop(index, name, value)
1494  *
1495  * Verify that the property specified by name can take the new
1496  * value. This is a sanity check to prevent bad values getting into
1497  * the default files.
1498  */
1499 static int
smb_validate_proto_prop(int index,char * name,char * value)1500 smb_validate_proto_prop(int index, char *name, char *value)
1501 {
1502 	if ((name == NULL) || (index < 0))
1503 		return (SA_BAD_VALUE);
1504 
1505 	if (smb_proto_options[index].validator == NULL)
1506 		return (SA_OK);
1507 
1508 	if (smb_proto_options[index].validator(index, value) == SA_OK)
1509 		return (SA_OK);
1510 	return (SA_BAD_VALUE);
1511 }
1512 
1513 /*
1514  * smb_set_proto_prop(prop)
1515  *
1516  * check that prop is valid.
1517  */
1518 /*ARGSUSED*/
1519 static int
smb_set_proto_prop(sa_property_t prop)1520 smb_set_proto_prop(sa_property_t prop)
1521 {
1522 	int ret = SA_OK;
1523 	char *name;
1524 	char *value;
1525 	int index = -1;
1526 	struct smb_proto_option_defs *opt;
1527 
1528 	name = sa_get_property_attr(prop, "type");
1529 	value = sa_get_property_attr(prop, "value");
1530 	if (name != NULL && value != NULL) {
1531 		index = findprotoopt(name);
1532 		if (index >= 0) {
1533 			/* should test for valid value */
1534 			ret = smb_validate_proto_prop(index, name, value);
1535 			if (ret == SA_OK) {
1536 				opt = &smb_proto_options[index];
1537 
1538 				/* Save to SMF */
1539 				if (smb_config_set(opt->smb_index,
1540 				    value) != 0) {
1541 					ret = SA_BAD_VALUE;
1542 					goto out;
1543 				}
1544 				/*
1545 				 * Specialized refresh mechanisms can
1546 				 * be flagged in the proto_options and
1547 				 * processed here.
1548 				 */
1549 				if (opt->refresh & SMB_REFRESH_REFRESH)
1550 					(void) smf_refresh_instance(
1551 					    SMBD_DEFAULT_INSTANCE_FMRI);
1552 				else if (opt->refresh & SMB_REFRESH_RESTART)
1553 					(void) smf_restart_instance(
1554 					    SMBD_DEFAULT_INSTANCE_FMRI);
1555 			}
1556 		}
1557 	}
1558 
1559 out:
1560 	if (name != NULL)
1561 		sa_free_attr_string(name);
1562 	if (value != NULL)
1563 		sa_free_attr_string(value);
1564 
1565 	return (ret);
1566 }
1567 
1568 /*
1569  * smb_get_status()
1570  *
1571  * What is the current status of the smbd? We use the SMF state here.
1572  * Caller must free the returned value.
1573  */
1574 
1575 static char *
smb_get_status(void)1576 smb_get_status(void)
1577 {
1578 	return (smf_get_state(SMBD_DEFAULT_INSTANCE_FMRI));
1579 }
1580 
1581 /*
1582  * This protocol plugin require resource names
1583  */
1584 static uint64_t
smb_share_features(void)1585 smb_share_features(void)
1586 {
1587 	return (SA_FEATURE_RESOURCE | SA_FEATURE_ALLOWSUBDIRS |
1588 	    SA_FEATURE_ALLOWPARDIRS | SA_FEATURE_SERVER);
1589 }
1590 
1591 /*
1592  * This should be used to convert smb_share_t to sa_resource_t
1593  * Should only be needed to build transient shares/resources to be
1594  * supplied to sharemgr to display.
1595  */
1596 static int
smb_add_transient(sa_handle_t handle,smb_share_t * si)1597 smb_add_transient(sa_handle_t handle, smb_share_t *si)
1598 {
1599 	int err;
1600 	sa_share_t share;
1601 	sa_group_t group;
1602 	sa_resource_t resource;
1603 	nvlist_t *nvl;
1604 	char *opt;
1605 
1606 	if (si == NULL)
1607 		return (SA_INVALID_NAME);
1608 
1609 	if ((share = sa_find_share(handle, si->shr_path)) == NULL) {
1610 		if ((group = smb_get_defaultgrp(handle)) == NULL)
1611 			return (SA_NO_SUCH_GROUP);
1612 
1613 		share = sa_get_share(group, si->shr_path);
1614 		if (share == NULL) {
1615 			share = sa_add_share(group, si->shr_path,
1616 			    SA_SHARE_TRANSIENT, &err);
1617 			if (share == NULL)
1618 				return (SA_NO_SUCH_PATH);
1619 		}
1620 	}
1621 
1622 	/*
1623 	 * Now handle the resource. Make sure that the resource is
1624 	 * transient and added to the share.
1625 	 */
1626 	resource = sa_get_share_resource(share, si->shr_name);
1627 	if (resource == NULL) {
1628 		resource = sa_add_resource(share,
1629 		    si->shr_name, SA_SHARE_TRANSIENT, &err);
1630 		if (resource == NULL)
1631 			return (SA_NO_SUCH_RESOURCE);
1632 	}
1633 
1634 	if (si->shr_cmnt[0] != '\0')
1635 		(void) sa_set_resource_description(resource, si->shr_cmnt);
1636 
1637 	if (si->shr_container[0] != '\0')
1638 		(void) sa_set_resource_attr(resource, SHOPT_AD_CONTAINER,
1639 		    si->shr_container);
1640 
1641 	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
1642 		return (SA_NO_MEMORY);
1643 
1644 	if ((opt = smb_csc_name(si)) != NULL)
1645 		err |= nvlist_add_string(nvl, SHOPT_CSC, opt);
1646 
1647 	opt = (si->shr_flags & SMB_SHRF_ABE) ? "true" : "false";
1648 	err |= nvlist_add_string(nvl, SHOPT_ABE, opt);
1649 
1650 	if ((si->shr_flags & SMB_SHRF_AUTOHOME) == 0) {
1651 		opt = (si->shr_flags & SMB_SHRF_GUEST_OK) ? "true" : "false";
1652 		err |= nvlist_add_string(nvl, SHOPT_GUEST, opt);
1653 	}
1654 
1655 	if (si->shr_access_ro[0] != '\0')
1656 		err |= nvlist_add_string(nvl, SHOPT_RO, si->shr_access_ro);
1657 
1658 	if (si->shr_access_rw[0] != '\0')
1659 		err |= nvlist_add_string(nvl, SHOPT_RW, si->shr_access_rw);
1660 
1661 	if (si->shr_access_none[0] != '\0')
1662 		err |= nvlist_add_string(nvl, SHOPT_NONE, si->shr_access_none);
1663 
1664 	if (err) {
1665 		nvlist_free(nvl);
1666 		return (SA_CONFIG_ERR);
1667 	}
1668 
1669 	err = smb_update_optionset_props(handle, resource, nvl);
1670 
1671 	nvlist_free(nvl);
1672 	return (err);
1673 }
1674 
1675 /*
1676  * Return smb transient shares.
1677  */
1678 static int
smb_list_transient(sa_handle_t handle)1679 smb_list_transient(sa_handle_t handle)
1680 {
1681 	int i, offset;
1682 	smb_shrlist_t list;
1683 	int res;
1684 
1685 	if (smb_share_count() <= 0)
1686 		return (SA_OK);
1687 
1688 	offset = 0;
1689 	while (smb_share_list(offset, &list) == NERR_Success) {
1690 		if (list.sl_cnt == 0)
1691 			break;
1692 
1693 		for (i = 0; i < list.sl_cnt; i++) {
1694 			res = smb_add_transient(handle, &(list.sl_shares[i]));
1695 			if (res != SA_OK)
1696 				return (res);
1697 		}
1698 		offset += list.sl_cnt;
1699 	}
1700 
1701 	return (SA_OK);
1702 }
1703 
1704 /*
1705  * fix_resource_name(share, name,  prefix)
1706  *
1707  * Construct a name where the ZFS dataset has the prefix replaced with "name".
1708  */
1709 static char *
fix_resource_name(sa_share_t share,char * name,char * prefix)1710 fix_resource_name(sa_share_t share, char *name, char *prefix)
1711 {
1712 	char buf[SA_MAX_RESOURCE_NAME + 1];
1713 	char *dataset;
1714 	size_t bufsz = SA_MAX_RESOURCE_NAME + 1;
1715 	size_t prelen;
1716 
1717 	if (prefix == NULL)
1718 		return (strdup(name));
1719 
1720 	dataset = sa_get_share_attr(share, "dataset");
1721 	if (dataset == NULL)
1722 		return (strdup(name));
1723 
1724 	(void) strlcpy(buf, name, bufsz);
1725 	prelen = strlen(prefix);
1726 
1727 	if (strncmp(dataset, prefix, prelen) == 0)
1728 		(void) strlcat(buf, dataset + prelen, bufsz);
1729 
1730 	sa_free_attr_string(dataset);
1731 	sa_fix_resource_name(buf);
1732 	return (strdup(buf));
1733 }
1734 
1735 /*
1736  * smb_parse_optstring(group, options)
1737  *
1738  * parse a compact option string into individual options. This allows
1739  * ZFS sharesmb and sharemgr "share" command to work.  group can be a
1740  * group, a share or a resource.
1741  */
1742 static int
smb_parse_optstring(sa_group_t group,char * options)1743 smb_parse_optstring(sa_group_t group, char *options)
1744 {
1745 	char *dup;
1746 	char *base;
1747 	char *lasts;
1748 	char *token;
1749 	sa_optionset_t optionset;
1750 	sa_group_t parent = NULL;
1751 	sa_resource_t resource = NULL;
1752 	int iszfs = 0;
1753 	int persist = 0;
1754 	int need_optionset = 0;
1755 	int ret = SA_OK;
1756 	sa_property_t prop;
1757 
1758 	/*
1759 	 * In order to not attempt to change ZFS properties unless
1760 	 * absolutely necessary, we never do it in the legacy parsing
1761 	 * so we need to keep track of this.
1762 	 */
1763 	if (sa_is_share(group)) {
1764 		char *zfs;
1765 
1766 		parent = sa_get_parent_group(group);
1767 		if (parent != NULL) {
1768 			zfs = sa_get_group_attr(parent, "zfs");
1769 			if (zfs != NULL) {
1770 				sa_free_attr_string(zfs);
1771 				iszfs = 1;
1772 			}
1773 		}
1774 	} else {
1775 		iszfs = sa_group_is_zfs(group);
1776 		/*
1777 		 * If a ZFS group, then we need to see if a resource
1778 		 * name is being set. If so, bail with
1779 		 * SA_PROP_SHARE_ONLY, so we come back in with a share
1780 		 * instead of a group.
1781 		 */
1782 		if (iszfs ||
1783 		    strncmp(options, "name=", sizeof ("name=") - 1) == 0 ||
1784 		    strstr(options, ",name=") != NULL) {
1785 			return (SA_PROP_SHARE_ONLY);
1786 		}
1787 	}
1788 
1789 	/* do we have an existing optionset? */
1790 	optionset = sa_get_optionset(group, "smb");
1791 	if (optionset == NULL) {
1792 		/* didn't find existing optionset so create one */
1793 		optionset = sa_create_optionset(group, "smb");
1794 		if (optionset == NULL)
1795 			return (SA_NO_MEMORY);
1796 	} else {
1797 		/*
1798 		 * If an optionset already exists, we've come through
1799 		 * twice so ignore the second time.
1800 		 */
1801 		return (ret);
1802 	}
1803 
1804 	/* We need a copy of options for the next part. */
1805 	dup = strdup(options);
1806 	if (dup == NULL)
1807 		return (SA_NO_MEMORY);
1808 
1809 	/*
1810 	 * SMB properties are straightforward and are strings,
1811 	 * integers or booleans.  Properties are separated by
1812 	 * commas. It will be necessary to parse quotes due to some
1813 	 * strings not having a restricted characters set.
1814 	 *
1815 	 * Note that names will create a resource. For now, if there
1816 	 * is a set of properties "before" the first name="", those
1817 	 * properties will be placed on the group.
1818 	 */
1819 	persist = sa_is_persistent(group);
1820 	base = dup;
1821 	token = dup;
1822 	lasts = NULL;
1823 	while (token != NULL && ret == SA_OK) {
1824 		ret = SA_OK;
1825 		token = strtok_r(base, ",", &lasts);
1826 		base = NULL;
1827 		if (token != NULL) {
1828 			char *value;
1829 			/*
1830 			 * All SMB properties have values so there
1831 			 * MUST be an '=' character.  If it doesn't,
1832 			 * it is a syntax error.
1833 			 */
1834 			value = strchr(token, '=');
1835 			if (value != NULL) {
1836 				*value++ = '\0';
1837 			} else {
1838 				ret = SA_SYNTAX_ERR;
1839 				break;
1840 			}
1841 			/*
1842 			 * We may need to handle a "name" property
1843 			 * that is a ZFS imposed resource name. Each
1844 			 * name would trigger getting a new "resource"
1845 			 * to put properties on. For now, assume no
1846 			 * "name" property for special handling.
1847 			 */
1848 
1849 			if (strcmp(token, SHOPT_NAME) == 0) {
1850 				char *prefix;
1851 				char *name = NULL;
1852 				/*
1853 				 * We have a name, so now work on the
1854 				 * resource level. We have a "share"
1855 				 * in "group" due to the caller having
1856 				 * added it. If we are called with a
1857 				 * group, the check for group/share
1858 				 * at the beginning of this function
1859 				 * will bail out the parse if there is a
1860 				 * "name" but no share.
1861 				 */
1862 				if (!iszfs) {
1863 					ret = SA_SYNTAX_ERR;
1864 					break;
1865 				}
1866 				/*
1867 				 * Make sure the parent group has the
1868 				 * "prefix" property since we will
1869 				 * need to use this for constructing
1870 				 * inherited name= values.
1871 				 */
1872 				prefix = sa_get_group_attr(parent, "prefix");
1873 				if (prefix == NULL) {
1874 					prefix = sa_get_group_attr(parent,
1875 					    "name");
1876 					if (prefix != NULL) {
1877 						(void) sa_set_group_attr(parent,
1878 						    "prefix", prefix);
1879 					}
1880 				}
1881 				name = fix_resource_name((sa_share_t)group,
1882 				    value, prefix);
1883 				if (name != NULL) {
1884 					resource = sa_add_resource(
1885 					    (sa_share_t)group, name,
1886 					    SA_SHARE_TRANSIENT, &ret);
1887 					sa_free_attr_string(name);
1888 				} else {
1889 					ret = SA_NO_MEMORY;
1890 				}
1891 				if (prefix != NULL)
1892 					sa_free_attr_string(prefix);
1893 
1894 				/* A resource level optionset is needed */
1895 
1896 				need_optionset = 1;
1897 				if (resource == NULL) {
1898 					ret = SA_NO_MEMORY;
1899 					break;
1900 				}
1901 				continue;
1902 			}
1903 
1904 			if (iszfs && strcmp(token, SHOPT_DESCRIPTION) == 0) {
1905 				if (resource == NULL)
1906 					(void) sa_set_share_description(
1907 					    (sa_share_t)group, value);
1908 				else
1909 					(void) sa_set_resource_description(
1910 					    resource, value);
1911 				continue;
1912 			}
1913 
1914 			if (need_optionset) {
1915 				optionset = sa_create_optionset(resource,
1916 				    "smb");
1917 				need_optionset = 0;
1918 			}
1919 
1920 			prop = sa_create_property(token, value);
1921 			if (prop == NULL)
1922 				ret = SA_NO_MEMORY;
1923 			else
1924 				ret = sa_add_property(optionset, prop);
1925 			if (ret != SA_OK)
1926 				break;
1927 			if (!iszfs)
1928 				ret = sa_commit_properties(optionset, !persist);
1929 		}
1930 	}
1931 	free(dup);
1932 	return (ret);
1933 }
1934 
1935 /*
1936  * smb_sprint_option(rbuff, rbuffsize, incr, prop, sep)
1937  *
1938  * provides a mechanism to format SMB properties into legacy output
1939  * format. If the buffer would overflow, it is reallocated and grown
1940  * as appropriate. Special cases of converting internal form of values
1941  * to those used by "share" are done. this function does one property
1942  * at a time.
1943  */
1944 
1945 static void
smb_sprint_option(char ** rbuff,size_t * rbuffsize,size_t incr,sa_property_t prop,int sep)1946 smb_sprint_option(char **rbuff, size_t *rbuffsize, size_t incr,
1947     sa_property_t prop, int sep)
1948 {
1949 	char *name;
1950 	char *value;
1951 	int curlen;
1952 	char *buff = *rbuff;
1953 	size_t buffsize = *rbuffsize;
1954 
1955 	name = sa_get_property_attr(prop, "type");
1956 	value = sa_get_property_attr(prop, "value");
1957 	if (buff != NULL)
1958 		curlen = strlen(buff);
1959 	else
1960 		curlen = 0;
1961 	if (name != NULL) {
1962 		int len;
1963 		len = strlen(name) + sep;
1964 
1965 		/*
1966 		 * A future RFE would be to replace this with more
1967 		 * generic code and to possibly handle more types.
1968 		 *
1969 		 * For now, everything else is treated as a string. If
1970 		 * we get any properties that aren't exactly
1971 		 * name/value pairs, we may need to
1972 		 * interpret/transform.
1973 		 */
1974 		if (value != NULL)
1975 			len += 1 + strlen(value);
1976 
1977 		while (buffsize <= (curlen + len)) {
1978 			/* need more room */
1979 			buffsize += incr;
1980 			buff = realloc(buff, buffsize);
1981 			*rbuff = buff;
1982 			*rbuffsize = buffsize;
1983 			if (buff == NULL) {
1984 				/* realloc failed so free everything */
1985 				if (*rbuff != NULL)
1986 					free(*rbuff);
1987 				goto err;
1988 			}
1989 		}
1990 		if (buff == NULL)
1991 			goto err;
1992 		(void) snprintf(buff + curlen, buffsize - curlen,
1993 		    "%s%s=%s", sep ? "," : "",
1994 		    name, value != NULL ? value : "\"\"");
1995 
1996 	}
1997 err:
1998 	if (name != NULL)
1999 		sa_free_attr_string(name);
2000 	if (value != NULL)
2001 		sa_free_attr_string(value);
2002 }
2003 
2004 /*
2005  * smb_format_resource_options(resource, hier)
2006  *
2007  * format all the options on the group into a flattened option
2008  * string. If hier is non-zero, walk up the tree to get inherited
2009  * options.
2010  */
2011 
2012 static char *
smb_format_options(sa_group_t group,int hier)2013 smb_format_options(sa_group_t group, int hier)
2014 {
2015 	sa_optionset_t options = NULL;
2016 	sa_property_t prop;
2017 	int sep = 0;
2018 	char *buff;
2019 	size_t buffsize;
2020 
2021 
2022 	buff = malloc(OPT_CHUNK);
2023 	if (buff == NULL)
2024 		return (NULL);
2025 
2026 	buff[0] = '\0';
2027 	buffsize = OPT_CHUNK;
2028 
2029 	/*
2030 	 * We may have a an optionset relative to this item. format
2031 	 * these if we find them and then add any security definitions.
2032 	 */
2033 
2034 	options = sa_get_derived_optionset(group, "smb", hier);
2035 
2036 	/*
2037 	 * do the default set first but skip any option that is also
2038 	 * in the protocol specific optionset.
2039 	 */
2040 	if (options != NULL) {
2041 		for (prop = sa_get_property(options, NULL);
2042 		    prop != NULL; prop = sa_get_next_property(prop)) {
2043 			/*
2044 			 * use this one since we skipped any
2045 			 * of these that were also in
2046 			 * optdefault
2047 			 */
2048 			smb_sprint_option(&buff, &buffsize, OPT_CHUNK,
2049 			    prop, sep);
2050 			if (buff == NULL) {
2051 				/*
2052 				 * buff could become NULL if there
2053 				 * isn't enough memory for
2054 				 * smb_sprint_option to realloc()
2055 				 * as necessary. We can't really
2056 				 * do anything about it at this
2057 				 * point so we return NULL.  The
2058 				 * caller should handle the
2059 				 * failure.
2060 				 */
2061 				if (options != NULL)
2062 					sa_free_derived_optionset(
2063 					    options);
2064 				return (buff);
2065 			}
2066 			sep = 1;
2067 		}
2068 	}
2069 
2070 	if (options != NULL)
2071 		sa_free_derived_optionset(options);
2072 	return (buff);
2073 }
2074 
2075 /*
2076  * smb_rename_resource(resource, newname)
2077  *
2078  * Change the current exported name of the resource to newname.
2079  */
2080 /*ARGSUSED*/
2081 int
smb_rename_resource(sa_handle_t handle,sa_resource_t resource,char * newname)2082 smb_rename_resource(sa_handle_t handle, sa_resource_t resource, char *newname)
2083 {
2084 	int ret = SA_OK;
2085 	int err;
2086 	char *oldname;
2087 
2088 	if (!smb_isonline())
2089 		return (SA_OK);
2090 
2091 	oldname = sa_get_resource_attr(resource, "name");
2092 	if (oldname == NULL)
2093 		return (SA_NO_SUCH_RESOURCE);
2094 
2095 	err = smb_share_rename(oldname, newname);
2096 
2097 	sa_free_attr_string(oldname);
2098 
2099 	/* improve error values somewhat */
2100 	switch (err) {
2101 	case NERR_Success:
2102 		break;
2103 	case NERR_InternalError:
2104 		ret = SA_SYSTEM_ERR;
2105 		break;
2106 	case NERR_DuplicateShare:
2107 		ret = SA_DUPLICATE_NAME;
2108 		break;
2109 	default:
2110 		ret = SA_CONFIG_ERR;
2111 		break;
2112 	}
2113 
2114 	return (ret);
2115 }
2116 
2117 static int
smb_build_shareinfo(sa_share_t share,sa_resource_t resource,smb_share_t * si)2118 smb_build_shareinfo(sa_share_t share, sa_resource_t resource, smb_share_t *si)
2119 {
2120 	sa_optionset_t opts;
2121 	char *path;
2122 	char *rname;
2123 	char *val = NULL;
2124 	char csc_value[SMB_CSC_BUFSZ];
2125 	char strbuf[sizeof ("required")];
2126 
2127 	bzero(si, sizeof (smb_share_t));
2128 
2129 	if ((path = sa_get_share_attr(share, "path")) == NULL)
2130 		return (SA_NO_SUCH_PATH);
2131 
2132 	if ((rname = sa_get_resource_attr(resource, "name")) == NULL) {
2133 		sa_free_attr_string(path);
2134 		return (SA_NO_SUCH_RESOURCE);
2135 	}
2136 
2137 	(void) strlcpy(si->shr_path, path, sizeof (si->shr_path));
2138 	(void) strlcpy(si->shr_name, rname, sizeof (si->shr_name));
2139 	sa_free_attr_string(path);
2140 	sa_free_attr_string(rname);
2141 
2142 	val = sa_get_resource_description(resource);
2143 	if (val == NULL)
2144 		val = sa_get_share_description(share);
2145 
2146 	if (val != NULL) {
2147 		(void) strlcpy(si->shr_cmnt, val, sizeof (si->shr_cmnt));
2148 		sa_free_share_description(val);
2149 	}
2150 
2151 	si->shr_flags = (sa_is_persistent(share))
2152 	    ? SMB_SHRF_PERM : SMB_SHRF_TRANS;
2153 
2154 	opts = sa_get_derived_optionset(resource, SMB_PROTOCOL_NAME, 1);
2155 	if (opts == NULL)
2156 		return (SA_OK);
2157 
2158 	if (smb_saprop_getbool(opts, SHOPT_CATIA, B_FALSE))
2159 		si->shr_flags |= SMB_SHRF_CATIA;
2160 
2161 	if (smb_saprop_getbool(opts, SHOPT_ABE, B_FALSE))
2162 		si->shr_flags |= SMB_SHRF_ABE;
2163 
2164 	if (smb_saprop_getbool(opts, SHOPT_GUEST, B_FALSE))
2165 		si->shr_flags |= SMB_SHRF_GUEST_OK;
2166 
2167 	if (smb_saprop_getbool(opts, SHOPT_DFSROOT, B_FALSE))
2168 		si->shr_flags |= SMB_SHRF_DFSROOT;
2169 
2170 	if (smb_saprop_getbool(opts, SHOPT_CA, B_FALSE))
2171 		si->shr_flags |= SMB_SHRF_CA;
2172 
2173 	if (smb_saprop_getbool(opts, SHOPT_FSO, B_FALSE))
2174 		si->shr_flags |= SMB_SHRF_FSO;
2175 
2176 	/* Quotas are enabled by default. */
2177 	if (smb_saprop_getbool(opts, SHOPT_QUOTAS, B_TRUE))
2178 		si->shr_flags |= SMB_SHRF_QUOTAS;
2179 
2180 	if (smb_saprop_getstr(opts, SHOPT_ENCRYPT, strbuf, sizeof (strbuf)))
2181 		smb_cfg_set_require(strbuf, &si->shr_encrypt);
2182 
2183 	(void) smb_saprop_getstr(opts, SHOPT_AD_CONTAINER, si->shr_container,
2184 	    sizeof (si->shr_container));
2185 
2186 	if (smb_saprop_getstr(opts, SHOPT_CSC, csc_value, sizeof (csc_value)))
2187 		smb_csc_option(csc_value, si);
2188 
2189 	if (smb_saprop_getstr(opts, SHOPT_RO, si->shr_access_ro,
2190 	    sizeof (si->shr_access_ro)))
2191 		si->shr_flags |= SMB_SHRF_ACC_RO;
2192 
2193 	if (smb_saprop_getstr(opts, SHOPT_RW, si->shr_access_rw,
2194 	    sizeof (si->shr_access_rw)))
2195 		si->shr_flags |= SMB_SHRF_ACC_RW;
2196 
2197 	if (smb_saprop_getstr(opts, SHOPT_NONE, si->shr_access_none,
2198 	    sizeof (si->shr_access_none)))
2199 		si->shr_flags |= SMB_SHRF_ACC_NONE;
2200 
2201 	sa_free_derived_optionset(opts);
2202 	return (SA_OK);
2203 }
2204 
2205 /*
2206  * Map a client-side caching (CSC) option to the appropriate share
2207  * flag.  Only one option is allowed; an error will be logged if
2208  * multiple options have been specified.  We don't need to do anything
2209  * about multiple values here because the SRVSVC will not recognize
2210  * a value containing multiple flags and will return the default value.
2211  *
2212  * If the option value is not recognized, it will be ignored: invalid
2213  * values will typically be caught and rejected by sharemgr.
2214  */
2215 static void
smb_csc_option(const char * value,smb_share_t * si)2216 smb_csc_option(const char *value, smb_share_t *si)
2217 {
2218 	char buf[SMB_CSC_BUFSZ];
2219 	int i;
2220 
2221 	for (i = 0; i < (sizeof (cscopt) / sizeof (cscopt[0])); ++i) {
2222 		if (strcasecmp(value, cscopt[i].value) == 0) {
2223 			si->shr_flags |= cscopt[i].flag;
2224 			break;
2225 		}
2226 	}
2227 
2228 	switch (si->shr_flags & SMB_SHRF_CSC_MASK) {
2229 	case 0:
2230 	case SMB_SHRF_CSC_DISABLED:
2231 	case SMB_SHRF_CSC_MANUAL:
2232 	case SMB_SHRF_CSC_AUTO:
2233 	case SMB_SHRF_CSC_VDO:
2234 		break;
2235 
2236 	default:
2237 		buf[0] = '\0';
2238 
2239 		for (i = 0; i < (sizeof (cscopt) / sizeof (cscopt[0])); ++i) {
2240 			if (si->shr_flags & cscopt[i].flag) {
2241 				(void) strlcat(buf, " ", SMB_CSC_BUFSZ);
2242 				(void) strlcat(buf, cscopt[i].value,
2243 				    SMB_CSC_BUFSZ);
2244 			}
2245 		}
2246 
2247 		syslog(LOG_ERR, "csc option conflict:%s", buf);
2248 		break;
2249 	}
2250 }
2251 
2252 /*
2253  * Return the option name for the first CSC flag (there should be only
2254  * one) encountered in the share flags.
2255  */
2256 static char *
smb_csc_name(const smb_share_t * si)2257 smb_csc_name(const smb_share_t *si)
2258 {
2259 	int i;
2260 
2261 	for (i = 0; i < (sizeof (cscopt) / sizeof (cscopt[0])); ++i) {
2262 		if (si->shr_flags & cscopt[i].flag)
2263 			return (cscopt[i].value);
2264 	}
2265 
2266 	return (NULL);
2267 }
2268 
2269 /*
2270  * smb_get_defaultgrp
2271  *
2272  * If default group for CIFS shares (i.e. "smb") exists
2273  * then it will return the group handle, otherwise it will
2274  * create the group and return the handle.
2275  *
2276  * All the shares created by CIFS clients (this is only possible
2277  * via RPC) will be added to "smb" groups.
2278  */
2279 static sa_group_t
smb_get_defaultgrp(sa_handle_t handle)2280 smb_get_defaultgrp(sa_handle_t handle)
2281 {
2282 	sa_group_t group = NULL;
2283 	int err;
2284 
2285 	group = sa_get_group(handle, SMB_DEFAULT_SHARE_GROUP);
2286 	if (group != NULL)
2287 		return (group);
2288 
2289 	group = sa_create_group(handle, SMB_DEFAULT_SHARE_GROUP, &err);
2290 	if (group == NULL)
2291 		return (NULL);
2292 
2293 	if (sa_create_optionset(group, SMB_DEFAULT_SHARE_GROUP) == NULL) {
2294 		(void) sa_remove_group(group);
2295 		group = NULL;
2296 	}
2297 
2298 	return (group);
2299 }
2300 
2301 /*
2302  * Checks to see if the command args are the supported substitution specifier.
2303  * i.e. <cmd> %U %S
2304  */
2305 static int
cmd_validator(int index,char * value)2306 cmd_validator(int index, char *value)
2307 {
2308 	char cmd[MAXPATHLEN];
2309 	char *ptr, *v;
2310 	boolean_t skip_cmdname;
2311 
2312 	if (string_length_check_validator(index, value) != SA_OK)
2313 		return (SA_BAD_VALUE);
2314 
2315 	if (*value == '\0')
2316 		return (SA_OK);
2317 
2318 	(void) strlcpy(cmd, value, sizeof (cmd));
2319 
2320 	ptr = cmd;
2321 	skip_cmdname = B_TRUE;
2322 	do {
2323 		if ((v = strsep(&ptr, " ")) == NULL)
2324 			break;
2325 
2326 		if (*v != '\0') {
2327 
2328 			if (skip_cmdname) {
2329 				skip_cmdname = B_FALSE;
2330 				continue;
2331 			}
2332 
2333 			if ((strlen(v) != 2) || *v != '%')
2334 				return (SA_BAD_VALUE);
2335 
2336 			if (strpbrk(v, SMB_VALID_SUB_CHRS) == NULL)
2337 				return (SA_BAD_VALUE);
2338 		}
2339 
2340 	} while (v != NULL);
2341 
2342 	/*
2343 	 * If skip_cmdname is still true then the string contains
2344 	 * only spaces.  Don't allow such a string.
2345 	 */
2346 	if (skip_cmdname)
2347 		return (SA_BAD_VALUE);
2348 
2349 	return (SA_OK);
2350 }
2351 
2352 /*ARGSUSED*/
2353 static int
disposition_validator(int index,char * value)2354 disposition_validator(int index, char *value)
2355 {
2356 	if (value == NULL)
2357 		return (SA_BAD_VALUE);
2358 
2359 	if (*value == '\0')
2360 		return (SA_OK);
2361 
2362 	if ((strcasecmp(value, SMB_EXEC_DISP_CONTINUE) == 0) ||
2363 	    (strcasecmp(value, SMB_EXEC_DISP_TERMINATE) == 0))
2364 		return (SA_OK);
2365 
2366 	return (SA_BAD_VALUE);
2367 }
2368 
2369 /*ARGSUSED*/
2370 static int
protocol_validator(int index,char * value)2371 protocol_validator(int index, char *value)
2372 {
2373 	if (value == NULL)
2374 		return (SA_BAD_VALUE);
2375 
2376 	if (*value == '\0')
2377 		return (SA_OK);
2378 
2379 	if (smb_config_check_protocol(value) == 0)
2380 		return (SA_OK);
2381 
2382 	return (SA_BAD_VALUE);
2383 
2384 }
2385 
2386 /*
2387  * Updates the optionset properties of the share resource.
2388  * The properties are given as a list of name-value pair.
2389  * The name argument should be the optionset property name and the value
2390  * should be a valid value for the specified property.
2391  *
2392  * When calling this function for permanent shares, the caller must also
2393  * call sa_commit_properties() to commit the changes to SMF.
2394  */
2395 static int
smb_update_optionset_props(sa_handle_t handle,sa_resource_t resource,nvlist_t * nvl)2396 smb_update_optionset_props(sa_handle_t handle, sa_resource_t resource,
2397     nvlist_t *nvl)
2398 {
2399 	sa_property_t prop;
2400 	sa_optionset_t opts;
2401 	int err = SA_OK;
2402 	nvpair_t *cur;
2403 	char *name, *val;
2404 
2405 	if ((opts = sa_get_optionset(resource, SMB_PROTOCOL_NAME)) == NULL) {
2406 		opts = sa_create_optionset(resource, SMB_PROTOCOL_NAME);
2407 		if (opts == NULL)
2408 			return (SA_CONFIG_ERR);
2409 	}
2410 
2411 	cur = nvlist_next_nvpair(nvl, NULL);
2412 	while (cur != NULL) {
2413 		name = nvpair_name(cur);
2414 		err = nvpair_value_string(cur, &val);
2415 		if ((err != 0) || (name == NULL) || (val == NULL)) {
2416 			err = SA_CONFIG_ERR;
2417 			break;
2418 		}
2419 
2420 		prop = NULL;
2421 		if ((prop = sa_get_property(opts, name)) == NULL) {
2422 			prop = sa_create_property(name, val);
2423 			if (prop != NULL) {
2424 				err = sa_valid_property(handle, opts,
2425 				    SMB_PROTOCOL_NAME, prop);
2426 				if (err != SA_OK) {
2427 					(void) sa_remove_property(prop);
2428 					break;
2429 				}
2430 			}
2431 			err = sa_add_property(opts, prop);
2432 			if (err != SA_OK)
2433 				break;
2434 		} else {
2435 			err = sa_update_property(prop, val);
2436 			if (err != SA_OK)
2437 				break;
2438 		}
2439 
2440 		cur = nvlist_next_nvpair(nvl, cur);
2441 	}
2442 
2443 	return (err);
2444 }
2445 
2446 static boolean_t
smb_saprop_getbool(sa_optionset_t opts,char * propname,boolean_t def)2447 smb_saprop_getbool(sa_optionset_t opts, char *propname, boolean_t def)
2448 {
2449 	sa_property_t prop;
2450 	char *val;
2451 	boolean_t ret = def;
2452 
2453 	prop = sa_get_property(opts, propname);
2454 	if ((val = sa_get_property_attr(prop, "value")) != NULL) {
2455 		if (def) {
2456 			/* Default is true, ret false if... */
2457 			if ((strcasecmp(val, "false") == 0) ||
2458 			    (strcmp(val, "0") == 0))
2459 				ret = B_FALSE;
2460 		} else {
2461 			/* Default is false, ret true if... */
2462 			if ((strcasecmp(val, "true") == 0) ||
2463 			    (strcmp(val, "1") == 0))
2464 				ret = B_TRUE;
2465 		}
2466 		free(val);
2467 	}
2468 
2469 	return (ret);
2470 }
2471 
2472 static boolean_t
smb_saprop_getstr(sa_optionset_t opts,char * propname,char * buf,size_t bufsz)2473 smb_saprop_getstr(sa_optionset_t opts, char *propname, char *buf, size_t bufsz)
2474 {
2475 	sa_property_t prop;
2476 	char *val;
2477 
2478 	prop = sa_get_property(opts, propname);
2479 	if ((val = sa_get_property_attr(prop, "value")) != NULL) {
2480 		(void) strlcpy(buf, val, bufsz);
2481 		free(val);
2482 		return (B_TRUE);
2483 	}
2484 
2485 	return (B_FALSE);
2486 }
2487