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