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 */
61static int smb_share_init(void);
62static void smb_share_fini(void);
63static int smb_enable_share(sa_share_t);
64static int smb_share_changed(sa_share_t);
65static int smb_resource_changed(sa_resource_t);
66static int smb_rename_resource(sa_handle_t, sa_resource_t, char *);
67static int smb_disable_share(sa_share_t share, char *);
68static int smb_validate_property(sa_handle_t, sa_property_t, sa_optionset_t);
69static int smb_set_proto_prop(sa_property_t);
70static sa_protocol_properties_t smb_get_proto_set(void);
71static char *smb_get_status(void);
72static int smb_parse_optstring(sa_group_t, char *);
73static char *smb_format_options(sa_group_t, int);
74
75static int smb_enable_service(void);
76
77static int range_check_validator(int, char *);
78static int range_check_validator_zero_ok(int, char *);
79static int string_length_check_validator(int, char *);
80static int print_enable_validator(int, char *);
81static int true_false_validator(int, char *);
82static int ipv4_validator(int, char *);
83static int hostname_validator(int, char *);
84static int path_validator(int, char *);
85static int cmd_validator(int, char *);
86static int disposition_validator(int, char *);
87static int protocol_validator(int, char *);
88static int require_validator(int, char *);
89
90static int smb_enable_resource(sa_resource_t);
91static int smb_disable_resource(sa_resource_t);
92static uint64_t smb_share_features(void);
93static int smb_list_transient(sa_handle_t);
94
95static int smb_build_shareinfo(sa_share_t, sa_resource_t, smb_share_t *);
96static void smb_csc_option(const char *, smb_share_t *);
97static char *smb_csc_name(const smb_share_t *);
98static sa_group_t smb_get_defaultgrp(sa_handle_t);
99static int interface_validator(int, char *);
100static int smb_update_optionset_props(sa_handle_t, sa_resource_t, nvlist_t *);
101
102static boolean_t smb_saprop_getbool(sa_optionset_t, char *, boolean_t);
103static boolean_t smb_saprop_getstr(sa_optionset_t, char *, char *, size_t);
104
105static 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
129typedef 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
140struct 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
170struct 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 */
195static int
196findopt(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 */
213static boolean_t
214is_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
242static int
243check_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 */
259static boolean_t
260validresource(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 */
286static boolean_t
287validcsc(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 */
305static boolean_t
306smb_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 */
324static boolean_t
325smb_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 */
345static boolean_t
346smb_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 */
368static boolean_t
369smb_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 */
387static int
388smb_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");
464done:
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
477static int
478smb_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 */
526static int
527smb_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 */
571static int
572smb_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 */
600static int
601smb_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 */
632static int
633smb_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	}
714done:
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*/
733static int
734smb_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
846struct 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
908static int
909require_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 */
929static int
930range_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 */
949static int
950range_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 */
973static int
974string_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*/
989static int
990true_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*/
1005static int
1006print_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*/
1025static int
1026ipv4_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*/
1052static int
1053hostname_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 */
1116static boolean_t
1117smb_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 */
1130static boolean_t
1131smb_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*/
1150static int
1151interface_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*/
1189static int
1190path_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 */
1217static sa_protocol_properties_t protoset;
1218
1219static int
1220findprotoopt(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
1240static int
1241smb_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
1275static int
1276smb_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 */
1289static void
1290smb_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 */
1304static sa_protocol_properties_t
1305smb_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 */
1316static void
1317smb_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
1422done:
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 */
1453static int
1454smb_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 */
1499static int
1500smb_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*/
1519static int
1520smb_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
1559out:
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
1575static char *
1576smb_get_status(void)
1577{
1578	return (smf_get_state(SMBD_DEFAULT_INSTANCE_FMRI));
1579}
1580
1581/*
1582 * This protocol plugin require resource names
1583 */
1584static uint64_t
1585smb_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 */
1596static int
1597smb_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 */
1678static int
1679smb_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 */
1709static char *
1710fix_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 */
1742static int
1743smb_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
1945static void
1946smb_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	}
1997err:
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
2012static char *
2013smb_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*/
2081int
2082smb_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
2117static int
2118smb_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 */
2215static void
2216smb_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 */
2256static char *
2257smb_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 */
2279static sa_group_t
2280smb_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 */
2305static int
2306cmd_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*/
2353static int
2354disposition_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*/
2370static int
2371protocol_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 */
2395static int
2396smb_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
2446static boolean_t
2447smb_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
2472static boolean_t
2473smb_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