xref: /titanic_41/usr/src/cmd/dfs.cmds/sharemgr/commands.c (revision 33f5ff17089e3a43e6e730bf80384c233123dbd9)
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 2010 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  * Copyright 2012 Milan Jurik. All rights reserved.
26  */
27 
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <fcntl.h>
31 #include <stdlib.h>
32 #include <stdio.h>
33 #include <string.h>
34 #include <ctype.h>
35 #include <unistd.h>
36 #include <getopt.h>
37 #include <utmpx.h>
38 #include <pwd.h>
39 #include <auth_attr.h>
40 #include <secdb.h>
41 #include <sys/param.h>
42 #include <sys/stat.h>
43 #include <errno.h>
44 
45 #include <libshare.h>
46 #include "sharemgr.h"
47 #include <libscf.h>
48 #include <libxml/tree.h>
49 #include <libintl.h>
50 #include <assert.h>
51 #include <iconv.h>
52 #include <langinfo.h>
53 #include <dirent.h>
54 
55 static char *sa_get_usage(sa_usage_t);
56 
57 /*
58  * Implementation of the common sub-commands supported by sharemgr.
59  * A number of helper functions are also included.
60  */
61 
62 /*
63  * has_protocol(group, proto)
64  *	If the group has an optionset with the specified protocol,
65  *	return true (1) otherwise false (0).
66  */
67 static int
has_protocol(sa_group_t group,char * protocol)68 has_protocol(sa_group_t group, char *protocol)
69 {
70 	sa_optionset_t optionset;
71 	int result = 0;
72 
73 	optionset = sa_get_optionset(group, protocol);
74 	if (optionset != NULL) {
75 		result++;
76 	}
77 	return (result);
78 }
79 
80 /*
81  * validresource(name)
82  *
83  * Check that name only has valid characters in it. The current valid
84  * set are the printable characters but not including:
85  *	" / \ [ ] : | < > + ; , ? * = \t
86  * Note that space is included and there is a maximum length.
87  */
88 static int
validresource(const char * name)89 validresource(const char *name)
90 {
91 	const char *cp;
92 	size_t len;
93 
94 	if (name == NULL)
95 		return (B_FALSE);
96 
97 	len = strlen(name);
98 	if (len == 0 || len > SA_MAX_RESOURCE_NAME)
99 		return (B_FALSE);
100 
101 	if (strpbrk(name, "\"/\\[]:|<>+;,?*=\t") != NULL) {
102 		return (B_FALSE);
103 	}
104 
105 	for (cp = name; *cp != '\0'; cp++)
106 		if (iscntrl(*cp))
107 			return (B_FALSE);
108 
109 	return (B_TRUE);
110 }
111 
112 /*
113  * conv_to_utf8(input)
114  *
115  * Convert the input string to utf8 from the current locale.  If the
116  * conversion fails, use the current locale, it is likely close
117  * enough. For example, the "C" locale is a subset of utf-8. The
118  * return value may be a new string or the original input string.
119  */
120 
121 static char *
conv_to_utf8(char * input)122 conv_to_utf8(char *input)
123 {
124 	iconv_t cd;
125 	char *inval = input;
126 	char *output = input;
127 	char *outleft;
128 	char *curlocale;
129 	size_t bytesleft;
130 	size_t size;
131 	size_t osize;
132 	static int warned = 0;
133 
134 	curlocale = nl_langinfo(CODESET);
135 	if (curlocale == NULL)
136 		curlocale = "C";
137 	cd = iconv_open("UTF-8", curlocale);
138 	if (cd != NULL && cd != (iconv_t)-1) {
139 		size = strlen(input);
140 		/* Assume worst case of characters expanding to 4 bytes. */
141 		bytesleft = size * 4;
142 		output = calloc(bytesleft, 1);
143 		if (output != NULL) {
144 			outleft = output;
145 			/* inval can be modified on return */
146 			osize = iconv(cd, (const char **)&inval, &size,
147 			    &outleft, &bytesleft);
148 			if (osize == (size_t)-1 || size != 0) {
149 				free(output);
150 				output = input;
151 			}
152 		} else {
153 			/* Need to return something. */
154 			output = input;
155 		}
156 		(void) iconv_close(cd);
157 	} else {
158 		if (!warned)
159 			(void) fprintf(stderr,
160 			    gettext("Cannot convert to UTF-8 from %s\n"),
161 			    curlocale ? curlocale : gettext("unknown"));
162 		warned = 1;
163 	}
164 	return (output);
165 }
166 
167 /*
168  * conv_from(input)
169  *
170  * Convert the input string from utf8 to current locale.  If the
171  * conversion isn't supported, just use as is. The return value may be
172  * a new string or the original input string.
173  */
174 
175 static char *
conv_from_utf8(char * input)176 conv_from_utf8(char *input)
177 {
178 	iconv_t cd;
179 	char *output = input;
180 	char *inval = input;
181 	char *outleft;
182 	char *curlocale;
183 	size_t bytesleft;
184 	size_t size;
185 	size_t osize;
186 	static int warned = 0;
187 
188 	curlocale = nl_langinfo(CODESET);
189 	if (curlocale == NULL)
190 		curlocale = "C";
191 	cd = iconv_open(curlocale, "UTF-8");
192 	if (cd != NULL && cd != (iconv_t)-1) {
193 		size = strlen(input);
194 		/* Assume worst case of characters expanding to 4 bytes. */
195 		bytesleft = size * 4;
196 		output = calloc(bytesleft, 1);
197 		if (output != NULL) {
198 			outleft = output;
199 			osize = iconv(cd, (const char **)&inval, &size,
200 			    &outleft, &bytesleft);
201 			if (osize == (size_t)-1 || size != 0)
202 				output = input;
203 		} else {
204 			/* Need to return something. */
205 			output = input;
206 		}
207 		(void) iconv_close(cd);
208 	} else {
209 		if (!warned)
210 			(void) fprintf(stderr,
211 			    gettext("Cannot convert to %s from UTF-8\n"),
212 			    curlocale ? curlocale : gettext("unknown"));
213 		warned = 1;
214 	}
215 	return (output);
216 }
217 
218 /*
219  * print_rsrc_desc(resource, sharedesc)
220  *
221  * Print the resource description string after converting from UTF8 to
222  * the current locale. If sharedesc is not NULL and there is no
223  * description on the resource, use sharedesc. sharedesc will already
224  * be converted to UTF8.
225  */
226 
227 static void
print_rsrc_desc(sa_resource_t resource,char * sharedesc)228 print_rsrc_desc(sa_resource_t resource, char *sharedesc)
229 {
230 	char *description;
231 	char *desc;
232 
233 	if (resource == NULL)
234 		return;
235 
236 	description = sa_get_resource_description(resource);
237 	if (description != NULL) {
238 		desc = conv_from_utf8(description);
239 		if (desc != description) {
240 			sa_free_share_description(description);
241 			description = desc;
242 		}
243 	} else if (sharedesc != NULL) {
244 		description = strdup(sharedesc);
245 	}
246 	if (description != NULL) {
247 		(void) printf("\t\"%s\"", description);
248 		sa_free_share_description(description);
249 	}
250 }
251 
252 /*
253  * set_resource_desc(share, description)
254  *
255  * Set the share description value after converting the description
256  * string to UTF8 from the current locale.
257  */
258 
259 static int
set_resource_desc(sa_share_t share,char * description)260 set_resource_desc(sa_share_t share, char *description)
261 {
262 	char *desc;
263 	int ret;
264 
265 	desc = conv_to_utf8(description);
266 	ret = sa_set_resource_description(share, desc);
267 	if (description != desc)
268 		sa_free_share_description(desc);
269 	return (ret);
270 }
271 
272 /*
273  * set_share_desc(share, description)
274  *
275  * Set the resource description value after converting the description
276  * string to UTF8 from the current locale.
277  */
278 
279 static int
set_share_desc(sa_share_t share,char * description)280 set_share_desc(sa_share_t share, char *description)
281 {
282 	char *desc;
283 	int ret;
284 
285 	desc = conv_to_utf8(description);
286 	ret = sa_set_share_description(share, desc);
287 	if (description != desc)
288 		sa_free_share_description(desc);
289 	return (ret);
290 }
291 
292 /*
293  * add_list(list, item, data, proto)
294  *	Adds a new list member that points holds item in the list.
295  *	If list is NULL, it starts a new list.  The function returns
296  *	the first member of the list.
297  */
298 struct list *
add_list(struct list * listp,void * item,void * data,char * proto)299 add_list(struct list *listp, void *item, void *data, char *proto)
300 {
301 	struct list *new, *tmp;
302 
303 	new = malloc(sizeof (struct list));
304 	if (new != NULL) {
305 		new->next = NULL;
306 		new->item = item;
307 		new->itemdata = data;
308 		new->proto = proto;
309 	} else {
310 		return (listp);
311 	}
312 
313 	if (listp == NULL)
314 		return (new);
315 
316 	for (tmp = listp; tmp->next != NULL; tmp = tmp->next) {
317 		/* get to end of list */
318 	}
319 	tmp->next = new;
320 	return (listp);
321 }
322 
323 /*
324  * free_list(list)
325  *	Given a list, free all the members of the list;
326  */
327 static void
free_list(struct list * listp)328 free_list(struct list *listp)
329 {
330 	struct list *tmp;
331 	while (listp != NULL) {
332 		tmp = listp;
333 		listp = listp->next;
334 		free(tmp);
335 	}
336 }
337 
338 /*
339  * check_authorization(instname, which)
340  *
341  * Checks to see if the specific type of authorization in which is
342  * enabled for the user in this SMF service instance.
343  */
344 
345 static int
check_authorization(char * instname,int which)346 check_authorization(char *instname, int which)
347 {
348 	scf_handle_t *handle = NULL;
349 	scf_simple_prop_t *prop = NULL;
350 	char svcstring[SA_MAX_NAME_LEN + sizeof (SA_SVC_FMRI_BASE) + 1];
351 	char *authstr = NULL;
352 	ssize_t numauths;
353 	int ret = B_TRUE;
354 	uid_t uid;
355 	struct passwd *pw = NULL;
356 
357 	uid = getuid();
358 	pw = getpwuid(uid);
359 	if (pw == NULL) {
360 		ret = B_FALSE;
361 	} else {
362 		/*
363 		 * Since names are restricted to SA_MAX_NAME_LEN won't
364 		 * overflow.
365 		 */
366 		(void) snprintf(svcstring, sizeof (svcstring), "%s:%s",
367 		    SA_SVC_FMRI_BASE, instname);
368 		handle = scf_handle_create(SCF_VERSION);
369 		if (handle != NULL) {
370 			if (scf_handle_bind(handle) == 0) {
371 				switch (which) {
372 				case SVC_SET:
373 					prop = scf_simple_prop_get(handle,
374 					    svcstring, "general",
375 					    SVC_AUTH_VALUE);
376 					break;
377 				case SVC_ACTION:
378 					prop = scf_simple_prop_get(handle,
379 					    svcstring, "general",
380 					    SVC_AUTH_ACTION);
381 					break;
382 				}
383 			}
384 		}
385 	}
386 	/* make sure we have an authorization string property */
387 	if (prop != NULL) {
388 		int i;
389 		numauths = scf_simple_prop_numvalues(prop);
390 		for (ret = 0, i = 0; i < numauths; i++) {
391 			authstr = scf_simple_prop_next_astring(prop);
392 			if (authstr != NULL) {
393 				/* check if this user has one of the strings */
394 				if (chkauthattr(authstr, pw->pw_name)) {
395 					ret = 1;
396 					break;
397 				}
398 			}
399 		}
400 		endauthattr();
401 		scf_simple_prop_free(prop);
402 	} else {
403 		/* no authorization string defined */
404 		ret = 0;
405 	}
406 	if (handle != NULL)
407 		scf_handle_destroy(handle);
408 	return (ret);
409 }
410 
411 /*
412  * check_authorizations(instname, flags)
413  *
414  * check all the needed authorizations for the user in this service
415  * instance. Return value of 1(true) or 0(false) indicates whether
416  * there are authorizations for the user or not.
417  */
418 
419 static int
check_authorizations(char * instname,int flags)420 check_authorizations(char *instname, int flags)
421 {
422 	int ret1 = 0;
423 	int ret2 = 0;
424 	int ret;
425 
426 	if (flags & SVC_SET)
427 		ret1 = check_authorization(instname, SVC_SET);
428 	if (flags & SVC_ACTION)
429 		ret2 = check_authorization(instname, SVC_ACTION);
430 	switch (flags) {
431 	case SVC_ACTION:
432 		ret = ret2;
433 		break;
434 	case SVC_SET:
435 		ret = ret1;
436 		break;
437 	case SVC_ACTION|SVC_SET:
438 		ret = ret1 & ret2;
439 		break;
440 	default:
441 		/* if not flags set, we assume we don't need authorizations */
442 		ret = 1;
443 	}
444 	return (ret);
445 }
446 
447 /*
448  * notify_or_enable_share(share, protocol)
449  *
450  * Since some protocols don't want an "enable" when properties change,
451  * this function will use the protocol specific notify function
452  * first. If that fails, it will then attempt to use the
453  * sa_enable_share().  "protocol" is the protocol that was specified
454  * on the command line.
455  */
456 static void
notify_or_enable_share(sa_share_t share,char * protocol)457 notify_or_enable_share(sa_share_t share, char *protocol)
458 {
459 	sa_group_t group;
460 	sa_optionset_t opt;
461 	int ret = SA_OK;
462 	char *path;
463 	char *groupproto;
464 	sa_share_t parent = share;
465 
466 	/* If really a resource, get parent share */
467 	if (!sa_is_share(share)) {
468 		parent = sa_get_resource_parent((sa_resource_t)share);
469 	}
470 
471 	/*
472 	 * Now that we've got a share in "parent", make sure it has a path.
473 	 */
474 	path = sa_get_share_attr(parent, "path");
475 	if (path == NULL)
476 		return;
477 
478 	group = sa_get_parent_group(parent);
479 
480 	if (group == NULL) {
481 		sa_free_attr_string(path);
482 		return;
483 	}
484 	for (opt = sa_get_optionset(group, NULL);
485 	    opt != NULL;
486 	    opt = sa_get_next_optionset(opt)) {
487 		groupproto = sa_get_optionset_attr(opt, "type");
488 		if (groupproto == NULL ||
489 		    (protocol != NULL && strcmp(groupproto, protocol) != 0)) {
490 			if (groupproto != NULL)
491 				sa_free_attr_string(groupproto);
492 			continue;
493 		}
494 		if (sa_is_share(share)) {
495 			if ((ret = sa_proto_change_notify(share,
496 			    groupproto)) != SA_OK) {
497 				ret = sa_enable_share(share, groupproto);
498 				if (ret != SA_OK) {
499 					(void) printf(
500 					    gettext("Could not reenable"
501 					    " share %s: %s\n"),
502 					    path, sa_errorstr(ret));
503 				}
504 			}
505 		} else {
506 			/* Must be a resource */
507 			if ((ret = sa_proto_notify_resource(share,
508 			    groupproto)) != SA_OK) {
509 				ret = sa_enable_resource(share, groupproto);
510 				if (ret != SA_OK) {
511 					(void) printf(
512 					    gettext("Could not "
513 					    "reenable resource %s: "
514 					    "%s\n"), path,
515 					    sa_errorstr(ret));
516 				}
517 			}
518 		}
519 		sa_free_attr_string(groupproto);
520 	}
521 	sa_free_attr_string(path);
522 }
523 
524 /*
525  * enable_group(group, updateproto, notify, proto)
526  *
527  * enable all the shares in the specified group. This is a helper for
528  * enable_all_groups in order to simplify regular and subgroup (zfs)
529  * enabling. Group has already been checked for non-NULL. If notify
530  * is non-zero, attempt to use the notify interface rather than
531  * enable.
532  */
533 static void
enable_group(sa_group_t group,char * updateproto,int notify,char * proto)534 enable_group(sa_group_t group, char *updateproto, int notify, char *proto)
535 {
536 	sa_share_t share;
537 
538 	/* If the protocol isn't enabled for this group skip it */
539 	if (!has_protocol(group, proto))
540 		return;
541 
542 	for (share = sa_get_share(group, NULL);
543 	    share != NULL;
544 	    share = sa_get_next_share(share)) {
545 		if (updateproto != NULL)
546 			(void) sa_update_legacy(share, updateproto);
547 		if (notify)
548 			notify_or_enable_share(share, proto);
549 		else
550 			(void) sa_enable_share(share, proto);
551 	}
552 }
553 
554 /*
555  * isenabled(group)
556  *
557  * Returns B_TRUE if the group is enabled or B_FALSE if it isn't.
558  * Moved to separate function to reduce clutter in the code.
559  */
560 
561 static int
isenabled(sa_group_t group)562 isenabled(sa_group_t group)
563 {
564 	char *state;
565 	int ret = B_FALSE;
566 
567 	if (group != NULL) {
568 		state = sa_get_group_attr(group, "state");
569 		if (state != NULL) {
570 
571 			if (strcmp(state, "enabled") == 0)
572 				ret = B_TRUE;
573 			sa_free_attr_string(state);
574 		}
575 	}
576 	return (ret);
577 }
578 
579 /*
580  * enable_all_groups(list, setstate, online, updateproto)
581  *
582  * Given a list of groups, enable each one found.  If updateproto is
583  * not NULL, then update all the shares for the protocol that was
584  * passed in. If enable is non-zero, tell enable_group to try the
585  * notify interface since this is a property change.
586  */
587 static int
enable_all_groups(sa_handle_t handle,struct list * work,int setstate,int online,char * updateproto,int enable)588 enable_all_groups(sa_handle_t handle, struct list *work, int setstate,
589     int online, char *updateproto, int enable)
590 {
591 	int ret;
592 	char instance[SA_MAX_NAME_LEN + sizeof (SA_SVC_FMRI_BASE) + 1];
593 	char *state;
594 	char *name;
595 	char *zfs = NULL;
596 	sa_group_t group;
597 	sa_group_t subgroup;
598 
599 	for (ret = SA_OK; work != NULL;	work = work->next) {
600 		group = (sa_group_t)work->item;
601 
602 		/*
603 		 * If setstate == TRUE, then make sure to set
604 		 * enabled. This needs to be done here in order for
605 		 * the isenabled check to succeed on a newly enabled
606 		 * group.
607 		 */
608 		if (setstate == B_TRUE) {
609 			ret = sa_set_group_attr(group, "state",	"enabled");
610 			if (ret != SA_OK)
611 				break;
612 		}
613 
614 		/*
615 		 * Check to see if group is enabled. If it isn't, skip
616 		 * the rest.  We don't want shares starting if the
617 		 * group is disabled. The properties may have been
618 		 * updated, but there won't be a change until the
619 		 * group is enabled.
620 		 */
621 		if (!isenabled(group))
622 			continue;
623 
624 		/* if itemdata != NULL then a single share */
625 		if (work->itemdata != NULL) {
626 			if (enable) {
627 				if (work->itemdata != NULL)
628 					notify_or_enable_share(work->itemdata,
629 					    updateproto);
630 				else
631 					ret = SA_CONFIG_ERR;
632 			} else {
633 				if (sa_is_share(work->itemdata)) {
634 					ret = sa_enable_share(
635 					    (sa_share_t)work->itemdata,
636 					    updateproto);
637 				} else {
638 					ret = sa_enable_resource(
639 					    (sa_resource_t)work->itemdata,
640 					    updateproto);
641 				}
642 			}
643 		}
644 		if (ret != SA_OK)
645 			break;
646 
647 		/* if itemdata == NULL then the whole group */
648 		if (work->itemdata == NULL) {
649 			zfs = sa_get_group_attr(group, "zfs");
650 			/*
651 			 * If the share is managed by ZFS, don't
652 			 * update any of the protocols since ZFS is
653 			 * handling this.  Updateproto will contain
654 			 * the name of the protocol that we want to
655 			 * update legacy files for.
656 			 */
657 			enable_group(group, zfs == NULL ? updateproto : NULL,
658 			    enable, work->proto);
659 			if (zfs != NULL)
660 				sa_free_attr_string(zfs);
661 
662 			for (subgroup = sa_get_sub_group(group);
663 			    subgroup != NULL;
664 			    subgroup = sa_get_next_group(subgroup)) {
665 				/* never update legacy for ZFS subgroups */
666 				enable_group(subgroup, NULL, enable,
667 				    work->proto);
668 			}
669 		}
670 		if (online) {
671 			zfs = sa_get_group_attr(group, "zfs");
672 			name = sa_get_group_attr(group, "name");
673 			if (name != NULL) {
674 				if (zfs == NULL) {
675 					(void) snprintf(instance,
676 					    sizeof (instance), "%s:%s",
677 					    SA_SVC_FMRI_BASE, name);
678 					state = smf_get_state(instance);
679 					if (state == NULL ||
680 					    strcmp(state, "online") != 0) {
681 						(void) smf_enable_instance(
682 						    instance, 0);
683 						free(state);
684 					}
685 				} else {
686 					sa_free_attr_string(zfs);
687 					zfs = NULL;
688 				}
689 				if (name != NULL)
690 					sa_free_attr_string(name);
691 			}
692 		}
693 	}
694 	if (ret == SA_OK) {
695 		ret = sa_update_config(handle);
696 	}
697 	return (ret);
698 }
699 
700 /*
701  * chk_opt(optlistp, security, proto)
702  *
703  * Do a sanity check on the optlist provided for the protocol.  This
704  * is a syntax check and verification that the property is either a
705  * general or specific to a names optionset.
706  */
707 
708 static int
chk_opt(struct options * optlistp,int security,char * proto)709 chk_opt(struct options *optlistp, int security, char *proto)
710 {
711 	struct options *optlist;
712 	char *sep = "";
713 	int notfirst = 0;
714 	int ret;
715 
716 	for (optlist = optlistp; optlist != NULL; optlist = optlist->next) {
717 		char *optname;
718 
719 		optname = optlist->optname;
720 		ret = OPT_ADD_OK;
721 		/* extract property/value pair */
722 		if (sa_is_security(optname, proto)) {
723 			if (!security)
724 				ret = OPT_ADD_SECURITY;
725 		} else {
726 			if (security)
727 				ret = OPT_ADD_PROPERTY;
728 		}
729 		if (ret != OPT_ADD_OK) {
730 			if (notfirst == 0)
731 				(void) printf(
732 				    gettext("Property syntax error: "));
733 			switch (ret) {
734 			case OPT_ADD_SYNTAX:
735 				(void) printf(gettext("%ssyntax error: %s"),
736 				    sep, optname);
737 				sep = ", ";
738 				break;
739 			case OPT_ADD_SECURITY:
740 				(void) printf(gettext("%s%s requires -S"),
741 				    optname, sep);
742 				sep = ", ";
743 				break;
744 			case OPT_ADD_PROPERTY:
745 				(void) printf(
746 				    gettext("%s%s not supported with -S"),
747 				    optname, sep);
748 				sep = ", ";
749 				break;
750 			}
751 			notfirst++;
752 		}
753 	}
754 	if (notfirst) {
755 		(void) printf("\n");
756 		ret = SA_SYNTAX_ERR;
757 	}
758 	return (ret);
759 }
760 
761 /*
762  * free_opt(optlist)
763  *	Free the specified option list.
764  */
765 static void
free_opt(struct options * optlist)766 free_opt(struct options *optlist)
767 {
768 	struct options *nextopt;
769 	while (optlist != NULL) {
770 		nextopt = optlist->next;
771 		free(optlist);
772 		optlist = nextopt;
773 	}
774 }
775 
776 /*
777  * check property list for valid properties
778  * A null value is a remove which is always valid.
779  */
780 static int
valid_options(sa_handle_t handle,struct options * optlist,char * proto,void * object,char * sec)781 valid_options(sa_handle_t handle, struct options *optlist, char *proto,
782     void *object, char *sec)
783 {
784 	int ret = SA_OK;
785 	struct options *cur;
786 	sa_property_t prop;
787 	sa_optionset_t parent = NULL;
788 
789 	if (object != NULL) {
790 		if (sec == NULL)
791 			parent = sa_get_optionset(object, proto);
792 		else
793 			parent = sa_get_security(object, sec, proto);
794 	}
795 
796 	for (cur = optlist; cur != NULL; cur = cur->next) {
797 		if (cur->optvalue == NULL)
798 			continue;
799 		prop = sa_create_property(cur->optname, cur->optvalue);
800 		if (prop == NULL)
801 			ret = SA_NO_MEMORY;
802 		if (ret != SA_OK ||
803 		    (ret = sa_valid_property(handle, parent, proto, prop)) !=
804 		    SA_OK) {
805 			(void) printf(
806 			    gettext("Could not add property %s: %s\n"),
807 			    cur->optname, sa_errorstr(ret));
808 		}
809 		(void) sa_remove_property(prop);
810 	}
811 	return (ret);
812 }
813 
814 /*
815  * add_optionset(group, optlist, protocol, *err)
816  *	Add the options in optlist to an optionset and then add the optionset
817  *	to the group.
818  *
819  *	The return value indicates if there was a "change" while errors are
820  *	returned via the *err parameters.
821  */
822 static int
add_optionset(sa_group_t group,struct options * optlist,char * proto,int * err)823 add_optionset(sa_group_t group, struct options *optlist, char *proto, int *err)
824 {
825 	sa_optionset_t optionset;
826 	int ret = SA_OK;
827 	int result = B_FALSE;
828 	sa_handle_t handle;
829 
830 	optionset = sa_get_optionset(group, proto);
831 	if (optionset == NULL) {
832 		optionset = sa_create_optionset(group, proto);
833 		if (optionset == NULL)
834 			ret = SA_NO_MEMORY;
835 		result = B_TRUE; /* adding a protocol is a change */
836 	}
837 	if (optionset == NULL) {
838 		ret = SA_NO_MEMORY;
839 		goto out;
840 	}
841 	handle = sa_find_group_handle(group);
842 	if (handle == NULL) {
843 		ret = SA_CONFIG_ERR;
844 		goto out;
845 	}
846 	while (optlist != NULL) {
847 		sa_property_t prop;
848 		prop = sa_get_property(optionset, optlist->optname);
849 		if (prop == NULL) {
850 			/*
851 			 * add the property, but only if it is
852 			 * a non-NULL or non-zero length value
853 			 */
854 			if (optlist->optvalue != NULL) {
855 				prop = sa_create_property(optlist->optname,
856 				    optlist->optvalue);
857 				if (prop != NULL) {
858 					ret = sa_valid_property(handle,
859 					    optionset, proto, prop);
860 					if (ret != SA_OK) {
861 						(void) sa_remove_property(prop);
862 						(void) printf(gettext("Could "
863 						    "not add property "
864 						    "%s: %s\n"),
865 						    optlist->optname,
866 						    sa_errorstr(ret));
867 					}
868 				}
869 				if (ret == SA_OK) {
870 					ret = sa_add_property(optionset, prop);
871 					if (ret != SA_OK) {
872 						(void) printf(gettext(
873 						    "Could not add property "
874 						    "%s: %s\n"),
875 						    optlist->optname,
876 						    sa_errorstr(ret));
877 					} else {
878 						/* there was a change */
879 						result = B_TRUE;
880 					}
881 				}
882 			}
883 		} else {
884 			ret = sa_update_property(prop, optlist->optvalue);
885 			/* should check to see if value changed */
886 			if (ret != SA_OK) {
887 				(void) printf(gettext("Could not update "
888 				    "property %s: %s\n"), optlist->optname,
889 				    sa_errorstr(ret));
890 			} else {
891 				result = B_TRUE;
892 			}
893 		}
894 		optlist = optlist->next;
895 	}
896 	ret = sa_commit_properties(optionset, 0);
897 
898 out:
899 	if (err != NULL)
900 		*err = ret;
901 	return (result);
902 }
903 
904 /*
905  * resource_compliant(group)
906  *
907  * Go through all the shares in the group. Assume compliant, but if
908  * any share doesn't have at least one resource name, it isn't
909  * compliant.
910  */
911 static int
resource_compliant(sa_group_t group)912 resource_compliant(sa_group_t group)
913 {
914 	sa_share_t share;
915 
916 	for (share = sa_get_share(group, NULL); share != NULL;
917 	    share = sa_get_next_share(share)) {
918 		if (sa_get_share_resource(share, NULL) == NULL) {
919 			return (B_FALSE);
920 		}
921 	}
922 	return (B_TRUE);
923 }
924 
925 /*
926  * fix_path(path)
927  *
928  * change all illegal characters to something else.  For now, all get
929  * converted to '_' and the leading '/' is stripped off. This is used
930  * to construct an resource name (SMB share name) that is valid.
931  * Caller must pass a valid path.
932  */
933 static void
fix_path(char * path)934 fix_path(char *path)
935 {
936 	char *cp;
937 	size_t len;
938 
939 	assert(path != NULL);
940 
941 	/* make sure we are appropriate length */
942 	cp = path + 1; /* skip leading slash */
943 	while (cp != NULL && strlen(cp) > SA_MAX_RESOURCE_NAME) {
944 		cp = strchr(cp, '/');
945 		if (cp != NULL)
946 			cp++;
947 	}
948 	/* two cases - cp == NULL and cp is substring of path */
949 	if (cp == NULL) {
950 		/* just take last SA_MAX_RESOURCE_NAME chars */
951 		len = 1 + strlen(path) - SA_MAX_RESOURCE_NAME;
952 		(void) memmove(path, path + len, SA_MAX_RESOURCE_NAME);
953 		path[SA_MAX_RESOURCE_NAME] = '\0';
954 	} else {
955 		len = strlen(cp) + 1;
956 		(void) memmove(path, cp, len);
957 	}
958 
959 	/*
960 	 * Don't want any of the characters that are not allowed
961 	 * in and SMB share name. Replace them with '_'.
962 	 */
963 	while (*path) {
964 		switch (*path) {
965 		case '/':
966 		case '"':
967 		case '\\':
968 		case '[':
969 		case ']':
970 		case ':':
971 		case '|':
972 		case '<':
973 		case '>':
974 		case '+':
975 		case ';':
976 		case ',':
977 		case '?':
978 		case '*':
979 		case '=':
980 		case '\t':
981 			*path = '_';
982 			break;
983 		}
984 		path++;
985 	}
986 }
987 
988 /*
989  * name_adjust(path, count)
990  *
991  * Add a ~<count> in place of last few characters. The total number of
992  * characters is dependent on count.
993  */
994 #define	MAX_MANGLE_NUMBER	10000
995 
996 static int
name_adjust(char * path,int count)997 name_adjust(char *path, int count)
998 {
999 	size_t len;
1000 
1001 	len = strlen(path) - 2;
1002 	if (count > 10)
1003 		len--;
1004 	if (count > 100)
1005 		len--;
1006 	if (count > 1000)
1007 		len--;
1008 	if (len > 0)
1009 		(void) sprintf(path + len, "~%d", count);
1010 	else
1011 		return (SA_BAD_VALUE);
1012 
1013 	return (SA_OK);
1014 }
1015 
1016 /*
1017  * make_resources(group)
1018  *
1019  * Go through all the shares in the group and make them have resource
1020  * names.
1021  */
1022 static void
make_resources(sa_group_t group)1023 make_resources(sa_group_t group)
1024 {
1025 	sa_share_t share;
1026 	int count;
1027 	int err = SA_OK;
1028 
1029 	for (share = sa_get_share(group, NULL); share != NULL;
1030 	    share = sa_get_next_share(share)) {
1031 		/* Skip those with resources */
1032 		if (sa_get_share_resource(share, NULL) == NULL) {
1033 			char *path;
1034 			path = sa_get_share_attr(share, "path");
1035 			if (path == NULL)
1036 				continue;
1037 			fix_path(path);
1038 			count = 0;	/* reset for next resource */
1039 			while (sa_add_resource(share, path,
1040 			    SA_SHARE_PERMANENT, &err) == NULL &&
1041 			    err == SA_DUPLICATE_NAME) {
1042 				int ret;
1043 				ret = name_adjust(path, count);
1044 				count++;
1045 				if (ret != SA_OK ||
1046 				    count >= MAX_MANGLE_NUMBER) {
1047 					(void) printf(gettext(
1048 					    "Cannot create resource name for"
1049 					    " path: %s\n"), path);
1050 					break;
1051 				}
1052 			}
1053 			sa_free_attr_string(path);
1054 		}
1055 	}
1056 }
1057 
1058 /*
1059  * check_valid_group(group, protocol)
1060  *
1061  * Check to see that the group should have the protocol added (if
1062  * there is one specified).
1063  */
1064 
1065 static int
check_valid_group(sa_group_t group,char * groupname,char * protocol)1066 check_valid_group(sa_group_t group, char *groupname, char *protocol)
1067 {
1068 
1069 	if (protocol != NULL) {
1070 		if (has_protocol(group, protocol)) {
1071 			(void) printf(gettext(
1072 			    "Group \"%s\" already exists"
1073 			    " with protocol %s\n"), groupname,
1074 			    protocol);
1075 			return (SA_DUPLICATE_NAME);
1076 		} else if (strcmp(groupname, "default") == 0 &&
1077 		    strcmp(protocol, "nfs") != 0) {
1078 			(void) printf(gettext(
1079 			    "Group \"%s\" only allows protocol "
1080 			    "\"%s\"\n"), groupname, "nfs");
1081 			return (SA_INVALID_PROTOCOL);
1082 		}
1083 	} else {
1084 		/* must add new protocol */
1085 		(void) printf(gettext(
1086 		    "Group already exists and no protocol "
1087 		    "specified.\n"));
1088 		return (SA_DUPLICATE_NAME);
1089 	}
1090 	return (SA_OK);
1091 }
1092 
1093 /*
1094  * enforce_featureset(group, protocol, dryrun, force)
1095  *
1096  * Check the protocol featureset against the group and enforce any
1097  * rules that might be imposed.
1098  */
1099 
1100 static int
enforce_featureset(sa_group_t group,char * protocol,boolean_t dryrun,boolean_t force)1101 enforce_featureset(sa_group_t group, char *protocol, boolean_t dryrun,
1102     boolean_t force)
1103 {
1104 	uint64_t features;
1105 
1106 	if (protocol == NULL)
1107 		return (SA_OK);
1108 
1109 	/*
1110 	 * First check to see if specified protocol is one we want to
1111 	 * allow on a group. Only server protocols are allowed here.
1112 	 */
1113 	features = sa_proto_get_featureset(protocol);
1114 	if (!(features & SA_FEATURE_SERVER)) {
1115 		(void) printf(
1116 		    gettext("Protocol \"%s\" not supported.\n"), protocol);
1117 		return (SA_INVALID_PROTOCOL);
1118 	}
1119 
1120 	/*
1121 	 * Check to see if the new protocol is one that requires
1122 	 * resource names and make sure we are compliant before
1123 	 * proceeding.
1124 	 */
1125 	if ((features & SA_FEATURE_RESOURCE) &&
1126 	    !resource_compliant(group)) {
1127 		if (force && !dryrun) {
1128 			make_resources(group);
1129 		} else {
1130 			(void) printf(
1131 			    gettext("Protocol requires resource names to be "
1132 			    "set: %s\n"), protocol);
1133 			return (SA_RESOURCE_REQUIRED);
1134 		}
1135 	}
1136 	return (SA_OK);
1137 }
1138 
1139 /*
1140  * set_all_protocols(group)
1141  *
1142  * Get the list of all protocols and add all server protocols to the
1143  * group.
1144  */
1145 
1146 static int
set_all_protocols(sa_group_t group)1147 set_all_protocols(sa_group_t group)
1148 {
1149 	char **protolist;
1150 	int numprotos, i;
1151 	uint64_t features;
1152 	sa_optionset_t optionset;
1153 	int ret = SA_OK;
1154 
1155 	/*
1156 	 * Now make sure we really want to put this protocol on a
1157 	 * group. Only server protocols can go here.
1158 	 */
1159 	numprotos = sa_get_protocols(&protolist);
1160 	for (i = 0; i < numprotos; i++) {
1161 		features = sa_proto_get_featureset(protolist[i]);
1162 		if (features & SA_FEATURE_SERVER) {
1163 			optionset = sa_create_optionset(group, protolist[i]);
1164 			if (optionset == NULL) {
1165 				ret = SA_NO_MEMORY;
1166 				break;
1167 			}
1168 		}
1169 	}
1170 
1171 	if (protolist != NULL)
1172 		free(protolist);
1173 
1174 	return (ret);
1175 }
1176 
1177 /*
1178  * sa_create(flags, argc, argv)
1179  *	create a new group
1180  *	this may or may not have a protocol associated with it.
1181  *	No protocol means "all" protocols in this case.
1182  */
1183 static int
sa_create(sa_handle_t handle,int flags,int argc,char * argv[])1184 sa_create(sa_handle_t handle, int flags, int argc, char *argv[])
1185 {
1186 	char *groupname;
1187 
1188 	sa_group_t group;
1189 	boolean_t force = B_FALSE;
1190 	boolean_t verbose = B_FALSE;
1191 	boolean_t dryrun = B_FALSE;
1192 	int c;
1193 	char *protocol = NULL;
1194 	int ret = SA_OK;
1195 	struct options *optlist = NULL;
1196 	int err = SA_OK;
1197 	int auth;
1198 	boolean_t created = B_FALSE;
1199 
1200 	while ((c = getopt(argc, argv, "?fhvnP:p:")) != EOF) {
1201 		switch (c) {
1202 		case 'f':
1203 			force = B_TRUE;
1204 			break;
1205 		case 'v':
1206 			verbose = B_TRUE;
1207 			break;
1208 		case 'n':
1209 			dryrun = B_TRUE;
1210 			break;
1211 		case 'P':
1212 			if (protocol != NULL) {
1213 				(void) printf(gettext("Specifying "
1214 				    "multiple protocols "
1215 				    "not supported: %s\n"), protocol);
1216 				return (SA_SYNTAX_ERR);
1217 			}
1218 			protocol = optarg;
1219 			if (sa_valid_protocol(protocol))
1220 				break;
1221 			(void) printf(gettext(
1222 			    "Invalid protocol specified: %s\n"), protocol);
1223 			return (SA_INVALID_PROTOCOL);
1224 		case 'p':
1225 			ret = add_opt(&optlist, optarg, 0);
1226 			switch (ret) {
1227 			case OPT_ADD_SYNTAX:
1228 				(void) printf(gettext(
1229 				    "Property syntax error for property: %s\n"),
1230 				    optarg);
1231 				return (SA_SYNTAX_ERR);
1232 			case OPT_ADD_SECURITY:
1233 				(void) printf(gettext(
1234 				    "Security properties need "
1235 				    "to be set with set-security: %s\n"),
1236 				    optarg);
1237 				return (SA_SYNTAX_ERR);
1238 			default:
1239 				break;
1240 			}
1241 			break;
1242 		case 'h':
1243 			/* optopt on valid arg isn't defined */
1244 			optopt = c;
1245 			/*FALLTHROUGH*/
1246 		case '?':
1247 		default:
1248 			/*
1249 			 * Since a bad option gets to here, sort it
1250 			 * out and return a syntax error return value
1251 			 * if necessary.
1252 			 */
1253 			switch (optopt) {
1254 			default:
1255 				err = SA_SYNTAX_ERR;
1256 				break;
1257 			case 'h':
1258 			case '?':
1259 				break;
1260 			}
1261 			(void) printf(gettext("usage: %s\n"),
1262 			    sa_get_usage(USAGE_CREATE));
1263 			return (err);
1264 		}
1265 	}
1266 
1267 	if (optind >= argc) {
1268 		(void) printf(gettext("usage: %s\n"),
1269 		    sa_get_usage(USAGE_CREATE));
1270 		(void) printf(gettext("\tgroup must be specified.\n"));
1271 		return (SA_BAD_PATH);
1272 	}
1273 
1274 	if ((optind + 1) < argc) {
1275 		(void) printf(gettext("usage: %s\n"),
1276 		    sa_get_usage(USAGE_CREATE));
1277 		(void) printf(gettext("\textraneous group(s) at end\n"));
1278 		return (SA_SYNTAX_ERR);
1279 	}
1280 
1281 	if (protocol == NULL && optlist != NULL) {
1282 		/* lookup default protocol */
1283 		(void) printf(gettext("usage: %s\n"),
1284 		    sa_get_usage(USAGE_CREATE));
1285 		(void) printf(gettext("\tprotocol must be specified "
1286 		    "with properties\n"));
1287 		return (SA_INVALID_PROTOCOL);
1288 	}
1289 
1290 	if (optlist != NULL)
1291 		ret = chk_opt(optlist, 0, protocol);
1292 	if (ret == OPT_ADD_SECURITY) {
1293 		(void) printf(gettext("Security properties not "
1294 		    "supported with create\n"));
1295 		return (SA_SYNTAX_ERR);
1296 	}
1297 
1298 	/*
1299 	 * If a group already exists, we can only add a new protocol
1300 	 * to it and not create a new one or add the same protocol
1301 	 * again.
1302 	 */
1303 
1304 	groupname = argv[optind];
1305 
1306 	auth = check_authorizations(groupname, flags);
1307 
1308 	group = sa_get_group(handle, groupname);
1309 	if (group != NULL) {
1310 		/* group exists so must be a protocol add */
1311 		ret = check_valid_group(group, groupname, protocol);
1312 	} else {
1313 		/*
1314 		 * is it a valid name? Must comply with SMF instance
1315 		 * name restrictions.
1316 		 */
1317 		if (!sa_valid_group_name(groupname)) {
1318 			ret = SA_INVALID_NAME;
1319 			(void) printf(gettext("Invalid group name: %s\n"),
1320 			    groupname);
1321 		}
1322 	}
1323 	if (ret == SA_OK) {
1324 		/* check protocol vs optlist */
1325 		if (optlist != NULL) {
1326 			/* check options, if any, for validity */
1327 			ret = valid_options(handle, optlist, protocol,
1328 			    group, NULL);
1329 		}
1330 	}
1331 	if (ret == SA_OK && !dryrun) {
1332 		if (group == NULL) {
1333 			group = sa_create_group(handle, (char *)groupname,
1334 			    &err);
1335 			created = B_TRUE;
1336 		}
1337 		if (group != NULL) {
1338 			sa_optionset_t optionset;
1339 
1340 			/*
1341 			 * Check group and protocol against featureset
1342 			 * requirements.
1343 			 */
1344 			ret = enforce_featureset(group, protocol,
1345 			    dryrun, force);
1346 			if (ret != SA_OK)
1347 				goto err;
1348 
1349 			/*
1350 			 * So far so good. Now add the required
1351 			 * optionset(s) to the group.
1352 			 */
1353 			if (optlist != NULL) {
1354 				(void) add_optionset(group, optlist, protocol,
1355 				    &ret);
1356 			} else if (protocol != NULL) {
1357 				optionset = sa_create_optionset(group,
1358 				    protocol);
1359 				if (optionset == NULL)
1360 					ret = SA_NO_MEMORY;
1361 			} else if (protocol == NULL) {
1362 				/* default group create so add all protocols */
1363 				ret = set_all_protocols(group);
1364 			}
1365 			/*
1366 			 * We have a group and legal additions
1367 			 */
1368 			if (ret == SA_OK) {
1369 				/*
1370 				 * Commit to configuration for protocols that
1371 				 * need to do block updates. For NFS, this
1372 				 * doesn't do anything but it will be run for
1373 				 * all protocols that implement the
1374 				 * appropriate plugin.
1375 				 */
1376 				ret = sa_update_config(handle);
1377 			} else {
1378 				if (group != NULL)
1379 					(void) sa_remove_group(group);
1380 			}
1381 		} else {
1382 			ret = err;
1383 			(void) printf(gettext("Could not create group: %s\n"),
1384 			    sa_errorstr(ret));
1385 		}
1386 	}
1387 	if (dryrun && ret == SA_OK && !auth && verbose) {
1388 		(void) printf(gettext("Command would fail: %s\n"),
1389 		    sa_errorstr(SA_NO_PERMISSION));
1390 		ret = SA_NO_PERMISSION;
1391 	}
1392 err:
1393 	if (ret != SA_OK && created)
1394 		ret = sa_remove_group(group);
1395 
1396 	free_opt(optlist);
1397 	return (ret);
1398 }
1399 
1400 /*
1401  * group_status(group)
1402  *
1403  * return the current status (enabled/disabled) of the group.
1404  */
1405 
1406 static char *
group_status(sa_group_t group)1407 group_status(sa_group_t group)
1408 {
1409 	char *state;
1410 	int enabled = 0;
1411 
1412 	state = sa_get_group_attr(group, "state");
1413 	if (state != NULL) {
1414 		if (strcmp(state, "enabled") == 0) {
1415 			enabled = 1;
1416 		}
1417 		sa_free_attr_string(state);
1418 	}
1419 	return (enabled ? "enabled" : "disabled");
1420 }
1421 
1422 /*
1423  * sa_delete(flags, argc, argv)
1424  *
1425  *	Delete a group.
1426  */
1427 
1428 static int
sa_delete(sa_handle_t handle,int flags,int argc,char * argv[])1429 sa_delete(sa_handle_t handle, int flags, int argc, char *argv[])
1430 {
1431 	char *groupname;
1432 	sa_group_t group;
1433 	sa_share_t share;
1434 	int verbose = 0;
1435 	int dryrun = 0;
1436 	int force = 0;
1437 	int c;
1438 	char *protocol = NULL;
1439 	char *sectype = NULL;
1440 	int ret = SA_OK;
1441 	int auth;
1442 
1443 	while ((c = getopt(argc, argv, "?hvnP:fS:")) != EOF) {
1444 		switch (c) {
1445 		case 'v':
1446 			verbose++;
1447 			break;
1448 		case 'n':
1449 			dryrun++;
1450 			break;
1451 		case 'P':
1452 			if (protocol != NULL) {
1453 				(void) printf(gettext("Specifying "
1454 				    "multiple protocols "
1455 				    "not supported: %s\n"), protocol);
1456 				return (SA_SYNTAX_ERR);
1457 			}
1458 			protocol = optarg;
1459 			if (!sa_valid_protocol(protocol)) {
1460 				(void) printf(gettext("Invalid protocol "
1461 				    "specified: %s\n"), protocol);
1462 				return (SA_INVALID_PROTOCOL);
1463 			}
1464 			break;
1465 		case 'S':
1466 			if (sectype != NULL) {
1467 				(void) printf(gettext("Specifying "
1468 				    "multiple property "
1469 				    "spaces not supported: %s\n"), sectype);
1470 				return (SA_SYNTAX_ERR);
1471 			}
1472 			sectype = optarg;
1473 			break;
1474 		case 'f':
1475 			force++;
1476 			break;
1477 		case 'h':
1478 			/* optopt on valid arg isn't defined */
1479 			optopt = c;
1480 			/*FALLTHROUGH*/
1481 		case '?':
1482 		default:
1483 			/*
1484 			 * Since a bad option gets to here, sort it
1485 			 * out and return a syntax error return value
1486 			 * if necessary.
1487 			 */
1488 			switch (optopt) {
1489 			default:
1490 				ret = SA_SYNTAX_ERR;
1491 				break;
1492 			case 'h':
1493 			case '?':
1494 				break;
1495 			}
1496 			(void) printf(gettext("usage: %s\n"),
1497 			    sa_get_usage(USAGE_DELETE));
1498 			return (ret);
1499 		}
1500 	}
1501 
1502 	if (optind >= argc) {
1503 		(void) printf(gettext("usage: %s\n"),
1504 		    sa_get_usage(USAGE_DELETE));
1505 		(void) printf(gettext("\tgroup must be specified.\n"));
1506 		return (SA_SYNTAX_ERR);
1507 	}
1508 
1509 	if ((optind + 1) < argc) {
1510 		(void) printf(gettext("usage: %s\n"),
1511 		    sa_get_usage(USAGE_DELETE));
1512 		(void) printf(gettext("\textraneous group(s) at end\n"));
1513 		return (SA_SYNTAX_ERR);
1514 	}
1515 
1516 	if (sectype != NULL && protocol == NULL) {
1517 		(void) printf(gettext("usage: %s\n"),
1518 		    sa_get_usage(USAGE_DELETE));
1519 		(void) printf(gettext("\tsecurity requires protocol to be "
1520 		    "specified.\n"));
1521 		return (SA_SYNTAX_ERR);
1522 	}
1523 
1524 	/*
1525 	 * Determine if the group already exists since it must in
1526 	 * order to be removed.
1527 	 *
1528 	 * We can delete when:
1529 	 *
1530 	 *	- group is empty
1531 	 *	- force flag is set
1532 	 *	- if protocol specified, only delete the protocol
1533 	 */
1534 
1535 	groupname = argv[optind];
1536 	group = sa_get_group(handle, groupname);
1537 	if (group == NULL) {
1538 		ret = SA_NO_SUCH_GROUP;
1539 		goto done;
1540 	}
1541 	auth = check_authorizations(groupname, flags);
1542 	if (protocol == NULL) {
1543 		share = sa_get_share(group, NULL);
1544 		if (share != NULL)
1545 			ret = SA_BUSY;
1546 		if (share == NULL || (share != NULL && force == 1)) {
1547 			ret = SA_OK;
1548 			if (!dryrun) {
1549 				while (share != NULL) {
1550 					sa_share_t next_share;
1551 					next_share = sa_get_next_share(share);
1552 					/*
1553 					 * need to do the disable of
1554 					 * each share, but don't
1555 					 * actually do anything on a
1556 					 * dryrun.
1557 					 */
1558 					ret = sa_disable_share(share, NULL);
1559 					ret = sa_remove_share(share);
1560 					share = next_share;
1561 				}
1562 				ret = sa_remove_group(group);
1563 			}
1564 		}
1565 		/* Commit to configuration if not a dryrun */
1566 		if (!dryrun && ret == SA_OK) {
1567 			ret = sa_update_config(handle);
1568 		}
1569 	} else {
1570 		/* a protocol delete */
1571 		sa_optionset_t optionset;
1572 		sa_security_t security;
1573 		if (sectype != NULL) {
1574 			/* only delete specified security */
1575 			security = sa_get_security(group, sectype, protocol);
1576 			if (security != NULL && !dryrun)
1577 				ret = sa_destroy_security(security);
1578 			else
1579 				ret = SA_INVALID_PROTOCOL;
1580 		} else {
1581 			optionset = sa_get_optionset(group, protocol);
1582 			if (optionset != NULL && !dryrun) {
1583 				/*
1584 				 * have an optionset with
1585 				 * protocol to delete
1586 				 */
1587 				ret = sa_destroy_optionset(optionset);
1588 				/*
1589 				 * Now find all security sets
1590 				 * for the protocol and remove
1591 				 * them. Don't remove other
1592 				 * protocols.
1593 				 */
1594 				for (security =
1595 				    sa_get_security(group, NULL, NULL);
1596 				    ret == SA_OK && security != NULL;
1597 				    security = sa_get_next_security(security)) {
1598 					char *secprot;
1599 					secprot = sa_get_security_attr(security,
1600 					    "type");
1601 					if (secprot != NULL &&
1602 					    strcmp(secprot, protocol) == 0)
1603 						ret = sa_destroy_security(
1604 						    security);
1605 					if (secprot != NULL)
1606 						sa_free_attr_string(secprot);
1607 				}
1608 			} else {
1609 				if (!dryrun)
1610 					ret = SA_INVALID_PROTOCOL;
1611 			}
1612 		}
1613 		/*
1614 		 * With the protocol items removed, make sure that all
1615 		 * the shares are updated in the legacy files, if
1616 		 * necessary.
1617 		 */
1618 		for (share = sa_get_share(group, NULL);
1619 		    share != NULL;
1620 		    share = sa_get_next_share(share)) {
1621 			(void) sa_delete_legacy(share, protocol);
1622 		}
1623 	}
1624 
1625 done:
1626 	if (ret != SA_OK) {
1627 		(void) printf(gettext("Could not delete group: %s\n"),
1628 		    sa_errorstr(ret));
1629 	} else if (dryrun && !auth && verbose) {
1630 		(void) printf(gettext("Command would fail: %s\n"),
1631 		    sa_errorstr(SA_NO_PERMISSION));
1632 	}
1633 	return (ret);
1634 }
1635 
1636 /*
1637  * strndupr(*buff, str, buffsize)
1638  *
1639  * used with small strings to duplicate and possibly increase the
1640  * buffer size of a string.
1641  */
1642 static char *
strndupr(char * buff,char * str,int * buffsize)1643 strndupr(char *buff, char *str, int *buffsize)
1644 {
1645 	int limit;
1646 	char *orig_buff = buff;
1647 
1648 	if (buff == NULL) {
1649 		buff = (char *)malloc(64);
1650 		if (buff == NULL)
1651 			return (NULL);
1652 		*buffsize = 64;
1653 		buff[0] = '\0';
1654 	}
1655 	limit = strlen(buff) + strlen(str) + 1;
1656 	if (limit > *buffsize) {
1657 		limit = *buffsize = *buffsize + ((limit / 64) + 64);
1658 		buff = realloc(buff, limit);
1659 	}
1660 	if (buff != NULL) {
1661 		(void) strcat(buff, str);
1662 	} else {
1663 		/* if it fails, fail it hard */
1664 		if (orig_buff != NULL)
1665 			free(orig_buff);
1666 	}
1667 	return (buff);
1668 }
1669 
1670 /*
1671  * group_proto(group)
1672  *
1673  * return a string of all the protocols (space separated) associated
1674  * with this group.
1675  */
1676 
1677 static char *
group_proto(sa_group_t group)1678 group_proto(sa_group_t group)
1679 {
1680 	sa_optionset_t optionset;
1681 	char *proto;
1682 	char *buff = NULL;
1683 	int buffsize = 0;
1684 	int addspace = 0;
1685 	/*
1686 	 * get the protocol list by finding the optionsets on this
1687 	 * group and extracting the type value. The initial call to
1688 	 * strndupr() initailizes buff.
1689 	 */
1690 	buff = strndupr(buff, "", &buffsize);
1691 	if (buff != NULL) {
1692 		for (optionset = sa_get_optionset(group, NULL);
1693 		    optionset != NULL && buff != NULL;
1694 		    optionset = sa_get_next_optionset(optionset)) {
1695 			/*
1696 			 * extract out the protocol type from this optionset
1697 			 * and append it to the buffer "buff". strndupr() will
1698 			 * reallocate space as necessay.
1699 			 */
1700 			proto = sa_get_optionset_attr(optionset, "type");
1701 			if (proto != NULL) {
1702 				if (addspace++)
1703 					buff = strndupr(buff, " ", &buffsize);
1704 				buff = strndupr(buff, proto, &buffsize);
1705 				sa_free_attr_string(proto);
1706 			}
1707 		}
1708 	}
1709 	return (buff);
1710 }
1711 
1712 /*
1713  * sa_list(flags, argc, argv)
1714  *
1715  * implements the "list" subcommand to list groups and optionally
1716  * their state and protocols.
1717  */
1718 
1719 static int
sa_list(sa_handle_t handle,int flags,int argc,char * argv[])1720 sa_list(sa_handle_t handle, int flags, int argc, char *argv[])
1721 {
1722 	sa_group_t group;
1723 	int verbose = 0;
1724 	int c;
1725 	char *protocol = NULL;
1726 	int ret = SA_OK;
1727 #ifdef lint
1728 	flags = flags;
1729 #endif
1730 
1731 	while ((c = getopt(argc, argv, "?hvP:")) != EOF) {
1732 		switch (c) {
1733 		case 'v':
1734 			verbose++;
1735 			break;
1736 		case 'P':
1737 			if (protocol != NULL) {
1738 				(void) printf(gettext(
1739 				    "Specifying multiple protocols "
1740 				    "not supported: %s\n"),
1741 				    protocol);
1742 				return (SA_SYNTAX_ERR);
1743 			}
1744 			protocol = optarg;
1745 			if (!sa_valid_protocol(protocol)) {
1746 				(void) printf(gettext(
1747 				    "Invalid protocol specified: %s\n"),
1748 				    protocol);
1749 				return (SA_INVALID_PROTOCOL);
1750 			}
1751 			break;
1752 		case 'h':
1753 			/* optopt on valid arg isn't defined */
1754 			optopt = c;
1755 			/*FALLTHROUGH*/
1756 		case '?':
1757 		default:
1758 			/*
1759 			 * Since a bad option gets to here, sort it
1760 			 * out and return a syntax error return value
1761 			 * if necessary.
1762 			 */
1763 			switch (optopt) {
1764 			default:
1765 				ret = SA_SYNTAX_ERR;
1766 				break;
1767 			case 'h':
1768 			case '?':
1769 				break;
1770 			}
1771 			(void) printf(gettext("usage: %s\n"),
1772 			    sa_get_usage(USAGE_LIST));
1773 				return (ret);
1774 		}
1775 	}
1776 
1777 	if (optind != argc) {
1778 		(void) printf(gettext("usage: %s\n"),
1779 		    sa_get_usage(USAGE_LIST));
1780 		return (SA_SYNTAX_ERR);
1781 	}
1782 
1783 	for (group = sa_get_group(handle, NULL);
1784 	    group != NULL;
1785 	    group = sa_get_next_group(group)) {
1786 		char *name;
1787 		char *proto;
1788 		if (protocol == NULL || has_protocol(group, protocol)) {
1789 			name = sa_get_group_attr(group, "name");
1790 			if (name != NULL && (verbose > 1 || name[0] != '#')) {
1791 				(void) printf("%s", (char *)name);
1792 				if (verbose) {
1793 					/*
1794 					 * Need the list of protocols
1795 					 * and current status once
1796 					 * available. We do want to
1797 					 * translate the
1798 					 * enabled/disabled text here.
1799 					 */
1800 					(void) printf("\t%s", isenabled(group) ?
1801 					    gettext("enabled") :
1802 					    gettext("disabled"));
1803 					proto = group_proto(group);
1804 					if (proto != NULL) {
1805 						(void) printf("\t%s",
1806 						    (char *)proto);
1807 						free(proto);
1808 					}
1809 				}
1810 				(void) printf("\n");
1811 			}
1812 			if (name != NULL)
1813 				sa_free_attr_string(name);
1814 		}
1815 	}
1816 	return (0);
1817 }
1818 
1819 /*
1820  * out_properties(optionset, proto, sec)
1821  *
1822  * Format the properties and encode the protocol and optional named
1823  * optionset into the string.
1824  *
1825  * format is protocol[:name]=(property-list)
1826  */
1827 
1828 static void
out_properties(sa_optionset_t optionset,char * proto,char * sec)1829 out_properties(sa_optionset_t optionset, char *proto, char *sec)
1830 {
1831 	char *type;
1832 	char *value;
1833 	int spacer;
1834 	sa_property_t prop;
1835 
1836 	if (sec == NULL)
1837 		(void) printf(" %s=(", proto ? proto : gettext("all"));
1838 	else
1839 		(void) printf(" %s:%s=(", proto ? proto : gettext("all"), sec);
1840 
1841 	for (spacer = 0, prop = sa_get_property(optionset, NULL);
1842 	    prop != NULL;
1843 	    prop = sa_get_next_property(prop)) {
1844 
1845 		/*
1846 		 * extract the property name/value and output with
1847 		 * appropriate spacing. I.e. no prefixed space the
1848 		 * first time through but a space on subsequent
1849 		 * properties.
1850 		 */
1851 		type = sa_get_property_attr(prop, "type");
1852 		value = sa_get_property_attr(prop, "value");
1853 		if (type != NULL) {
1854 			(void) printf("%s%s=", spacer ? " " : "",	type);
1855 			spacer = 1;
1856 			if (value != NULL)
1857 				(void) printf("\"%s\"", value);
1858 			else
1859 				(void) printf("\"\"");
1860 		}
1861 		if (type != NULL)
1862 			sa_free_attr_string(type);
1863 		if (value != NULL)
1864 			sa_free_attr_string(value);
1865 	}
1866 	(void) printf(")");
1867 }
1868 
1869 /*
1870  * show_properties(group, protocol, prefix)
1871  *
1872  * print the properties for a group. If protocol is NULL, do all
1873  * protocols otherwise only the specified protocol. All security
1874  * (named groups specific to the protocol) are included.
1875  *
1876  * The "prefix" is always applied. The caller knows whether it wants
1877  * some type of prefix string (white space) or not.  Once the prefix
1878  * has been output, it is reduced to the zero length string for the
1879  * remainder of the property output.
1880  */
1881 
1882 static void
show_properties(sa_group_t group,char * protocol,char * prefix)1883 show_properties(sa_group_t group, char *protocol, char *prefix)
1884 {
1885 	sa_optionset_t optionset;
1886 	sa_security_t security;
1887 	char *value;
1888 	char *secvalue;
1889 
1890 	if (protocol != NULL) {
1891 		optionset = sa_get_optionset(group, protocol);
1892 		if (optionset != NULL) {
1893 			(void) printf("%s", prefix);
1894 			prefix = "";
1895 			out_properties(optionset, protocol, NULL);
1896 		}
1897 		security = sa_get_security(group, protocol, NULL);
1898 		if (security != NULL) {
1899 			(void) printf("%s", prefix);
1900 			prefix = "";
1901 			out_properties(security, protocol, NULL);
1902 		}
1903 	} else {
1904 		for (optionset = sa_get_optionset(group, protocol);
1905 		    optionset != NULL;
1906 		    optionset = sa_get_next_optionset(optionset)) {
1907 
1908 			value = sa_get_optionset_attr(optionset, "type");
1909 			(void) printf("%s", prefix);
1910 			prefix = "";
1911 			out_properties(optionset, value, 0);
1912 			if (value != NULL)
1913 				sa_free_attr_string(value);
1914 		}
1915 		for (security = sa_get_security(group, NULL, protocol);
1916 		    security != NULL;
1917 		    security = sa_get_next_security(security)) {
1918 
1919 			value = sa_get_security_attr(security, "type");
1920 			secvalue = sa_get_security_attr(security, "sectype");
1921 			(void) printf("%s", prefix);
1922 			prefix = "";
1923 			out_properties(security, value, secvalue);
1924 			if (value != NULL)
1925 				sa_free_attr_string(value);
1926 			if (secvalue != NULL)
1927 				sa_free_attr_string(secvalue);
1928 		}
1929 	}
1930 }
1931 
1932 /*
1933  * get_resource(share)
1934  *
1935  * Get the first resource name, if any, and fix string to be in
1936  * current locale and have quotes if it has embedded spaces.  Return
1937  * an attr string that must be freed.
1938  */
1939 
1940 static char *
get_resource(sa_share_t share)1941 get_resource(sa_share_t share)
1942 {
1943 	sa_resource_t resource;
1944 	char *resstring = NULL;
1945 	char *retstring;
1946 
1947 	if ((resource = sa_get_share_resource(share, NULL)) != NULL) {
1948 		resstring = sa_get_resource_attr(resource, "name");
1949 		if (resstring != NULL) {
1950 			char *cp;
1951 			int len;
1952 
1953 			retstring = conv_from_utf8(resstring);
1954 			if (retstring != resstring) {
1955 				sa_free_attr_string(resstring);
1956 				resstring = retstring;
1957 			}
1958 			if (strpbrk(resstring, " ") != NULL) {
1959 				/* account for quotes */
1960 				len = strlen(resstring) + 3;
1961 				cp = calloc(len, sizeof (char));
1962 				if (cp != NULL) {
1963 					(void) snprintf(cp, len,
1964 					    "\"%s\"", resstring);
1965 					sa_free_attr_string(resstring);
1966 					resstring = cp;
1967 				} else {
1968 					sa_free_attr_string(resstring);
1969 					resstring = NULL;
1970 				}
1971 			}
1972 		}
1973 	}
1974 	return (resstring);
1975 }
1976 
1977 /*
1978  * has_resource_with_opt(share)
1979  *
1980  * Check to see if the share has any resource names with optionsets
1981  * set. Also indicate if multiple resource names since the syntax
1982  * would be about the same.
1983  */
1984 static int
has_resource_with_opt(sa_share_t share)1985 has_resource_with_opt(sa_share_t share)
1986 {
1987 	sa_resource_t resource;
1988 	int ret = B_FALSE;
1989 
1990 	for (resource = sa_get_share_resource(share, NULL);
1991 	    resource != NULL;
1992 	    resource = sa_get_next_resource(resource)) {
1993 
1994 		if (sa_get_optionset(resource, NULL) != NULL) {
1995 			ret = B_TRUE;
1996 			break;
1997 		}
1998 	}
1999 	return (ret);
2000 }
2001 
2002 /*
2003  * has_multiple_resource(share)
2004  *
2005  * Check to see if the share has multiple resource names since
2006  * the syntax would be about the same.
2007  */
2008 static boolean_t
has_multiple_resource(sa_share_t share)2009 has_multiple_resource(sa_share_t share)
2010 {
2011 	sa_resource_t resource;
2012 	int num;
2013 
2014 	for (num = 0, resource = sa_get_share_resource(share, NULL);
2015 	    resource != NULL;
2016 	    resource = sa_get_next_resource(resource)) {
2017 		num++;
2018 		if (num > 1)
2019 			return (B_TRUE);
2020 	}
2021 	return (B_FALSE);
2022 }
2023 
2024 /*
2025  * show_share(share, verbose, properties, proto, iszfs, sharepath)
2026  *
2027  * print out the share information. With the addition of resource as a
2028  * full object that can have multiple instances below the share, we
2029  * need to display that as well.
2030  */
2031 
2032 static void
show_share(sa_share_t share,int verbose,int properties,char * proto,int iszfs,char * sharepath)2033 show_share(sa_share_t share, int verbose, int properties, char *proto,
2034     int iszfs, char *sharepath)
2035 {
2036 	char *drive;
2037 	char *exclude;
2038 	sa_resource_t resource = NULL;
2039 	char *description;
2040 	char *rsrcname;
2041 	int rsrcwithopt;
2042 	boolean_t multiple;
2043 	char *type;
2044 
2045 	rsrcwithopt = has_resource_with_opt(share);
2046 
2047 	if (verbose || (properties && rsrcwithopt)) {
2048 		/* First, indicate if transient */
2049 		type = sa_get_share_attr(share, "type");
2050 		if (type != NULL && !iszfs && verbose &&
2051 		    strcmp(type, "transient") == 0)
2052 			(void) printf("\t* ");
2053 		else
2054 			(void) printf("\t  ");
2055 
2056 		if (type != NULL)
2057 			sa_free_attr_string(type);
2058 
2059 		/*
2060 		 * If we came in with verbose, we want to handle the case of
2061 		 * multiple resources as though they had properties set.
2062 		 */
2063 		multiple = has_multiple_resource(share);
2064 
2065 		/*
2066 		 * if there is a description on the share and there
2067 		 * are resources, treat as multiple resources in order
2068 		 * to get all descriptions displayed.
2069 		 */
2070 		description = sa_get_share_description(share);
2071 		resource = sa_get_share_resource(share, NULL);
2072 
2073 		if (description != NULL && resource != NULL)
2074 			multiple = B_TRUE;
2075 
2076 		/* Next, if not multiple follow old model */
2077 		if (!multiple && !rsrcwithopt) {
2078 			rsrcname = get_resource(share);
2079 			if (rsrcname != NULL && strlen(rsrcname) > 0) {
2080 				(void) printf("%s=%s", rsrcname, sharepath);
2081 			} else {
2082 				(void) printf("%s", sharepath);
2083 			}
2084 			if (rsrcname != NULL)
2085 				sa_free_attr_string(rsrcname);
2086 			/* Print the description string if there is one. */
2087 			print_rsrc_desc(resource, description);
2088 		} else {
2089 			/* Treat as simple and then resources come later */
2090 			(void) printf("%s", sharepath);
2091 		}
2092 		drive = sa_get_share_attr(share, "drive-letter");
2093 		if (drive != NULL) {
2094 			if (strlen(drive) > 0)
2095 				(void) printf(gettext("\tdrive-letter=\"%s:\""),
2096 				    drive);
2097 			sa_free_attr_string(drive);
2098 		}
2099 		if (properties)
2100 			show_properties(share, proto, "\t");
2101 		exclude = sa_get_share_attr(share, "exclude");
2102 		if (exclude != NULL) {
2103 			(void) printf(gettext("\tnot-shared-with=[%s]"),
2104 			    exclude);
2105 			sa_free_attr_string(exclude);
2106 		}
2107 
2108 		if (description != NULL) {
2109 			print_rsrc_desc((sa_resource_t)share, description);
2110 		}
2111 		/*
2112 		 * If there are resource names with options, show them
2113 		 * here, with one line per resource. Resource specific
2114 		 * options are at the end of the line followed by
2115 		 * description, if any.
2116 		 */
2117 		if (rsrcwithopt || multiple) {
2118 			for (resource = sa_get_share_resource(share, NULL);
2119 			    resource != NULL;
2120 			    resource = sa_get_next_resource(resource)) {
2121 				int has_space;
2122 				char *rsrc;
2123 
2124 				(void) printf("\n\t\t  ");
2125 				rsrcname = sa_get_resource_attr(resource,
2126 				    "name");
2127 				if (rsrcname == NULL)
2128 					continue;
2129 
2130 				rsrc = conv_from_utf8(rsrcname);
2131 				has_space = strpbrk(rsrc, " ") != NULL;
2132 
2133 				if (has_space)
2134 					(void) printf("\"%s\"=%s", rsrc,
2135 					    sharepath);
2136 				else
2137 					(void) printf("%s=%s", rsrc,
2138 					    sharepath);
2139 				if (rsrc != rsrcname)
2140 					sa_free_attr_string(rsrc);
2141 				sa_free_attr_string(rsrcname);
2142 				if (properties || rsrcwithopt)
2143 					show_properties(resource, proto, "\t");
2144 
2145 				/* Get description string if any */
2146 				print_rsrc_desc(resource, description);
2147 			}
2148 		}
2149 		if (description != NULL)
2150 			sa_free_share_description(description);
2151 	} else {
2152 		(void) printf("\t  %s", sharepath);
2153 		if (properties)
2154 			show_properties(share, proto, "\t");
2155 	}
2156 	(void) printf("\n");
2157 }
2158 
2159 /*
2160  * show_group(group, verbose, properties, proto, subgroup)
2161  *
2162  * helper function to show the contents of a group.
2163  */
2164 
2165 static void
show_group(sa_group_t group,int verbose,int properties,char * proto,char * subgroup)2166 show_group(sa_group_t group, int verbose, int properties, char *proto,
2167     char *subgroup)
2168 {
2169 	sa_share_t share;
2170 	char *groupname;
2171 	char *zfs = NULL;
2172 	int iszfs = 0;
2173 	char *sharepath;
2174 
2175 	groupname = sa_get_group_attr(group, "name");
2176 	if (groupname != NULL) {
2177 		if (proto != NULL && !has_protocol(group, proto)) {
2178 			sa_free_attr_string(groupname);
2179 			return;
2180 		}
2181 		/*
2182 		 * check to see if the group is managed by ZFS. If
2183 		 * there is an attribute, then it is. A non-NULL zfs
2184 		 * variable will trigger the different way to display
2185 		 * and will remove the transient property indicator
2186 		 * from the output.
2187 		 */
2188 		zfs = sa_get_group_attr(group, "zfs");
2189 		if (zfs != NULL) {
2190 			iszfs = 1;
2191 			sa_free_attr_string(zfs);
2192 		}
2193 		share = sa_get_share(group, NULL);
2194 		if (subgroup == NULL)
2195 			(void) printf("%s", groupname);
2196 		else
2197 			(void) printf("    %s/%s", subgroup, groupname);
2198 		if (properties)
2199 			show_properties(group, proto, "");
2200 		(void) printf("\n");
2201 		if (strcmp(groupname, "zfs") == 0) {
2202 			sa_group_t zgroup;
2203 
2204 			for (zgroup = sa_get_sub_group(group);
2205 			    zgroup != NULL;
2206 			    zgroup = sa_get_next_group(zgroup)) {
2207 				show_group(zgroup, verbose, properties, proto,
2208 				    "zfs");
2209 			}
2210 			sa_free_attr_string(groupname);
2211 			return;
2212 		}
2213 		/*
2214 		 * Have a group, so list the contents. Resource and
2215 		 * description are only listed if verbose is set.
2216 		 */
2217 		for (share = sa_get_share(group, NULL);
2218 		    share != NULL;
2219 		    share = sa_get_next_share(share)) {
2220 			sharepath = sa_get_share_attr(share, "path");
2221 			if (sharepath != NULL) {
2222 				show_share(share, verbose, properties, proto,
2223 				    iszfs, sharepath);
2224 				sa_free_attr_string(sharepath);
2225 			}
2226 		}
2227 	}
2228 	if (groupname != NULL) {
2229 		sa_free_attr_string(groupname);
2230 	}
2231 }
2232 
2233 /*
2234  * show_group_xml_init()
2235  *
2236  * Create an XML document that will be used to display config info via
2237  * XML format.
2238  */
2239 
2240 xmlDocPtr
show_group_xml_init()2241 show_group_xml_init()
2242 {
2243 	xmlDocPtr doc;
2244 	xmlNodePtr root;
2245 
2246 	doc = xmlNewDoc((xmlChar *)"1.0");
2247 	if (doc != NULL) {
2248 		root = xmlNewNode(NULL, (xmlChar *)"sharecfg");
2249 		if (root != NULL)
2250 			(void) xmlDocSetRootElement(doc, root);
2251 	}
2252 	return (doc);
2253 }
2254 
2255 /*
2256  * show_group_xml(doc, group)
2257  *
2258  * Copy the group info into the XML doc.
2259  */
2260 
2261 static void
show_group_xml(xmlDocPtr doc,sa_group_t group)2262 show_group_xml(xmlDocPtr doc, sa_group_t group)
2263 {
2264 	xmlNodePtr node;
2265 	xmlNodePtr root;
2266 
2267 	root = xmlDocGetRootElement(doc);
2268 	node = xmlCopyNode((xmlNodePtr)group, 1);
2269 	if (node != NULL && root != NULL) {
2270 		(void) xmlAddChild(root, node);
2271 		/*
2272 		 * In the future, we may have interally used tags that
2273 		 * should not appear in the XML output. Remove
2274 		 * anything we don't want to show here.
2275 		 */
2276 	}
2277 }
2278 
2279 /*
2280  * sa_show(flags, argc, argv)
2281  *
2282  * Implements the show subcommand.
2283  */
2284 
2285 int
sa_show(sa_handle_t handle,int flags,int argc,char * argv[])2286 sa_show(sa_handle_t handle, int flags, int argc, char *argv[])
2287 {
2288 	sa_group_t group;
2289 	int verbose = 0;
2290 	int properties = 0;
2291 	int c;
2292 	int ret = SA_OK;
2293 	char *protocol = NULL;
2294 	int xml = 0;
2295 	xmlDocPtr doc;
2296 #ifdef lint
2297 	flags = flags;
2298 #endif
2299 
2300 	while ((c = getopt(argc, argv, "?hvP:px")) !=	EOF) {
2301 		switch (c) {
2302 		case 'v':
2303 			verbose++;
2304 			break;
2305 		case 'p':
2306 			properties++;
2307 			break;
2308 		case 'P':
2309 			if (protocol != NULL) {
2310 				(void) printf(gettext(
2311 				    "Specifying multiple protocols "
2312 				    "not supported: %s\n"),
2313 				    protocol);
2314 				return (SA_SYNTAX_ERR);
2315 			}
2316 			protocol = optarg;
2317 			if (!sa_valid_protocol(protocol)) {
2318 				(void) printf(gettext(
2319 				    "Invalid protocol specified: %s\n"),
2320 				    protocol);
2321 				return (SA_INVALID_PROTOCOL);
2322 			}
2323 			break;
2324 		case 'x':
2325 			xml++;
2326 			break;
2327 		case 'h':
2328 			/* optopt on valid arg isn't defined */
2329 			optopt = c;
2330 			/*FALLTHROUGH*/
2331 		case '?':
2332 		default:
2333 			/*
2334 			 * Since a bad option gets to here, sort it
2335 			 * out and return a syntax error return value
2336 			 * if necessary.
2337 			 */
2338 			switch (optopt) {
2339 			default:
2340 				ret = SA_SYNTAX_ERR;
2341 				break;
2342 			case 'h':
2343 			case '?':
2344 				break;
2345 			}
2346 			(void) printf(gettext("usage: %s\n"),
2347 			    sa_get_usage(USAGE_SHOW));
2348 			return (ret);
2349 		}
2350 	}
2351 
2352 	if (xml) {
2353 		doc = show_group_xml_init();
2354 		if (doc == NULL)
2355 			ret = SA_NO_MEMORY;
2356 	}
2357 
2358 	if (optind == argc) {
2359 		/* No group specified so go through them all */
2360 		for (group = sa_get_group(handle, NULL);
2361 		    group != NULL;
2362 		    group = sa_get_next_group(group)) {
2363 			/*
2364 			 * Have a group so check if one we want and then list
2365 			 * contents with appropriate options.
2366 			 */
2367 			if (xml)
2368 				show_group_xml(doc, group);
2369 			else
2370 				show_group(group, verbose, properties, protocol,
2371 				    NULL);
2372 		}
2373 	} else {
2374 		/* Have a specified list of groups */
2375 		for (; optind < argc; optind++) {
2376 			group = sa_get_group(handle, argv[optind]);
2377 			if (group != NULL) {
2378 				if (xml)
2379 					show_group_xml(doc, group);
2380 				else
2381 					show_group(group, verbose, properties,
2382 					    protocol, NULL);
2383 			} else {
2384 				(void) printf(gettext("%s: not found\n"),
2385 				    argv[optind]);
2386 				ret = SA_NO_SUCH_GROUP;
2387 			}
2388 		}
2389 	}
2390 	if (xml && ret == SA_OK) {
2391 		(void) xmlDocFormatDump(stdout, doc, 1);
2392 		xmlFreeDoc(doc);
2393 	}
2394 	return (ret);
2395 
2396 }
2397 
2398 /*
2399  * enable_share(group, share, update_legacy)
2400  *
2401  * helper function to enable a share if the group is enabled.
2402  */
2403 
2404 static int
enable_share(sa_handle_t handle,sa_group_t group,sa_share_t share,int update_legacy)2405 enable_share(sa_handle_t handle, sa_group_t group, sa_share_t share,
2406     int update_legacy)
2407 {
2408 	char *value;
2409 	int enabled;
2410 	sa_optionset_t optionset;
2411 	int err;
2412 	int ret = SA_OK;
2413 	char *zfs = NULL;
2414 	int iszfs = 0;
2415 	int isshare;
2416 
2417 	/*
2418 	 * need to enable this share if the group is enabled but not
2419 	 * otherwise. The enable is also done on each protocol
2420 	 * represented in the group.
2421 	 */
2422 	value = sa_get_group_attr(group, "state");
2423 	enabled = value != NULL && strcmp(value, "enabled") == 0;
2424 	if (value != NULL)
2425 		sa_free_attr_string(value);
2426 	/* remove legacy config if necessary */
2427 	if (update_legacy)
2428 		ret = sa_delete_legacy(share, NULL);
2429 	zfs = sa_get_group_attr(group, "zfs");
2430 	if (zfs != NULL) {
2431 		iszfs++;
2432 		sa_free_attr_string(zfs);
2433 	}
2434 
2435 	/*
2436 	 * Step through each optionset at the group level and
2437 	 * enable the share based on the protocol type. This
2438 	 * works because protocols must be set on the group
2439 	 * for the protocol to be enabled.
2440 	 */
2441 	isshare = sa_is_share(share);
2442 	for (optionset = sa_get_optionset(group, NULL);
2443 	    optionset != NULL && ret == SA_OK;
2444 	    optionset = sa_get_next_optionset(optionset)) {
2445 		value = sa_get_optionset_attr(optionset, "type");
2446 		if (value != NULL) {
2447 			if (enabled) {
2448 				if (isshare) {
2449 					err = sa_enable_share(share, value);
2450 				} else {
2451 					err = sa_enable_resource(share, value);
2452 					if (err == SA_NOT_SUPPORTED) {
2453 						sa_share_t parent;
2454 						parent = sa_get_resource_parent(
2455 						    share);
2456 						if (parent != NULL)
2457 							err = sa_enable_share(
2458 							    parent, value);
2459 					}
2460 				}
2461 				if (err != SA_OK) {
2462 					ret = err;
2463 					(void) printf(gettext(
2464 					    "Failed to enable share for "
2465 					    "\"%s\": %s\n"),
2466 					    value, sa_errorstr(ret));
2467 				}
2468 			}
2469 			/*
2470 			 * If we want to update the legacy, use a copy of
2471 			 * share so we can avoid breaking the loop we are in
2472 			 * since we might also need to go up the tree to the
2473 			 * parent.
2474 			 */
2475 			if (update_legacy && !iszfs) {
2476 				sa_share_t update = share;
2477 				if (!sa_is_share(share)) {
2478 					update = sa_get_resource_parent(share);
2479 				}
2480 				(void) sa_update_legacy(update, value);
2481 			}
2482 			sa_free_attr_string(value);
2483 		}
2484 	}
2485 	if (ret == SA_OK)
2486 		(void) sa_update_config(handle);
2487 	return (ret);
2488 }
2489 
2490 /*
2491  * sa_require_resource(group)
2492  *
2493  * if any of the defined protocols on the group require resource
2494  * names, then all shares must have them.
2495  */
2496 
2497 static int
sa_require_resource(sa_group_t group)2498 sa_require_resource(sa_group_t group)
2499 {
2500 	sa_optionset_t optionset;
2501 
2502 	for (optionset = sa_get_optionset(group, NULL);
2503 	    optionset != NULL;
2504 	    optionset = sa_get_next_optionset(optionset)) {
2505 		char *proto;
2506 
2507 		proto = sa_get_optionset_attr(optionset, "type");
2508 		if (proto != NULL) {
2509 			uint64_t features;
2510 
2511 			features = sa_proto_get_featureset(proto);
2512 			if (features & SA_FEATURE_RESOURCE) {
2513 				sa_free_attr_string(proto);
2514 				return (B_TRUE);
2515 			}
2516 			sa_free_attr_string(proto);
2517 		}
2518 	}
2519 	return (B_FALSE);
2520 }
2521 
2522 /*
2523  * sa_addshare(flags, argc, argv)
2524  *
2525  * implements add-share subcommand.
2526  */
2527 
2528 static int
sa_addshare(sa_handle_t handle,int flags,int argc,char * argv[])2529 sa_addshare(sa_handle_t handle, int flags, int argc, char *argv[])
2530 {
2531 	int verbose = 0;
2532 	int dryrun = 0;
2533 	int c;
2534 	int ret = SA_OK;
2535 	sa_group_t group;
2536 	sa_share_t share;
2537 	sa_resource_t resource = NULL;
2538 	char *sharepath = NULL;
2539 	char *description = NULL;
2540 	char *rsrcname = NULL;
2541 	char *rsrc = NULL;
2542 	int persist = SA_SHARE_PERMANENT; /* default to persist */
2543 	int auth;
2544 	char dir[MAXPATHLEN];
2545 
2546 	while ((c = getopt(argc, argv, "?hvns:d:r:t")) != EOF) {
2547 		switch (c) {
2548 		case 'n':
2549 			dryrun++;
2550 			break;
2551 		case 'v':
2552 			verbose++;
2553 			break;
2554 		case 'd':
2555 			description = optarg;
2556 			break;
2557 		case 'r':
2558 			if (rsrcname != NULL) {
2559 				(void) printf(gettext("Adding multiple "
2560 				    "resource names not"
2561 				    " supported\n"));
2562 				return (SA_SYNTAX_ERR);
2563 			}
2564 			rsrcname = optarg;
2565 			break;
2566 		case 's':
2567 			/*
2568 			 * Save share path into group. Currently limit
2569 			 * to one share per command.
2570 			 */
2571 			if (sharepath != NULL) {
2572 				(void) printf(gettext(
2573 				    "Adding multiple shares not supported\n"));
2574 				return (SA_SYNTAX_ERR);
2575 			}
2576 			sharepath = optarg;
2577 			break;
2578 		case 't':
2579 			persist = SA_SHARE_TRANSIENT;
2580 			break;
2581 		case 'h':
2582 			/* optopt on valid arg isn't defined */
2583 			optopt = c;
2584 			/*FALLTHROUGH*/
2585 		case '?':
2586 		default:
2587 			/*
2588 			 * Since a bad option gets to here, sort it
2589 			 * out and return a syntax error return value
2590 			 * if necessary.
2591 			 */
2592 			switch (optopt) {
2593 			default:
2594 				ret = SA_SYNTAX_ERR;
2595 				break;
2596 			case 'h':
2597 			case '?':
2598 				break;
2599 			}
2600 			(void) printf(gettext("usage: %s\n"),
2601 			    sa_get_usage(USAGE_ADD_SHARE));
2602 			return (ret);
2603 		}
2604 	}
2605 
2606 	if (optind >= argc) {
2607 		(void) printf(gettext("usage: %s\n"),
2608 		    sa_get_usage(USAGE_ADD_SHARE));
2609 		if (dryrun || sharepath != NULL || description != NULL ||
2610 		    rsrcname != NULL || verbose || persist) {
2611 			(void) printf(gettext("\tgroup must be specified\n"));
2612 			ret = SA_NO_SUCH_GROUP;
2613 		} else {
2614 			ret = SA_OK;
2615 		}
2616 	} else {
2617 		if (sharepath == NULL) {
2618 			(void) printf(gettext("usage: %s\n"),
2619 			    sa_get_usage(USAGE_ADD_SHARE));
2620 			(void) printf(gettext(
2621 			    "\t-s sharepath must be specified\n"));
2622 			ret = SA_BAD_PATH;
2623 		}
2624 		if (ret == SA_OK) {
2625 			if (realpath(sharepath, dir) == NULL) {
2626 				ret = SA_BAD_PATH;
2627 				(void) printf(gettext("Path "
2628 				    "is not valid: %s\n"),
2629 				    sharepath);
2630 			} else {
2631 				sharepath = dir;
2632 			}
2633 		}
2634 		if (ret == SA_OK && rsrcname != NULL) {
2635 			/* check for valid syntax */
2636 			if (validresource(rsrcname)) {
2637 				rsrc = conv_to_utf8(rsrcname);
2638 				resource = sa_find_resource(handle, rsrc);
2639 				if (resource != NULL) {
2640 					/*
2641 					 * Resource names must be
2642 					 * unique in the system
2643 					 */
2644 					ret = SA_DUPLICATE_NAME;
2645 					(void) printf(gettext("usage: %s\n"),
2646 					    sa_get_usage(USAGE_ADD_SHARE));
2647 					(void) printf(gettext(
2648 					    "\tresource names must be unique "
2649 					    "in the system\n"));
2650 				}
2651 			} else {
2652 				(void) printf(gettext("usage: %s\n"),
2653 				    sa_get_usage(USAGE_ADD_SHARE));
2654 				(void) printf(gettext(
2655 				    "\tresource names use restricted "
2656 				    "character set\n"));
2657 				ret = SA_INVALID_NAME;
2658 			}
2659 		}
2660 
2661 		if (ret != SA_OK) {
2662 			if (rsrc != NULL && rsrcname != rsrc)
2663 				sa_free_attr_string(rsrc);
2664 			return (ret);
2665 		}
2666 
2667 		share = sa_find_share(handle, sharepath);
2668 		if (share != NULL) {
2669 			if (rsrcname == NULL) {
2670 				/*
2671 				 * Can only have a duplicate share if a new
2672 				 * resource name is being added.
2673 				 */
2674 				ret = SA_DUPLICATE_NAME;
2675 				(void) printf(gettext("Share path already "
2676 				    "shared: %s\n"), sharepath);
2677 			}
2678 		}
2679 		if (ret != SA_OK)
2680 			return (ret);
2681 
2682 		group = sa_get_group(handle, argv[optind]);
2683 		if (group != NULL) {
2684 			if (sa_require_resource(group) == B_TRUE &&
2685 			    rsrcname == NULL) {
2686 				(void) printf(gettext(
2687 				    "Resource name is required "
2688 				    "by at least one enabled protocol "
2689 				    "in group\n"));
2690 				return (SA_RESOURCE_REQUIRED);
2691 			}
2692 			if (share == NULL && ret == SA_OK) {
2693 				if (dryrun)
2694 					ret = sa_check_path(group, sharepath,
2695 					    SA_CHECK_NORMAL);
2696 				else
2697 					share = sa_add_share(group, sharepath,
2698 					    persist, &ret);
2699 			}
2700 			/*
2701 			 * Make sure this isn't an attempt to put a resourced
2702 			 * share into a different group than it already is in.
2703 			 */
2704 			if (share != NULL) {
2705 				sa_group_t parent;
2706 				parent = sa_get_parent_group(share);
2707 				if (parent != group) {
2708 					ret = SA_DUPLICATE_NAME;
2709 					(void) printf(gettext(
2710 					    "Share path already "
2711 					    "shared: %s\n"), sharepath);
2712 				}
2713 			}
2714 			if (!dryrun && share == NULL) {
2715 				(void) printf(gettext(
2716 				    "Could not add share: %s\n"),
2717 				    sa_errorstr(ret));
2718 			} else {
2719 				auth = check_authorizations(argv[optind],
2720 				    flags);
2721 				if (!dryrun && ret == SA_OK) {
2722 					if (rsrcname != NULL) {
2723 						resource = sa_add_resource(
2724 						    share,
2725 						    rsrc,
2726 						    SA_SHARE_PERMANENT,
2727 						    &ret);
2728 					}
2729 					if (ret == SA_OK &&
2730 					    description != NULL) {
2731 						if (resource != NULL)
2732 							ret =
2733 							    set_resource_desc(
2734 							    resource,
2735 							    description);
2736 						else
2737 							ret =
2738 							    set_share_desc(
2739 							    share,
2740 							    description);
2741 					}
2742 					if (ret == SA_OK) {
2743 						/* now enable the share(s) */
2744 						if (resource != NULL) {
2745 							ret = enable_share(
2746 							    handle,
2747 							    group,
2748 							    resource,
2749 							    1);
2750 						} else {
2751 							ret = enable_share(
2752 							    handle,
2753 							    group,
2754 							    share,
2755 							    1);
2756 						}
2757 						ret = sa_update_config(handle);
2758 					}
2759 					switch (ret) {
2760 					case SA_DUPLICATE_NAME:
2761 						(void) printf(gettext(
2762 						    "Resource name in"
2763 						    "use: %s\n"),
2764 						    rsrcname);
2765 						break;
2766 					default:
2767 						(void) printf(gettext(
2768 						    "Could not set "
2769 						    "attribute: %s\n"),
2770 						    sa_errorstr(ret));
2771 						break;
2772 					case SA_OK:
2773 						break;
2774 					}
2775 				} else if (dryrun && ret == SA_OK &&
2776 				    !auth && verbose) {
2777 					(void) printf(gettext(
2778 					    "Command would fail: %s\n"),
2779 					    sa_errorstr(SA_NO_PERMISSION));
2780 					ret = SA_NO_PERMISSION;
2781 				}
2782 			}
2783 		} else {
2784 			switch (ret) {
2785 			default:
2786 				(void) printf(gettext(
2787 				    "Group \"%s\" not found\n"), argv[optind]);
2788 				ret = SA_NO_SUCH_GROUP;
2789 				break;
2790 			case SA_BAD_PATH:
2791 			case SA_DUPLICATE_NAME:
2792 				break;
2793 			}
2794 		}
2795 	}
2796 	return (ret);
2797 }
2798 
2799 /*
2800  * sa_moveshare(flags, argc, argv)
2801  *
2802  * implements move-share subcommand.
2803  */
2804 
2805 int
sa_moveshare(sa_handle_t handle,int flags,int argc,char * argv[])2806 sa_moveshare(sa_handle_t handle, int flags, int argc, char *argv[])
2807 {
2808 	int verbose = 0;
2809 	int dryrun = 0;
2810 	int c;
2811 	int ret = SA_OK;
2812 	sa_group_t group;
2813 	sa_share_t share;
2814 	char *rsrcname = NULL;
2815 	char *sharepath = NULL;
2816 	int authsrc = 0, authdst = 0;
2817 	char dir[MAXPATHLEN];
2818 
2819 	while ((c = getopt(argc, argv, "?hvnr:s:")) != EOF) {
2820 		switch (c) {
2821 		case 'n':
2822 			dryrun++;
2823 			break;
2824 		case 'v':
2825 			verbose++;
2826 			break;
2827 		case 'r':
2828 			if (rsrcname != NULL) {
2829 				(void) printf(gettext(
2830 				    "Moving multiple resource names not"
2831 				    " supported\n"));
2832 				return (SA_SYNTAX_ERR);
2833 			}
2834 			rsrcname = optarg;
2835 			break;
2836 		case 's':
2837 			/*
2838 			 * Remove share path from group. Currently limit
2839 			 * to one share per command.
2840 			 */
2841 			if (sharepath != NULL) {
2842 				(void) printf(gettext("Moving multiple shares"
2843 				    " not supported\n"));
2844 				return (SA_SYNTAX_ERR);
2845 			}
2846 			sharepath = optarg;
2847 			break;
2848 		case 'h':
2849 			/* optopt on valid arg isn't defined */
2850 			optopt = c;
2851 			/*FALLTHROUGH*/
2852 		case '?':
2853 		default:
2854 			/*
2855 			 * Since a bad option gets to here, sort it
2856 			 * out and return a syntax error return value
2857 			 * if necessary.
2858 			 */
2859 			switch (optopt) {
2860 			default:
2861 				ret = SA_SYNTAX_ERR;
2862 				break;
2863 			case 'h':
2864 			case '?':
2865 				break;
2866 			}
2867 			(void) printf(gettext("usage: %s\n"),
2868 			    sa_get_usage(USAGE_MOVE_SHARE));
2869 			return (ret);
2870 		}
2871 	}
2872 
2873 	if (optind >= argc || sharepath == NULL) {
2874 		(void) printf(gettext("usage: %s\n"),
2875 		    sa_get_usage(USAGE_MOVE_SHARE));
2876 		if (dryrun || verbose || sharepath != NULL) {
2877 			(void) printf(gettext("\tgroup must be specified\n"));
2878 			ret = SA_NO_SUCH_GROUP;
2879 		} else {
2880 			if (sharepath == NULL) {
2881 				ret = SA_SYNTAX_ERR;
2882 				(void) printf(gettext(
2883 				    "\tsharepath must be specified\n"));
2884 			} else {
2885 				ret = SA_OK;
2886 			}
2887 		}
2888 	} else {
2889 		sa_group_t parent;
2890 		char *zfsold;
2891 		char *zfsnew;
2892 
2893 		if (sharepath == NULL) {
2894 			(void) printf(gettext(
2895 			    "sharepath must be specified with the -s "
2896 			    "option\n"));
2897 			return (SA_BAD_PATH);
2898 		}
2899 		group = sa_get_group(handle, argv[optind]);
2900 		if (group == NULL) {
2901 			(void) printf(gettext("Group \"%s\" not found\n"),
2902 			    argv[optind]);
2903 			return (SA_NO_SUCH_GROUP);
2904 		}
2905 		share = sa_find_share(handle, sharepath);
2906 		/*
2907 		 * If a share wasn't found, it may have been a symlink
2908 		 * or has a trailing '/'. Try again after resolving
2909 		 * with realpath().
2910 		 */
2911 		if (share == NULL) {
2912 			if (realpath(sharepath, dir) == NULL) {
2913 				(void) printf(gettext("Path "
2914 				    "is not valid: %s\n"),
2915 				    sharepath);
2916 				return (SA_BAD_PATH);
2917 			}
2918 			sharepath = dir;
2919 			share = sa_find_share(handle, sharepath);
2920 		}
2921 		if (share == NULL) {
2922 			(void) printf(gettext("Share not found: %s\n"),
2923 			    sharepath);
2924 			return (SA_NO_SUCH_PATH);
2925 		}
2926 		authdst = check_authorizations(argv[optind], flags);
2927 
2928 		parent = sa_get_parent_group(share);
2929 		if (parent != NULL) {
2930 			char *pname;
2931 			pname = sa_get_group_attr(parent, "name");
2932 			if (pname != NULL) {
2933 				authsrc = check_authorizations(pname, flags);
2934 				sa_free_attr_string(pname);
2935 			}
2936 			zfsold = sa_get_group_attr(parent, "zfs");
2937 			zfsnew = sa_get_group_attr(group, "zfs");
2938 			if ((zfsold != NULL && zfsnew == NULL) ||
2939 			    (zfsold == NULL && zfsnew != NULL)) {
2940 				ret = SA_NOT_ALLOWED;
2941 			}
2942 			if (zfsold != NULL)
2943 				sa_free_attr_string(zfsold);
2944 			if (zfsnew != NULL)
2945 				sa_free_attr_string(zfsnew);
2946 		}
2947 
2948 		if (ret == SA_OK && parent != group && !dryrun) {
2949 			char *oldstate;
2950 			/*
2951 			 * Note that the share may need to be
2952 			 * "unshared" if the new group is disabled and
2953 			 * the old was enabled or it may need to be
2954 			 * share to update if the new group is
2955 			 * enabled. We disable before the move and
2956 			 * will have to enable after the move in order
2957 			 * to cleanup entries for protocols that
2958 			 * aren't in the new group.
2959 			 */
2960 			oldstate = sa_get_group_attr(parent, "state");
2961 			if (oldstate != NULL) {
2962 				/* enable_share determines what to do */
2963 				if (strcmp(oldstate, "enabled") == 0)
2964 					(void) sa_disable_share(share, NULL);
2965 				sa_free_attr_string(oldstate);
2966 			}
2967 		}
2968 
2969 		if (!dryrun && ret == SA_OK)
2970 			ret = sa_move_share(group, share);
2971 
2972 		/*
2973 		 * Reenable and update any config information.
2974 		 */
2975 		if (ret == SA_OK && parent != group && !dryrun) {
2976 			ret = sa_update_config(handle);
2977 
2978 			(void) enable_share(handle, group, share, 1);
2979 		}
2980 
2981 		if (ret != SA_OK)
2982 			(void) printf(gettext("Could not move share: %s\n"),
2983 			    sa_errorstr(ret));
2984 
2985 		if (dryrun && ret == SA_OK && !(authsrc & authdst) &&
2986 		    verbose) {
2987 			(void) printf(gettext("Command would fail: %s\n"),
2988 			    sa_errorstr(SA_NO_PERMISSION));
2989 		}
2990 	}
2991 	return (ret);
2992 }
2993 
2994 /*
2995  * sa_removeshare(flags, argc, argv)
2996  *
2997  * implements remove-share subcommand.
2998  */
2999 
3000 int
sa_removeshare(sa_handle_t handle,int flags,int argc,char * argv[])3001 sa_removeshare(sa_handle_t handle, int flags, int argc, char *argv[])
3002 {
3003 	int verbose = 0;
3004 	int dryrun = 0;
3005 	int force = 0;
3006 	int c;
3007 	int ret = SA_OK;
3008 	sa_group_t group;
3009 	sa_resource_t resource = NULL;
3010 	sa_share_t share = NULL;
3011 	char *rsrcname = NULL;
3012 	char *sharepath = NULL;
3013 	char dir[MAXPATHLEN];
3014 	int auth;
3015 
3016 	while ((c = getopt(argc, argv, "?hfnr:s:v")) != EOF) {
3017 		switch (c) {
3018 		case 'n':
3019 			dryrun++;
3020 			break;
3021 		case 'v':
3022 			verbose++;
3023 			break;
3024 		case 'f':
3025 			force++;
3026 			break;
3027 		case 's':
3028 			/*
3029 			 * Remove share path from group. Currently limit
3030 			 * to one share per command.
3031 			 */
3032 			if (sharepath != NULL) {
3033 				(void) printf(gettext(
3034 				    "Removing multiple shares not "
3035 				    "supported\n"));
3036 				return (SA_SYNTAX_ERR);
3037 			}
3038 			sharepath = optarg;
3039 			break;
3040 		case 'r':
3041 			/*
3042 			 * Remove share from group if last resource or remove
3043 			 * resource from share if multiple resources.
3044 			 */
3045 			if (rsrcname != NULL) {
3046 				(void) printf(gettext(
3047 				    "Removing multiple resource names not "
3048 				    "supported\n"));
3049 				return (SA_SYNTAX_ERR);
3050 			}
3051 			rsrcname = optarg;
3052 			break;
3053 		case 'h':
3054 			/* optopt on valid arg isn't defined */
3055 			optopt = c;
3056 			/*FALLTHROUGH*/
3057 		case '?':
3058 		default:
3059 			/*
3060 			 * Since a bad option gets to here, sort it
3061 			 * out and return a syntax error return value
3062 			 * if necessary.
3063 			 */
3064 			switch (optopt) {
3065 			default:
3066 				ret = SA_SYNTAX_ERR;
3067 				break;
3068 			case 'h':
3069 			case '?':
3070 				break;
3071 			}
3072 			(void) printf(gettext("usage: %s\n"),
3073 			    sa_get_usage(USAGE_REMOVE_SHARE));
3074 			return (ret);
3075 		}
3076 	}
3077 
3078 	if (optind >= argc || (rsrcname == NULL && sharepath == NULL)) {
3079 		if (sharepath == NULL && rsrcname == NULL) {
3080 			(void) printf(gettext("usage: %s\n"),
3081 			    sa_get_usage(USAGE_REMOVE_SHARE));
3082 			(void) printf(gettext("\t-s sharepath or -r resource"
3083 			    " must be specified\n"));
3084 			ret = SA_BAD_PATH;
3085 		} else {
3086 			ret = SA_OK;
3087 		}
3088 	}
3089 	if (ret != SA_OK) {
3090 		return (ret);
3091 	}
3092 
3093 	if (optind < argc) {
3094 		if ((optind + 1) < argc) {
3095 			(void) printf(gettext("Extraneous group(s) at end of "
3096 			    "command\n"));
3097 			ret = SA_SYNTAX_ERR;
3098 		} else {
3099 			group = sa_get_group(handle, argv[optind]);
3100 			if (group == NULL) {
3101 				(void) printf(gettext(
3102 				    "Group \"%s\" not found\n"), argv[optind]);
3103 				ret = SA_NO_SUCH_GROUP;
3104 			}
3105 		}
3106 	} else {
3107 		group = NULL;
3108 	}
3109 
3110 	if (rsrcname != NULL) {
3111 		resource = sa_find_resource(handle, rsrcname);
3112 		if (resource == NULL) {
3113 			ret = SA_NO_SUCH_RESOURCE;
3114 			(void) printf(gettext(
3115 			    "Resource name not found for share: %s\n"),
3116 			    rsrcname);
3117 		}
3118 	}
3119 
3120 	/*
3121 	 * Lookup the path in the internal configuration. Care
3122 	 * must be taken to handle the case where the
3123 	 * underlying path has been removed since we need to
3124 	 * be able to deal with that as well.
3125 	 */
3126 	if (ret == SA_OK) {
3127 		if (sharepath != NULL) {
3128 			if (group != NULL)
3129 				share = sa_get_share(group, sharepath);
3130 			else
3131 				share = sa_find_share(handle, sharepath);
3132 		}
3133 
3134 		if (resource != NULL) {
3135 			sa_share_t rsrcshare;
3136 			rsrcshare = sa_get_resource_parent(resource);
3137 			if (share == NULL)
3138 				share = rsrcshare;
3139 			else if (share != rsrcshare) {
3140 				ret = SA_NO_SUCH_RESOURCE;
3141 				(void) printf(gettext(
3142 				    "Bad resource name for share: %s\n"),
3143 				    rsrcname);
3144 				share = NULL;
3145 			}
3146 		}
3147 
3148 		/*
3149 		 * If we didn't find the share with the provided path,
3150 		 * it may be a symlink so attempt to resolve it using
3151 		 * realpath and try again. Realpath will resolve any
3152 		 * symlinks and place them in "dir". Note that
3153 		 * sharepath is only used for the lookup the first
3154 		 * time and later for error messages. dir will be used
3155 		 * on the second attempt. Once a share is found, all
3156 		 * operations are based off of the share variable.
3157 		 */
3158 		if (share == NULL) {
3159 			if (realpath(sharepath, dir) == NULL) {
3160 				ret = SA_BAD_PATH;
3161 				(void) printf(gettext(
3162 				    "Path is not valid: %s\n"), sharepath);
3163 			} else {
3164 				if (group != NULL)
3165 					share = sa_get_share(group, dir);
3166 				else
3167 					share = sa_find_share(handle, dir);
3168 			}
3169 		}
3170 	}
3171 
3172 	/*
3173 	 * If there hasn't been an error, there was likely a
3174 	 * path found. If not, give the appropriate error
3175 	 * message and set the return error. If it was found,
3176 	 * then disable the share and then remove it from the
3177 	 * configuration.
3178 	 */
3179 	if (ret != SA_OK) {
3180 		return (ret);
3181 	}
3182 	if (share == NULL) {
3183 		if (group != NULL)
3184 			(void) printf(gettext("Share not found in group %s:"
3185 			    " %s\n"), argv[optind], sharepath);
3186 		else
3187 			(void) printf(gettext("Share not found: %s\n"),
3188 			    sharepath);
3189 		ret = SA_NO_SUCH_PATH;
3190 	} else {
3191 		if (group == NULL)
3192 			group = sa_get_parent_group(share);
3193 		if (!dryrun) {
3194 			if (ret == SA_OK) {
3195 				if (resource != NULL)
3196 					ret = sa_disable_resource(resource,
3197 					    NULL);
3198 				else
3199 					ret = sa_disable_share(share, NULL);
3200 				/*
3201 				 * We don't care if it fails since it
3202 				 * could be disabled already. Some
3203 				 * unexpected errors could occur that
3204 				 * prevent removal, so also check for
3205 				 * force being set.
3206 				 */
3207 				if ((ret == SA_OK || ret == SA_NO_SUCH_PATH ||
3208 				    ret == SA_NOT_SUPPORTED ||
3209 				    ret == SA_SYSTEM_ERR || force) &&
3210 				    resource == NULL)
3211 					ret = sa_remove_share(share);
3212 
3213 				if ((ret == SA_OK || ret == SA_NO_SUCH_PATH ||
3214 				    ret == SA_NOT_SUPPORTED ||
3215 				    ret == SA_SYSTEM_ERR || force) &&
3216 				    resource != NULL) {
3217 					ret = sa_remove_resource(resource);
3218 					if (ret == SA_OK) {
3219 						/*
3220 						 * If this was the
3221 						 * last one, remove
3222 						 * the share as well.
3223 						 */
3224 						resource =
3225 						    sa_get_share_resource(
3226 						    share, NULL);
3227 						if (resource == NULL)
3228 							ret = sa_remove_share(
3229 							    share);
3230 					}
3231 				}
3232 				if (ret == SA_OK)
3233 					ret = sa_update_config(handle);
3234 			}
3235 			if (ret != SA_OK)
3236 				(void) printf(gettext("Could not remove share:"
3237 				    " %s\n"), sa_errorstr(ret));
3238 		} else if (ret == SA_OK) {
3239 			char *pname;
3240 			pname = sa_get_group_attr(group, "name");
3241 			if (pname != NULL) {
3242 				auth = check_authorizations(pname, flags);
3243 				sa_free_attr_string(pname);
3244 			}
3245 			if (!auth && verbose) {
3246 				(void) printf(gettext(
3247 				    "Command would fail: %s\n"),
3248 				    sa_errorstr(SA_NO_PERMISSION));
3249 			}
3250 		}
3251 	}
3252 	return (ret);
3253 }
3254 
3255 /*
3256  * sa_set_share(flags, argc, argv)
3257  *
3258  * implements set-share subcommand.
3259  */
3260 
3261 int
sa_set_share(sa_handle_t handle,int flags,int argc,char * argv[])3262 sa_set_share(sa_handle_t handle, int flags, int argc, char *argv[])
3263 {
3264 	int dryrun = 0;
3265 	int c;
3266 	int ret = SA_OK;
3267 	sa_group_t group, sharegroup;
3268 	sa_share_t share = NULL;
3269 	sa_resource_t resource = NULL;
3270 	char *sharepath = NULL;
3271 	char *description = NULL;
3272 	char *rsrcname = NULL;
3273 	char *rsrc = NULL;
3274 	char *newname = NULL;
3275 	char *newrsrc;
3276 	char *groupname = NULL;
3277 	int auth;
3278 	int verbose = 0;
3279 
3280 	while ((c = getopt(argc, argv, "?hnd:r:s:")) != EOF) {
3281 		switch (c) {
3282 		case 'n':
3283 			dryrun++;
3284 			break;
3285 		case 'd':
3286 			description = optarg;
3287 			break;
3288 		case 'v':
3289 			verbose++;
3290 			break;
3291 		case 'r':
3292 			/*
3293 			 * Update share by resource name
3294 			 */
3295 			if (rsrcname != NULL) {
3296 				(void) printf(gettext(
3297 				    "Updating multiple resource names not "
3298 				    "supported\n"));
3299 				return (SA_SYNTAX_ERR);
3300 			}
3301 			rsrcname = optarg;
3302 			break;
3303 		case 's':
3304 			/*
3305 			 * Save share path into group. Currently limit
3306 			 * to one share per command.
3307 			 */
3308 			if (sharepath != NULL) {
3309 				(void) printf(gettext(
3310 				    "Updating multiple shares not "
3311 				    "supported\n"));
3312 				return (SA_SYNTAX_ERR);
3313 			}
3314 			sharepath = optarg;
3315 			break;
3316 		case 'h':
3317 			/* optopt on valid arg isn't defined */
3318 			optopt = c;
3319 			/*FALLTHROUGH*/
3320 		case '?':
3321 		default:
3322 			/*
3323 			 * Since a bad option gets to here, sort it
3324 			 * out and return a syntax error return value
3325 			 * if necessary.
3326 			 */
3327 			switch (optopt) {
3328 			default:
3329 				ret = SA_SYNTAX_ERR;
3330 				break;
3331 			case 'h':
3332 			case '?':
3333 				break;
3334 			}
3335 			(void) printf(gettext("usage: %s\n"),
3336 			    sa_get_usage(USAGE_SET_SHARE));
3337 			return (ret);
3338 		}
3339 	}
3340 
3341 	if (optind >= argc && sharepath == NULL && rsrcname == NULL) {
3342 		if (sharepath == NULL) {
3343 			(void) printf(gettext("usage: %s\n"),
3344 			    sa_get_usage(USAGE_SET_SHARE));
3345 			(void) printf(gettext("\tgroup must be specified\n"));
3346 			ret = SA_BAD_PATH;
3347 		} else {
3348 			ret = SA_OK;
3349 		}
3350 	}
3351 	if ((optind + 1) < argc) {
3352 		(void) printf(gettext("usage: %s\n"),
3353 		    sa_get_usage(USAGE_SET_SHARE));
3354 		(void) printf(gettext("\tExtraneous group(s) at end\n"));
3355 		ret = SA_SYNTAX_ERR;
3356 	}
3357 
3358 	/*
3359 	 * Must have at least one of sharepath and rsrcrname.
3360 	 * It is a syntax error to be missing both.
3361 	 */
3362 	if (sharepath == NULL && rsrcname == NULL) {
3363 		(void) printf(gettext("usage: %s\n"),
3364 		    sa_get_usage(USAGE_SET_SHARE));
3365 		ret = SA_SYNTAX_ERR;
3366 	}
3367 
3368 	if (ret != SA_OK)
3369 		return (ret);
3370 
3371 	if (optind < argc) {
3372 		groupname = argv[optind];
3373 		group = sa_get_group(handle, groupname);
3374 	} else {
3375 		group = NULL;
3376 		groupname = NULL;
3377 	}
3378 	if (rsrcname != NULL) {
3379 		/*
3380 		 * If rsrcname exists, split rename syntax and then
3381 		 * convert to utf 8 if no errors.
3382 		 */
3383 		newname = strchr(rsrcname, '=');
3384 		if (newname != NULL) {
3385 			*newname++ = '\0';
3386 		}
3387 		if (!validresource(rsrcname)) {
3388 			ret = SA_INVALID_NAME;
3389 			(void) printf(gettext("Invalid resource name: "
3390 			    "\"%s\"\n"), rsrcname);
3391 		} else {
3392 			rsrc = conv_to_utf8(rsrcname);
3393 		}
3394 		if (newname != NULL) {
3395 			if (!validresource(newname)) {
3396 				ret = SA_INVALID_NAME;
3397 				(void) printf(gettext("Invalid resource name: "
3398 				    "%s\n"), newname);
3399 				newname = NULL;
3400 			} else {
3401 				newrsrc = conv_to_utf8(newname);
3402 			}
3403 		}
3404 	}
3405 
3406 	if (ret != SA_OK) {
3407 		if (rsrcname != NULL && rsrcname != rsrc)
3408 			sa_free_attr_string(rsrc);
3409 		if (newname != NULL && newname != newrsrc)
3410 			sa_free_attr_string(newrsrc);
3411 		return (ret);
3412 	}
3413 
3414 	if (sharepath != NULL) {
3415 		share = sa_find_share(handle, sharepath);
3416 	} else if (rsrcname != NULL) {
3417 		resource = sa_find_resource(handle, rsrc);
3418 		if (resource != NULL)
3419 			share = sa_get_resource_parent(resource);
3420 		else
3421 			ret = SA_NO_SUCH_RESOURCE;
3422 	}
3423 	if (share != NULL) {
3424 		sharegroup = sa_get_parent_group(share);
3425 		if (group != NULL && group != sharegroup) {
3426 			(void) printf(gettext("Group \"%s\" does not contain "
3427 			    "share %s\n"),
3428 			    argv[optind], sharepath);
3429 			ret = SA_BAD_PATH;
3430 		} else {
3431 			int delgroupname = 0;
3432 			if (groupname == NULL) {
3433 				groupname = sa_get_group_attr(sharegroup,
3434 				    "name");
3435 				delgroupname = 1;
3436 			}
3437 			if (groupname != NULL) {
3438 				auth = check_authorizations(groupname, flags);
3439 				if (delgroupname) {
3440 					sa_free_attr_string(groupname);
3441 					groupname = NULL;
3442 				}
3443 			} else {
3444 				ret = SA_NO_MEMORY;
3445 			}
3446 			if (rsrcname != NULL) {
3447 				resource = sa_find_resource(handle, rsrc);
3448 				if (!dryrun) {
3449 					if (newname != NULL &&
3450 					    resource != NULL)
3451 						ret = sa_rename_resource(
3452 						    resource, newrsrc);
3453 					else if (newname != NULL)
3454 						ret = SA_NO_SUCH_RESOURCE;
3455 					if (newname != NULL &&
3456 					    newname != newrsrc)
3457 						sa_free_attr_string(newrsrc);
3458 				}
3459 				if (rsrc != rsrcname)
3460 					sa_free_attr_string(rsrc);
3461 			}
3462 
3463 			/*
3464 			 * If the user has set a description, it will be
3465 			 * on the resource if -r was used otherwise it
3466 			 * must be on the share.
3467 			 */
3468 			if (!dryrun && ret == SA_OK && description != NULL) {
3469 				char *desc;
3470 				desc = conv_to_utf8(description);
3471 				if (resource != NULL)
3472 					ret = sa_set_resource_description(
3473 					    resource, desc);
3474 				else
3475 					ret = sa_set_share_description(share,
3476 					    desc);
3477 				if (desc != description)
3478 					sa_free_share_description(desc);
3479 			}
3480 		}
3481 		if (!dryrun && ret == SA_OK) {
3482 			if (resource != NULL)
3483 				(void) sa_enable_resource(resource, NULL);
3484 			ret = sa_update_config(handle);
3485 		}
3486 		switch (ret) {
3487 		case SA_DUPLICATE_NAME:
3488 			(void) printf(gettext("Resource name in use: %s\n"),
3489 			    rsrcname);
3490 			break;
3491 		default:
3492 			(void) printf(gettext("Could not set: %s\n"),
3493 			    sa_errorstr(ret));
3494 			break;
3495 		case SA_OK:
3496 			if (dryrun && !auth && verbose) {
3497 				(void) printf(gettext(
3498 				    "Command would fail: %s\n"),
3499 				    sa_errorstr(SA_NO_PERMISSION));
3500 			}
3501 			break;
3502 		}
3503 	} else {
3504 		switch (ret) {
3505 		case SA_NO_SUCH_RESOURCE:
3506 			(void) printf(gettext("Resource \"%s\" not found\n"),
3507 			    rsrcname);
3508 			break;
3509 		default:
3510 			if (sharepath != NULL) {
3511 				(void) printf(
3512 				    gettext("Share path \"%s\" not found\n"),
3513 				    sharepath);
3514 				ret = SA_NO_SUCH_PATH;
3515 			} else {
3516 				(void) printf(gettext("Set failed: %s\n"),
3517 				    sa_errorstr(ret));
3518 			}
3519 		}
3520 	}
3521 
3522 	return (ret);
3523 }
3524 
3525 /*
3526  * add_security(group, sectype, optlist, proto, *err)
3527  *
3528  * Helper function to add a security option (named optionset) to the
3529  * group.
3530  */
3531 
3532 static int
add_security(sa_group_t group,char * sectype,struct options * optlist,char * proto,int * err)3533 add_security(sa_group_t group, char *sectype,
3534     struct options *optlist, char *proto, int *err)
3535 {
3536 	sa_security_t security;
3537 	int ret = SA_OK;
3538 	int result = 0;
3539 	sa_handle_t handle;
3540 
3541 	sectype = sa_proto_space_alias(proto, sectype);
3542 	security = sa_get_security(group, sectype, proto);
3543 	if (security == NULL)
3544 		security = sa_create_security(group, sectype, proto);
3545 
3546 	if (sectype != NULL)
3547 		sa_free_attr_string(sectype);
3548 
3549 	if (security == NULL)
3550 		goto done;
3551 
3552 	handle = sa_find_group_handle(group);
3553 	if (handle == NULL) {
3554 		ret = SA_CONFIG_ERR;
3555 		goto done;
3556 	}
3557 	while (optlist != NULL) {
3558 		sa_property_t prop;
3559 		prop = sa_get_property(security, optlist->optname);
3560 		if (prop == NULL) {
3561 			/*
3562 			 * Add the property, but only if it is
3563 			 * a non-NULL or non-zero length value
3564 			 */
3565 			if (optlist->optvalue != NULL) {
3566 				prop = sa_create_property(optlist->optname,
3567 				    optlist->optvalue);
3568 				if (prop != NULL) {
3569 					ret = sa_valid_property(handle,
3570 					    security, proto, prop);
3571 					if (ret != SA_OK) {
3572 						(void) sa_remove_property(prop);
3573 						(void) printf(gettext(
3574 						    "Could not add "
3575 						    "property %s: %s\n"),
3576 						    optlist->optname,
3577 						    sa_errorstr(ret));
3578 					}
3579 					if (ret == SA_OK) {
3580 						ret = sa_add_property(security,
3581 						    prop);
3582 						if (ret != SA_OK) {
3583 							(void) printf(gettext(
3584 							    "Could not add "
3585 							    "property (%s=%s):"
3586 							    " %s\n"),
3587 							    optlist->optname,
3588 							    optlist->optvalue,
3589 							    sa_errorstr(ret));
3590 						} else {
3591 							result = 1;
3592 						}
3593 					}
3594 				}
3595 			}
3596 		} else {
3597 			ret = sa_update_property(prop, optlist->optvalue);
3598 			result = 1; /* should check if really changed */
3599 		}
3600 		optlist = optlist->next;
3601 	}
3602 	/*
3603 	 * When done, properties may have all been removed but
3604 	 * we need to keep the security type itself until
3605 	 * explicitly removed.
3606 	 */
3607 	if (result)
3608 		ret = sa_commit_properties(security, 0);
3609 done:
3610 	*err = ret;
3611 	return (result);
3612 }
3613 
3614 /*
3615  * zfscheck(group, share)
3616  *
3617  * For the special case where a share was provided, make sure it is a
3618  * compatible path for a ZFS property change.  The only path
3619  * acceptable is the path that defines the zfs sub-group (dataset with
3620  * the sharenfs property set) and not one of the paths that inherited
3621  * the NFS properties. Returns SA_OK if it is usable and
3622  * SA_NOT_ALLOWED if it isn't.
3623  *
3624  * If group is not a ZFS group/subgroup, we assume OK since the check
3625  * on return will catch errors for those cases.  What we are looking
3626  * for here is that the group is ZFS and the share is not the defining
3627  * share.  All else is SA_OK.
3628  */
3629 
3630 static int
zfscheck(sa_group_t group,sa_share_t share)3631 zfscheck(sa_group_t group, sa_share_t share)
3632 {
3633 	int ret = SA_OK;
3634 	char *attr;
3635 
3636 	if (sa_group_is_zfs(group)) {
3637 		/*
3638 		 * The group is a ZFS group.  Does the share represent
3639 		 * the dataset that defined the group? It is only OK
3640 		 * if the attribute "subgroup" exists on the share and
3641 		 * has a value of "true".
3642 		 */
3643 
3644 		ret = SA_NOT_ALLOWED;
3645 		attr = sa_get_share_attr(share, "subgroup");
3646 		if (attr != NULL) {
3647 			if (strcmp(attr, "true") == 0)
3648 				ret = SA_OK;
3649 			sa_free_attr_string(attr);
3650 		}
3651 	}
3652 	return (ret);
3653 }
3654 
3655 /*
3656  * basic_set(groupname, optlist, protocol, sharepath, rsrcname, dryrun)
3657  *
3658  * This function implements "set" when a name space (-S) is not
3659  * specified. It is a basic set. Options and other CLI parsing has
3660  * already been done.
3661  *
3662  * "rsrcname" is a "resource name". If it is non-NULL, it must match
3663  * the sharepath if present or group if present, otherwise it is used
3664  * to set options.
3665  *
3666  * Resource names may take options if the protocol supports it. If the
3667  * protocol doesn't support resource level options, rsrcname is just
3668  * an alias for the share.
3669  */
3670 
3671 static int
basic_set(sa_handle_t handle,char * groupname,struct options * optlist,char * protocol,char * sharepath,char * rsrcname,int dryrun)3672 basic_set(sa_handle_t handle, char *groupname, struct options *optlist,
3673     char *protocol, char *sharepath, char *rsrcname, int dryrun)
3674 {
3675 	sa_group_t group;
3676 	int ret = SA_OK;
3677 	int change = 0;
3678 	struct list *worklist = NULL;
3679 
3680 	group = sa_get_group(handle, groupname);
3681 	if (group != NULL) {
3682 		sa_share_t share = NULL;
3683 		sa_resource_t resource = NULL;
3684 
3685 		/*
3686 		 * If there is a sharepath, make sure it belongs to
3687 		 * the group.
3688 		 */
3689 		if (sharepath != NULL) {
3690 			share = sa_get_share(group, sharepath);
3691 			if (share == NULL) {
3692 				(void) printf(gettext(
3693 				    "Share does not exist in group %s\n"),
3694 				    groupname, sharepath);
3695 				ret = SA_NO_SUCH_PATH;
3696 			} else {
3697 				/* if ZFS and OK, then only group */
3698 				ret = zfscheck(group, share);
3699 				if (ret == SA_OK &&
3700 				    sa_group_is_zfs(group))
3701 					share = NULL;
3702 				if (ret == SA_NOT_ALLOWED)
3703 					(void) printf(gettext(
3704 					    "Properties on ZFS group shares "
3705 					    "not supported: %s\n"), sharepath);
3706 			}
3707 		}
3708 
3709 		/*
3710 		 * If a resource name exists, make sure it belongs to
3711 		 * the share if present else it belongs to the
3712 		 * group. Also check the protocol to see if it
3713 		 * supports resource level properties or not. If not,
3714 		 * use share only.
3715 		 */
3716 		if (rsrcname != NULL) {
3717 			if (share != NULL) {
3718 				resource = sa_get_share_resource(share,
3719 				    rsrcname);
3720 				if (resource == NULL)
3721 					ret = SA_NO_SUCH_RESOURCE;
3722 			} else {
3723 				resource = sa_get_resource(group, rsrcname);
3724 				if (resource != NULL)
3725 					share = sa_get_resource_parent(
3726 					    resource);
3727 				else
3728 					ret = SA_NO_SUCH_RESOURCE;
3729 			}
3730 			if (ret == SA_OK && resource != NULL) {
3731 				uint64_t features;
3732 				/*
3733 				 * Check to see if the resource can take
3734 				 * properties. If so, stick the resource into
3735 				 * "share" so it will all just work.
3736 				 */
3737 				features = sa_proto_get_featureset(protocol);
3738 				if (features & SA_FEATURE_RESOURCE)
3739 					share = (sa_share_t)resource;
3740 			}
3741 		}
3742 
3743 		if (ret == SA_OK) {
3744 			/* group must exist */
3745 			ret = valid_options(handle, optlist, protocol,
3746 			    share == NULL ? group : share, NULL);
3747 			if (ret == SA_OK && !dryrun) {
3748 				if (share != NULL)
3749 					change |= add_optionset(share, optlist,
3750 					    protocol, &ret);
3751 				else
3752 					change |= add_optionset(group, optlist,
3753 					    protocol, &ret);
3754 				if (ret == SA_OK && change)
3755 					worklist = add_list(worklist, group,
3756 					    share, protocol);
3757 			}
3758 		}
3759 		free_opt(optlist);
3760 	} else {
3761 		(void) printf(gettext("Group \"%s\" not found\n"), groupname);
3762 		ret = SA_NO_SUCH_GROUP;
3763 	}
3764 	/*
3765 	 * we have a group and potentially legal additions
3766 	 */
3767 
3768 	/*
3769 	 * Commit to configuration if not a dryrunp and properties
3770 	 * have changed.
3771 	 */
3772 	if (!dryrun && ret == SA_OK && change && worklist != NULL)
3773 		/* properties changed, so update all shares */
3774 		(void) enable_all_groups(handle, worklist, 0, 0, protocol,
3775 		    B_TRUE);
3776 
3777 	if (worklist != NULL)
3778 		free_list(worklist);
3779 	return (ret);
3780 }
3781 
3782 /*
3783  * space_set(groupname, optlist, protocol, sharepath, dryrun)
3784  *
3785  * This function implements "set" when a name space (-S) is
3786  * specified. It is a namespace set. Options and other CLI parsing has
3787  * already been done.
3788  */
3789 
3790 static int
space_set(sa_handle_t handle,char * groupname,struct options * optlist,char * protocol,char * sharepath,int dryrun,char * sectype)3791 space_set(sa_handle_t handle, char *groupname, struct options *optlist,
3792     char *protocol, char *sharepath, int dryrun, char *sectype)
3793 {
3794 	sa_group_t group;
3795 	int ret = SA_OK;
3796 	int change = 0;
3797 	struct list *worklist = NULL;
3798 
3799 	/*
3800 	 * make sure protcol and sectype are valid
3801 	 */
3802 
3803 	if (sa_proto_valid_space(protocol, sectype) == 0) {
3804 		(void) printf(gettext("Option space \"%s\" not valid "
3805 		    "for protocol.\n"), sectype);
3806 		return (SA_INVALID_SECURITY);
3807 	}
3808 
3809 	group = sa_get_group(handle, groupname);
3810 	if (group != NULL) {
3811 		sa_share_t share = NULL;
3812 		if (sharepath != NULL) {
3813 			share = sa_get_share(group, sharepath);
3814 			if (share == NULL) {
3815 				(void) printf(gettext(
3816 				    "Share does not exist in group %s\n"),
3817 				    groupname, sharepath);
3818 				ret = SA_NO_SUCH_PATH;
3819 			} else {
3820 				/* if ZFS and OK, then only group */
3821 				ret = zfscheck(group, share);
3822 				if (ret == SA_OK &&
3823 				    sa_group_is_zfs(group))
3824 					share = NULL;
3825 				if (ret == SA_NOT_ALLOWED)
3826 					(void) printf(gettext(
3827 					    "Properties on ZFS group shares "
3828 					    "not supported: %s\n"), sharepath);
3829 			}
3830 		}
3831 		if (ret == SA_OK) {
3832 			/* group must exist */
3833 			ret = valid_options(handle, optlist, protocol,
3834 			    share == NULL ? group : share, sectype);
3835 			if (ret == SA_OK && !dryrun) {
3836 				if (share != NULL)
3837 					change = add_security(share, sectype,
3838 					    optlist, protocol, &ret);
3839 				else
3840 					change = add_security(group, sectype,
3841 					    optlist, protocol, &ret);
3842 				if (ret != SA_OK)
3843 					(void) printf(gettext(
3844 					    "Could not set property: %s\n"),
3845 					    sa_errorstr(ret));
3846 			}
3847 			if (ret == SA_OK && change)
3848 				worklist = add_list(worklist, group, share,
3849 				    protocol);
3850 		}
3851 		free_opt(optlist);
3852 	} else {
3853 		(void) printf(gettext("Group \"%s\" not found\n"), groupname);
3854 		ret = SA_NO_SUCH_GROUP;
3855 	}
3856 
3857 	/*
3858 	 * We have a group and potentially legal additions.
3859 	 */
3860 
3861 	/* Commit to configuration if not a dryrun */
3862 	if (!dryrun && ret == 0) {
3863 		if (change && worklist != NULL) {
3864 			/* properties changed, so update all shares */
3865 			(void) enable_all_groups(handle, worklist, 0, 0,
3866 			    protocol, B_TRUE);
3867 		}
3868 		ret = sa_update_config(handle);
3869 	}
3870 	if (worklist != NULL)
3871 		free_list(worklist);
3872 	return (ret);
3873 }
3874 
3875 /*
3876  * sa_set(flags, argc, argv)
3877  *
3878  * Implements the set subcommand. It keys off of -S to determine which
3879  * set of operations to actually do.
3880  */
3881 
3882 int
sa_set(sa_handle_t handle,int flags,int argc,char * argv[])3883 sa_set(sa_handle_t handle, int flags, int argc, char *argv[])
3884 {
3885 	char *groupname;
3886 	int verbose = 0;
3887 	int dryrun = 0;
3888 	int c;
3889 	char *protocol = NULL;
3890 	int ret = SA_OK;
3891 	struct options *optlist = NULL;
3892 	char *rsrcname = NULL;
3893 	char *sharepath = NULL;
3894 	char *optset = NULL;
3895 	int auth;
3896 
3897 	while ((c = getopt(argc, argv, "?hvnP:p:r:s:S:")) != EOF) {
3898 		switch (c) {
3899 		case 'v':
3900 			verbose++;
3901 			break;
3902 		case 'n':
3903 			dryrun++;
3904 			break;
3905 		case 'P':
3906 			if (protocol != NULL) {
3907 				(void) printf(gettext(
3908 				    "Specifying multiple protocols "
3909 				    "not supported: %s\n"), protocol);
3910 				return (SA_SYNTAX_ERR);
3911 			}
3912 			protocol = optarg;
3913 			if (!sa_valid_protocol(protocol)) {
3914 				(void) printf(gettext(
3915 				    "Invalid protocol specified: %s\n"),
3916 				    protocol);
3917 				return (SA_INVALID_PROTOCOL);
3918 			}
3919 			break;
3920 		case 'p':
3921 			ret = add_opt(&optlist, optarg, 0);
3922 			switch (ret) {
3923 			case OPT_ADD_SYNTAX:
3924 				(void) printf(gettext("Property syntax error:"
3925 				    " %s\n"), optarg);
3926 				return (SA_SYNTAX_ERR);
3927 			case OPT_ADD_MEMORY:
3928 				(void) printf(gettext("No memory to set "
3929 				    "property: %s\n"), optarg);
3930 				return (SA_NO_MEMORY);
3931 			default:
3932 				break;
3933 			}
3934 			break;
3935 		case 'r':
3936 			if (rsrcname != NULL) {
3937 				(void) printf(gettext(
3938 				    "Setting multiple resource names not"
3939 				    " supported\n"));
3940 				return (SA_SYNTAX_ERR);
3941 			}
3942 			rsrcname = optarg;
3943 			break;
3944 		case 's':
3945 			if (sharepath != NULL) {
3946 				(void) printf(gettext(
3947 				    "Setting multiple shares not supported\n"));
3948 				return (SA_SYNTAX_ERR);
3949 			}
3950 			sharepath = optarg;
3951 			break;
3952 		case 'S':
3953 			if (optset != NULL) {
3954 				(void) printf(gettext(
3955 				    "Specifying multiple property "
3956 				    "spaces not supported: %s\n"), optset);
3957 				return (SA_SYNTAX_ERR);
3958 			}
3959 			optset = optarg;
3960 			break;
3961 		case 'h':
3962 			/* optopt on valid arg isn't defined */
3963 			optopt = c;
3964 			/*FALLTHROUGH*/
3965 		case '?':
3966 		default:
3967 			/*
3968 			 * Since a bad option gets to here, sort it
3969 			 * out and return a syntax error return value
3970 			 * if necessary.
3971 			 */
3972 			switch (optopt) {
3973 			default:
3974 				ret = SA_SYNTAX_ERR;
3975 				break;
3976 			case 'h':
3977 			case '?':
3978 				break;
3979 			}
3980 			(void) printf(gettext("usage: %s\n"),
3981 			    sa_get_usage(USAGE_SET));
3982 			return (ret);
3983 		}
3984 	}
3985 
3986 	if (optlist != NULL)
3987 		ret = chk_opt(optlist, optset != NULL, protocol);
3988 
3989 	if (optind >= argc || (optlist == NULL && optset == NULL) ||
3990 	    protocol == NULL || ret != OPT_ADD_OK) {
3991 		char *sep = "\t";
3992 
3993 		(void) printf(gettext("usage: %s\n"), sa_get_usage(USAGE_SET));
3994 		if (optind >= argc) {
3995 			(void) printf(gettext("%sgroup must be specified"),
3996 			    sep);
3997 			sep = ", ";
3998 		}
3999 		if (optlist == NULL) {
4000 			(void) printf(gettext("%sat least one property must be"
4001 			    " specified"), sep);
4002 			sep = ", ";
4003 		}
4004 		if (protocol == NULL) {
4005 			(void) printf(gettext("%sprotocol must be specified"),
4006 			    sep);
4007 			sep = ", ";
4008 		}
4009 		(void) printf("\n");
4010 		ret = SA_SYNTAX_ERR;
4011 	} else {
4012 		/*
4013 		 * Group already exists so we can proceed after a few
4014 		 * additional checks related to ZFS handling.
4015 		 */
4016 
4017 		groupname = argv[optind];
4018 		if (strcmp(groupname, "zfs") == 0) {
4019 			(void) printf(gettext("Changing properties for group "
4020 			    "\"zfs\" not allowed\n"));
4021 			return (SA_NOT_ALLOWED);
4022 		}
4023 
4024 		auth = check_authorizations(groupname, flags);
4025 		if (optset == NULL)
4026 			ret = basic_set(handle, groupname, optlist, protocol,
4027 			    sharepath, rsrcname, dryrun);
4028 		else
4029 			ret = space_set(handle, groupname, optlist, protocol,
4030 			    sharepath, dryrun, optset);
4031 		if (dryrun && ret == SA_OK && !auth && verbose) {
4032 			(void) printf(gettext("Command would fail: %s\n"),
4033 			    sa_errorstr(SA_NO_PERMISSION));
4034 		}
4035 	}
4036 	return (ret);
4037 }
4038 
4039 /*
4040  * remove_options(group, optlist, proto, *err)
4041  *
4042  * Helper function to actually remove options from a group after all
4043  * preprocessing is done.
4044  */
4045 
4046 static int
remove_options(sa_group_t group,struct options * optlist,char * proto,int * err)4047 remove_options(sa_group_t group, struct options *optlist,
4048     char *proto, int *err)
4049 {
4050 	struct options *cur;
4051 	sa_optionset_t optionset;
4052 	sa_property_t prop;
4053 	int change = 0;
4054 	int ret = SA_OK;
4055 
4056 	optionset = sa_get_optionset(group, proto);
4057 	if (optionset != NULL) {
4058 		for (cur = optlist; cur != NULL; cur = cur->next) {
4059 			prop = sa_get_property(optionset, cur->optname);
4060 			if (prop != NULL) {
4061 				ret = sa_remove_property(prop);
4062 				if (ret != SA_OK)
4063 					break;
4064 				change = 1;
4065 			}
4066 		}
4067 	}
4068 	if (ret == SA_OK && change)
4069 		ret = sa_commit_properties(optionset, 0);
4070 
4071 	if (err != NULL)
4072 		*err = ret;
4073 	return (change);
4074 }
4075 
4076 /*
4077  * valid_unset(group, optlist, proto)
4078  *
4079  * Sanity check the optlist to make sure they can be removed. Issue an
4080  * error if a property doesn't exist.
4081  */
4082 
4083 static int
valid_unset(sa_group_t group,struct options * optlist,char * proto)4084 valid_unset(sa_group_t group, struct options *optlist, char *proto)
4085 {
4086 	struct options *cur;
4087 	sa_optionset_t optionset;
4088 	sa_property_t prop;
4089 	int ret = SA_OK;
4090 
4091 	optionset = sa_get_optionset(group, proto);
4092 	if (optionset != NULL) {
4093 		for (cur = optlist; cur != NULL; cur = cur->next) {
4094 			prop = sa_get_property(optionset, cur->optname);
4095 			if (prop == NULL) {
4096 				(void) printf(gettext(
4097 				    "Could not unset property %s: not set\n"),
4098 				    cur->optname);
4099 				ret = SA_NO_SUCH_PROP;
4100 			}
4101 		}
4102 	}
4103 	return (ret);
4104 }
4105 
4106 /*
4107  * valid_unset_security(group, optlist, proto)
4108  *
4109  * Sanity check the optlist to make sure they can be removed. Issue an
4110  * error if a property doesn't exist.
4111  */
4112 
4113 static int
valid_unset_security(sa_group_t group,struct options * optlist,char * proto,char * sectype)4114 valid_unset_security(sa_group_t group, struct options *optlist, char *proto,
4115     char *sectype)
4116 {
4117 	struct options *cur;
4118 	sa_security_t security;
4119 	sa_property_t prop;
4120 	int ret = SA_OK;
4121 	char *sec;
4122 
4123 	sec = sa_proto_space_alias(proto, sectype);
4124 	security = sa_get_security(group, sec, proto);
4125 	if (security != NULL) {
4126 		for (cur = optlist; cur != NULL; cur = cur->next) {
4127 			prop = sa_get_property(security, cur->optname);
4128 			if (prop == NULL) {
4129 				(void) printf(gettext(
4130 				    "Could not unset property %s: not set\n"),
4131 				    cur->optname);
4132 				ret = SA_NO_SUCH_PROP;
4133 			}
4134 		}
4135 	} else {
4136 		(void) printf(gettext(
4137 		    "Could not unset %s: space not defined\n"), sectype);
4138 		ret = SA_NO_SUCH_SECURITY;
4139 	}
4140 	if (sec != NULL)
4141 		sa_free_attr_string(sec);
4142 	return (ret);
4143 }
4144 
4145 /*
4146  * remove_security(group, optlist, proto)
4147  *
4148  * Remove the properties since they were checked as valid.
4149  */
4150 
4151 static int
remove_security(sa_group_t group,char * sectype,struct options * optlist,char * proto,int * err)4152 remove_security(sa_group_t group, char *sectype,
4153     struct options *optlist, char *proto, int *err)
4154 {
4155 	sa_security_t security;
4156 	int ret = SA_OK;
4157 	int change = 0;
4158 
4159 	sectype = sa_proto_space_alias(proto, sectype);
4160 	security = sa_get_security(group, sectype, proto);
4161 	if (sectype != NULL)
4162 		sa_free_attr_string(sectype);
4163 
4164 	if (security != NULL) {
4165 		while (optlist != NULL) {
4166 			sa_property_t prop;
4167 			prop = sa_get_property(security, optlist->optname);
4168 			if (prop != NULL) {
4169 				ret = sa_remove_property(prop);
4170 				if (ret != SA_OK)
4171 					break;
4172 				change = 1;
4173 			}
4174 			optlist = optlist->next;
4175 		}
4176 		/*
4177 		 * when done, properties may have all been removed but
4178 		 * we need to keep the security type itself until
4179 		 * explicitly removed.
4180 		 */
4181 		if (ret == SA_OK && change)
4182 			ret = sa_commit_properties(security, 0);
4183 	} else {
4184 		ret = SA_NO_SUCH_PROP;
4185 	}
4186 	if (err != NULL)
4187 		*err = ret;
4188 	return (change);
4189 }
4190 
4191 /*
4192  * basic_unset(groupname, optlist, protocol, sharepath, rsrcname, dryrun)
4193  *
4194  * Unset non-named optionset properties.
4195  */
4196 
4197 static int
basic_unset(sa_handle_t handle,char * groupname,struct options * optlist,char * protocol,char * sharepath,char * rsrcname,int dryrun)4198 basic_unset(sa_handle_t handle, char *groupname, struct options *optlist,
4199     char *protocol, char *sharepath, char *rsrcname, int dryrun)
4200 {
4201 	sa_group_t group;
4202 	int ret = SA_OK;
4203 	int change = 0;
4204 	struct list *worklist = NULL;
4205 	sa_share_t share = NULL;
4206 	sa_resource_t resource = NULL;
4207 
4208 	group = sa_get_group(handle, groupname);
4209 	if (group == NULL)
4210 		return (ret);
4211 
4212 	/*
4213 	 * If there is a sharepath, make sure it belongs to
4214 	 * the group.
4215 	 */
4216 	if (sharepath != NULL) {
4217 		share = sa_get_share(group, sharepath);
4218 		if (share == NULL) {
4219 			(void) printf(gettext(
4220 			    "Share does not exist in group %s\n"),
4221 			    groupname, sharepath);
4222 			ret = SA_NO_SUCH_PATH;
4223 		}
4224 	}
4225 	/*
4226 	 * If a resource name exists, make sure it belongs to
4227 	 * the share if present else it belongs to the
4228 	 * group. Also check the protocol to see if it
4229 	 * supports resource level properties or not. If not,
4230 	 * use share only.
4231 	 */
4232 	if (rsrcname != NULL) {
4233 		if (share != NULL) {
4234 			resource = sa_get_share_resource(share, rsrcname);
4235 			if (resource == NULL)
4236 				ret = SA_NO_SUCH_RESOURCE;
4237 		} else {
4238 			resource = sa_get_resource(group, rsrcname);
4239 			if (resource != NULL) {
4240 				share = sa_get_resource_parent(resource);
4241 			} else {
4242 				ret = SA_NO_SUCH_RESOURCE;
4243 			}
4244 		}
4245 		if (ret == SA_OK && resource != NULL) {
4246 			uint64_t features;
4247 			/*
4248 			 * Check to see if the resource can take
4249 			 * properties. If so, stick the resource into
4250 			 * "share" so it will all just work.
4251 			 */
4252 			features = sa_proto_get_featureset(protocol);
4253 			if (features & SA_FEATURE_RESOURCE)
4254 				share = (sa_share_t)resource;
4255 		}
4256 	}
4257 
4258 	if (ret == SA_OK) {
4259 		/* group must exist */
4260 		ret = valid_unset(share != NULL ? share : group,
4261 		    optlist, protocol);
4262 		if (ret == SA_OK && !dryrun) {
4263 			if (share != NULL) {
4264 				sa_optionset_t optionset;
4265 				sa_property_t prop;
4266 				change |= remove_options(share, optlist,
4267 				    protocol, &ret);
4268 				/*
4269 				 * If a share optionset is
4270 				 * empty, remove it.
4271 				 */
4272 				optionset = sa_get_optionset((sa_share_t)share,
4273 				    protocol);
4274 				if (optionset != NULL) {
4275 					prop = sa_get_property(optionset, NULL);
4276 					if (prop == NULL)
4277 						(void) sa_destroy_optionset(
4278 						    optionset);
4279 				}
4280 			} else {
4281 				change |= remove_options(group,
4282 				    optlist, protocol, &ret);
4283 			}
4284 			if (ret == SA_OK && change)
4285 				worklist = add_list(worklist, group, share,
4286 				    protocol);
4287 			if (ret != SA_OK)
4288 				(void) printf(gettext(
4289 				    "Could not remove properties: "
4290 				    "%s\n"), sa_errorstr(ret));
4291 		}
4292 	} else {
4293 		(void) printf(gettext("Group \"%s\" not found\n"), groupname);
4294 		ret = SA_NO_SUCH_GROUP;
4295 	}
4296 	free_opt(optlist);
4297 
4298 	/*
4299 	 * We have a group and potentially legal additions
4300 	 *
4301 	 * Commit to configuration if not a dryrun
4302 	 */
4303 	if (!dryrun && ret == SA_OK) {
4304 		if (change && worklist != NULL) {
4305 			/* properties changed, so update all shares */
4306 			(void) enable_all_groups(handle, worklist, 0, 0,
4307 			    protocol, B_TRUE);
4308 		}
4309 	}
4310 	if (worklist != NULL)
4311 		free_list(worklist);
4312 	return (ret);
4313 }
4314 
4315 /*
4316  * space_unset(groupname, optlist, protocol, sharepath, dryrun)
4317  *
4318  * Unset named optionset properties.
4319  */
4320 static int
space_unset(sa_handle_t handle,char * groupname,struct options * optlist,char * protocol,char * sharepath,int dryrun,char * sectype)4321 space_unset(sa_handle_t handle, char *groupname, struct options *optlist,
4322     char *protocol, char *sharepath, int dryrun, char *sectype)
4323 {
4324 	sa_group_t group;
4325 	int ret = SA_OK;
4326 	int change = 0;
4327 	struct list *worklist = NULL;
4328 	sa_share_t share = NULL;
4329 
4330 	group = sa_get_group(handle, groupname);
4331 	if (group == NULL) {
4332 		(void) printf(gettext("Group \"%s\" not found\n"), groupname);
4333 		return (SA_NO_SUCH_GROUP);
4334 	}
4335 	if (sharepath != NULL) {
4336 		share = sa_get_share(group, sharepath);
4337 		if (share == NULL) {
4338 			(void) printf(gettext(
4339 			    "Share does not exist in group %s\n"),
4340 			    groupname, sharepath);
4341 			return (SA_NO_SUCH_PATH);
4342 		}
4343 	}
4344 	ret = valid_unset_security(share != NULL ? share : group,
4345 	    optlist, protocol, sectype);
4346 
4347 	if (ret == SA_OK && !dryrun) {
4348 		if (optlist != NULL) {
4349 			if (share != NULL) {
4350 				sa_security_t optionset;
4351 				sa_property_t prop;
4352 				change = remove_security(share,
4353 				    sectype, optlist, protocol, &ret);
4354 
4355 				/* If a share security is empty, remove it */
4356 				optionset = sa_get_security((sa_group_t)share,
4357 				    sectype, protocol);
4358 				if (optionset != NULL) {
4359 					prop = sa_get_property(optionset,
4360 					    NULL);
4361 					if (prop == NULL)
4362 						ret = sa_destroy_security(
4363 						    optionset);
4364 				}
4365 			} else {
4366 				change = remove_security(group, sectype,
4367 				    optlist, protocol, &ret);
4368 			}
4369 		} else {
4370 			sa_security_t security;
4371 			char *sec;
4372 			sec = sa_proto_space_alias(protocol, sectype);
4373 			security = sa_get_security(group, sec, protocol);
4374 			if (sec != NULL)
4375 				sa_free_attr_string(sec);
4376 			if (security != NULL) {
4377 				ret = sa_destroy_security(security);
4378 				if (ret == SA_OK)
4379 					change = 1;
4380 			} else {
4381 				ret = SA_NO_SUCH_PROP;
4382 			}
4383 		}
4384 		if (ret != SA_OK)
4385 			(void) printf(gettext("Could not unset property: %s\n"),
4386 			    sa_errorstr(ret));
4387 	}
4388 
4389 	if (ret == SA_OK && change)
4390 		worklist = add_list(worklist, group, 0, protocol);
4391 
4392 	free_opt(optlist);
4393 	/*
4394 	 * We have a group and potentially legal additions
4395 	 */
4396 
4397 	/* Commit to configuration if not a dryrun */
4398 	if (!dryrun && ret == 0) {
4399 		/* properties changed, so update all shares */
4400 		if (change && worklist != NULL)
4401 			(void) enable_all_groups(handle, worklist, 0, 0,
4402 			    protocol, B_TRUE);
4403 		ret = sa_update_config(handle);
4404 	}
4405 	if (worklist != NULL)
4406 		free_list(worklist);
4407 	return (ret);
4408 }
4409 
4410 /*
4411  * sa_unset(flags, argc, argv)
4412  *
4413  * Implements the unset subcommand. Parsing done here and then basic
4414  * or space versions of the real code are called.
4415  */
4416 
4417 int
sa_unset(sa_handle_t handle,int flags,int argc,char * argv[])4418 sa_unset(sa_handle_t handle, int flags, int argc, char *argv[])
4419 {
4420 	char *groupname;
4421 	int verbose = 0;
4422 	int dryrun = 0;
4423 	int c;
4424 	char *protocol = NULL;
4425 	int ret = SA_OK;
4426 	struct options *optlist = NULL;
4427 	char *rsrcname = NULL;
4428 	char *sharepath = NULL;
4429 	char *optset = NULL;
4430 	int auth;
4431 
4432 	while ((c = getopt(argc, argv, "?hvnP:p:r:s:S:")) != EOF) {
4433 		switch (c) {
4434 		case 'v':
4435 			verbose++;
4436 			break;
4437 		case 'n':
4438 			dryrun++;
4439 			break;
4440 		case 'P':
4441 			if (protocol != NULL) {
4442 				(void) printf(gettext(
4443 				    "Specifying multiple protocols "
4444 				    "not supported: %s\n"), protocol);
4445 				return (SA_SYNTAX_ERR);
4446 			}
4447 			protocol = optarg;
4448 			if (!sa_valid_protocol(protocol)) {
4449 				(void) printf(gettext(
4450 				    "Invalid protocol specified: %s\n"),
4451 				    protocol);
4452 				return (SA_INVALID_PROTOCOL);
4453 			}
4454 			break;
4455 		case 'p':
4456 			ret = add_opt(&optlist, optarg, 1);
4457 			switch (ret) {
4458 			case OPT_ADD_SYNTAX:
4459 				(void) printf(gettext("Property syntax error "
4460 				    "for property %s\n"), optarg);
4461 				return (SA_SYNTAX_ERR);
4462 
4463 			case OPT_ADD_PROPERTY:
4464 				(void) printf(gettext("Properties need to be "
4465 				    "set with set command: %s\n"), optarg);
4466 				return (SA_SYNTAX_ERR);
4467 
4468 			default:
4469 				break;
4470 			}
4471 			break;
4472 		case 'r':
4473 			/*
4474 			 * Unset properties on resource if applicable or on
4475 			 * share if resource for this protocol doesn't use
4476 			 * resources.
4477 			 */
4478 			if (rsrcname != NULL) {
4479 				(void) printf(gettext(
4480 				    "Unsetting multiple resource "
4481 				    "names not supported\n"));
4482 				return (SA_SYNTAX_ERR);
4483 			}
4484 			rsrcname = optarg;
4485 			break;
4486 		case 's':
4487 			if (sharepath != NULL) {
4488 				(void) printf(gettext(
4489 				    "Adding multiple shares not supported\n"));
4490 				return (SA_SYNTAX_ERR);
4491 			}
4492 			sharepath = optarg;
4493 			break;
4494 		case 'S':
4495 			if (optset != NULL) {
4496 				(void) printf(gettext(
4497 				    "Specifying multiple property "
4498 				    "spaces not supported: %s\n"), optset);
4499 				return (SA_SYNTAX_ERR);
4500 			}
4501 			optset = optarg;
4502 			break;
4503 		case 'h':
4504 			/* optopt on valid arg isn't defined */
4505 			optopt = c;
4506 			/*FALLTHROUGH*/
4507 		case '?':
4508 		default:
4509 			/*
4510 			 * Since a bad option gets to here, sort it
4511 			 * out and return a syntax error return value
4512 			 * if necessary.
4513 			 */
4514 			switch (optopt) {
4515 			default:
4516 				ret = SA_SYNTAX_ERR;
4517 				break;
4518 			case 'h':
4519 			case '?':
4520 				break;
4521 			}
4522 			(void) printf(gettext("usage: %s\n"),
4523 			    sa_get_usage(USAGE_UNSET));
4524 			return (ret);
4525 		}
4526 	}
4527 
4528 	if (optlist != NULL)
4529 		ret = chk_opt(optlist, optset != NULL, protocol);
4530 
4531 	if (optind >= argc || (optlist == NULL && optset == NULL) ||
4532 	    protocol == NULL) {
4533 		char *sep = "\t";
4534 		(void) printf(gettext("usage: %s\n"),
4535 		    sa_get_usage(USAGE_UNSET));
4536 		if (optind >= argc) {
4537 			(void) printf(gettext("%sgroup must be specified"),
4538 			    sep);
4539 			sep = ", ";
4540 		}
4541 		if (optlist == NULL) {
4542 			(void) printf(gettext("%sat least one property must "
4543 			    "be specified"), sep);
4544 			sep = ", ";
4545 		}
4546 		if (protocol == NULL) {
4547 			(void) printf(gettext("%sprotocol must be specified"),
4548 			    sep);
4549 			sep = ", ";
4550 		}
4551 		(void) printf("\n");
4552 		ret = SA_SYNTAX_ERR;
4553 	} else {
4554 
4555 		/*
4556 		 * If a group already exists, we can only add a new
4557 		 * protocol to it and not create a new one or add the
4558 		 * same protocol again.
4559 		 */
4560 
4561 		groupname = argv[optind];
4562 		auth = check_authorizations(groupname, flags);
4563 		if (optset == NULL)
4564 			ret = basic_unset(handle, groupname, optlist, protocol,
4565 			    sharepath, rsrcname, dryrun);
4566 		else
4567 			ret = space_unset(handle, groupname, optlist, protocol,
4568 			    sharepath, dryrun, optset);
4569 
4570 		if (dryrun && ret == SA_OK && !auth && verbose)
4571 			(void) printf(gettext("Command would fail: %s\n"),
4572 			    sa_errorstr(SA_NO_PERMISSION));
4573 	}
4574 	return (ret);
4575 }
4576 
4577 /*
4578  * sa_enable_group(flags, argc, argv)
4579  *
4580  * Implements the enable subcommand
4581  */
4582 
4583 int
sa_enable_group(sa_handle_t handle,int flags,int argc,char * argv[])4584 sa_enable_group(sa_handle_t handle, int flags, int argc, char *argv[])
4585 {
4586 	int verbose = 0;
4587 	int dryrun = 0;
4588 	int all = 0;
4589 	int c;
4590 	int ret = SA_OK;
4591 	char *protocol = NULL;
4592 	char *state;
4593 	struct list *worklist = NULL;
4594 	int auth = 1;
4595 	sa_group_t group;
4596 
4597 	while ((c = getopt(argc, argv, "?havnP:")) != EOF) {
4598 		switch (c) {
4599 		case 'a':
4600 			all = 1;
4601 			break;
4602 		case 'n':
4603 			dryrun++;
4604 			break;
4605 		case 'P':
4606 			if (protocol != NULL) {
4607 				(void) printf(gettext(
4608 				    "Specifying multiple protocols "
4609 				    "not supported: %s\n"), protocol);
4610 				return (SA_SYNTAX_ERR);
4611 			}
4612 			protocol = optarg;
4613 			if (!sa_valid_protocol(protocol)) {
4614 				(void) printf(gettext(
4615 				    "Invalid protocol specified: %s\n"),
4616 				    protocol);
4617 				return (SA_INVALID_PROTOCOL);
4618 			}
4619 			break;
4620 		case 'v':
4621 			verbose++;
4622 			break;
4623 		case 'h':
4624 			/* optopt on valid arg isn't defined */
4625 			optopt = c;
4626 			/*FALLTHROUGH*/
4627 		case '?':
4628 		default:
4629 			/*
4630 			 * Since a bad option gets to here, sort it
4631 			 * out and return a syntax error return value
4632 			 * if necessary.
4633 			 */
4634 			switch (optopt) {
4635 			default:
4636 				ret = SA_SYNTAX_ERR;
4637 				break;
4638 			case 'h':
4639 			case '?':
4640 				(void) printf(gettext("usage: %s\n"),
4641 				    sa_get_usage(USAGE_ENABLE));
4642 				return (ret);
4643 			}
4644 		}
4645 	}
4646 
4647 	if (optind == argc && !all) {
4648 		(void) printf(gettext("usage: %s\n"),
4649 		    sa_get_usage(USAGE_ENABLE));
4650 		(void) printf(gettext("\tmust specify group\n"));
4651 		return (SA_NO_SUCH_PATH);
4652 	}
4653 	if (!all) {
4654 		while (optind < argc) {
4655 			group = sa_get_group(handle, argv[optind]);
4656 			if (group != NULL) {
4657 				auth &= check_authorizations(argv[optind],
4658 				    flags);
4659 				state = sa_get_group_attr(group, "state");
4660 				if (state != NULL &&
4661 				    strcmp(state, "enabled") == 0) {
4662 					/* already enabled */
4663 					if (verbose)
4664 						(void) printf(gettext(
4665 						    "Group \"%s\" is already "
4666 						    "enabled\n"),
4667 						    argv[optind]);
4668 					ret = SA_BUSY; /* already enabled */
4669 				} else {
4670 					worklist = add_list(worklist, group,
4671 					    0, protocol);
4672 					if (verbose)
4673 						(void) printf(gettext(
4674 						    "Enabling group \"%s\"\n"),
4675 						    argv[optind]);
4676 				}
4677 				if (state != NULL)
4678 					sa_free_attr_string(state);
4679 			} else {
4680 				ret = SA_NO_SUCH_GROUP;
4681 			}
4682 			optind++;
4683 		}
4684 	} else {
4685 		for (group = sa_get_group(handle, NULL);
4686 		    group != NULL;
4687 		    group = sa_get_next_group(group)) {
4688 			worklist = add_list(worklist, group, 0, protocol);
4689 		}
4690 	}
4691 	if (!dryrun && ret == SA_OK)
4692 		ret = enable_all_groups(handle, worklist, 1, 0, NULL, B_FALSE);
4693 
4694 	if (ret != SA_OK && ret != SA_BUSY)
4695 		(void) printf(gettext("Could not enable group: %s\n"),
4696 		    sa_errorstr(ret));
4697 	if (ret == SA_BUSY)
4698 		ret = SA_OK;
4699 
4700 	if (worklist != NULL)
4701 		free_list(worklist);
4702 	if (dryrun && ret == SA_OK && !auth && verbose) {
4703 		(void) printf(gettext("Command would fail: %s\n"),
4704 		    sa_errorstr(SA_NO_PERMISSION));
4705 	}
4706 	return (ret);
4707 }
4708 
4709 /*
4710  * disable_group(group, proto)
4711  *
4712  * Disable all the shares in the specified group.. This is a helper
4713  * for disable_all_groups in order to simplify regular and subgroup
4714  * (zfs) disabling. Group has already been checked for non-NULL.
4715  */
4716 
4717 static int
disable_group(sa_group_t group,char * proto)4718 disable_group(sa_group_t group, char *proto)
4719 {
4720 	sa_share_t share;
4721 	int ret = SA_OK;
4722 
4723 	/*
4724 	 * If the protocol isn't enabled, skip it and treat as
4725 	 * successful.
4726 	 */
4727 	if (!has_protocol(group, proto))
4728 		return (ret);
4729 
4730 	for (share = sa_get_share(group, NULL);
4731 	    share != NULL && ret == SA_OK;
4732 	    share = sa_get_next_share(share)) {
4733 		ret = sa_disable_share(share, proto);
4734 		if (ret == SA_NO_SUCH_PATH) {
4735 			/*
4736 			 * this is OK since the path is gone. we can't
4737 			 * re-share it anyway so no error.
4738 			 */
4739 			ret = SA_OK;
4740 		}
4741 	}
4742 	return (ret);
4743 }
4744 
4745 /*
4746  * disable_all_groups(work, setstate)
4747  *
4748  * helper function that disables the shares in the list of groups
4749  * provided. It optionally marks the group as disabled. Used by both
4750  * enable and start subcommands.
4751  */
4752 
4753 static int
disable_all_groups(sa_handle_t handle,struct list * work,int setstate)4754 disable_all_groups(sa_handle_t handle, struct list *work, int setstate)
4755 {
4756 	int ret = SA_OK;
4757 	sa_group_t subgroup, group;
4758 
4759 	while (work != NULL && ret == SA_OK) {
4760 		group = (sa_group_t)work->item;
4761 		if (setstate)
4762 			ret = sa_set_group_attr(group, "state", "disabled");
4763 		if (ret == SA_OK) {
4764 			char *name;
4765 			name = sa_get_group_attr(group, "name");
4766 			if (name != NULL && strcmp(name, "zfs") == 0) {
4767 				/* need to get the sub-groups for stopping */
4768 				for (subgroup = sa_get_sub_group(group);
4769 				    subgroup != NULL;
4770 				    subgroup = sa_get_next_group(subgroup)) {
4771 					ret = disable_group(subgroup,
4772 					    work->proto);
4773 				}
4774 			} else {
4775 				ret = disable_group(group, work->proto);
4776 			}
4777 			if (name != NULL)
4778 				sa_free_attr_string(name);
4779 			/*
4780 			 * We don't want to "disable" since it won't come
4781 			 * up after a reboot.  The SMF framework should do
4782 			 * the right thing. On enable we do want to do
4783 			 * something.
4784 			 */
4785 		}
4786 		work = work->next;
4787 	}
4788 	if (ret == SA_OK)
4789 		ret = sa_update_config(handle);
4790 	return (ret);
4791 }
4792 
4793 /*
4794  * sa_disable_group(flags, argc, argv)
4795  *
4796  * Implements the disable subcommand
4797  */
4798 
4799 int
sa_disable_group(sa_handle_t handle,int flags,int argc,char * argv[])4800 sa_disable_group(sa_handle_t handle, int flags, int argc, char *argv[])
4801 {
4802 	int verbose = 0;
4803 	int dryrun = 0;
4804 	int all = 0;
4805 	int c;
4806 	int ret = SA_OK;
4807 	char *protocol = NULL;
4808 	char *state;
4809 	struct list *worklist = NULL;
4810 	sa_group_t group;
4811 	int auth = 1;
4812 
4813 	while ((c = getopt(argc, argv, "?havn")) != EOF) {
4814 		switch (c) {
4815 		case 'a':
4816 			all = 1;
4817 			break;
4818 		case 'n':
4819 			dryrun++;
4820 			break;
4821 		case 'P':
4822 			if (protocol != NULL) {
4823 				(void) printf(gettext(
4824 				    "Specifying multiple protocols "
4825 				    "not supported: %s\n"), protocol);
4826 				return (SA_SYNTAX_ERR);
4827 			}
4828 			protocol = optarg;
4829 			if (!sa_valid_protocol(protocol)) {
4830 				(void) printf(gettext(
4831 				    "Invalid protocol specified: %s\n"),
4832 				    protocol);
4833 				return (SA_INVALID_PROTOCOL);
4834 			}
4835 			break;
4836 		case 'v':
4837 			verbose++;
4838 			break;
4839 		case 'h':
4840 			/* optopt on valid arg isn't defined */
4841 			optopt = c;
4842 			/*FALLTHROUGH*/
4843 		case '?':
4844 		default:
4845 			/*
4846 			 * Since a bad option gets to here, sort it
4847 			 * out and return a syntax error return value
4848 			 * if necessary.
4849 			 */
4850 			switch (optopt) {
4851 			default:
4852 				ret = SA_SYNTAX_ERR;
4853 				break;
4854 			case 'h':
4855 			case '?':
4856 				break;
4857 			}
4858 			(void) printf(gettext("usage: %s\n"),
4859 			    sa_get_usage(USAGE_DISABLE));
4860 			return (ret);
4861 		}
4862 	}
4863 
4864 	if (optind == argc && !all) {
4865 		(void) printf(gettext("usage: %s\n"),
4866 		    sa_get_usage(USAGE_DISABLE));
4867 		(void) printf(gettext("\tmust specify group\n"));
4868 		return (SA_NO_SUCH_PATH);
4869 	}
4870 	if (!all) {
4871 		while (optind < argc) {
4872 			group = sa_get_group(handle, argv[optind]);
4873 			if (group != NULL) {
4874 				auth &= check_authorizations(argv[optind],
4875 				    flags);
4876 				state = sa_get_group_attr(group, "state");
4877 				if (state == NULL ||
4878 				    strcmp(state, "disabled") == 0) {
4879 					/* already disabled */
4880 					if (verbose)
4881 						(void) printf(gettext(
4882 						    "Group \"%s\" is "
4883 						    "already disabled\n"),
4884 						    argv[optind]);
4885 					ret = SA_BUSY; /* already disabled */
4886 				} else {
4887 					worklist = add_list(worklist, group, 0,
4888 					    protocol);
4889 					if (verbose)
4890 						(void) printf(gettext(
4891 						    "Disabling group "
4892 						    "\"%s\"\n"), argv[optind]);
4893 				}
4894 				if (state != NULL)
4895 					sa_free_attr_string(state);
4896 			} else {
4897 				ret = SA_NO_SUCH_GROUP;
4898 			}
4899 			optind++;
4900 		}
4901 	} else {
4902 		for (group = sa_get_group(handle, NULL);
4903 		    group != NULL;
4904 		    group = sa_get_next_group(group))
4905 			worklist = add_list(worklist, group, 0, protocol);
4906 	}
4907 
4908 	if (ret == SA_OK && !dryrun)
4909 		ret = disable_all_groups(handle, worklist, 1);
4910 	if (ret != SA_OK && ret != SA_BUSY)
4911 		(void) printf(gettext("Could not disable group: %s\n"),
4912 		    sa_errorstr(ret));
4913 	if (ret == SA_BUSY)
4914 		ret = SA_OK;
4915 	if (worklist != NULL)
4916 		free_list(worklist);
4917 	if (dryrun && ret == SA_OK && !auth && verbose)
4918 		(void) printf(gettext("Command would fail: %s\n"),
4919 		    sa_errorstr(SA_NO_PERMISSION));
4920 	return (ret);
4921 }
4922 
4923 /*
4924  * sa_start_group(flags, argc, argv)
4925  *
4926  * Implements the start command.
4927  * This is similar to enable except it doesn't change the state
4928  * of the group(s) and only enables shares if the group is already
4929  * enabled.
4930  */
4931 
4932 int
sa_start_group(sa_handle_t handle,int flags,int argc,char * argv[])4933 sa_start_group(sa_handle_t handle, int flags, int argc, char *argv[])
4934 {
4935 	int verbose = 0;
4936 	int all = 0;
4937 	int c;
4938 	int ret = SMF_EXIT_OK;
4939 	char *protocol = NULL;
4940 	char *state;
4941 	struct list *worklist = NULL;
4942 	sa_group_t group;
4943 #ifdef lint
4944 	flags = flags;
4945 #endif
4946 
4947 	while ((c = getopt(argc, argv, "?havP:")) != EOF) {
4948 		switch (c) {
4949 		case 'a':
4950 			all = 1;
4951 			break;
4952 		case 'P':
4953 			if (protocol != NULL) {
4954 				(void) printf(gettext(
4955 				    "Specifying multiple protocols "
4956 				    "not supported: %s\n"), protocol);
4957 				return (SA_SYNTAX_ERR);
4958 			}
4959 			protocol = optarg;
4960 			if (!sa_valid_protocol(protocol)) {
4961 				(void) printf(gettext(
4962 				    "Invalid protocol specified: %s\n"),
4963 				    protocol);
4964 				return (SA_INVALID_PROTOCOL);
4965 			}
4966 			break;
4967 		case 'v':
4968 			verbose++;
4969 			break;
4970 		case 'h':
4971 			/* optopt on valid arg isn't defined */
4972 			optopt = c;
4973 			/*FALLTHROUGH*/
4974 		case '?':
4975 		default:
4976 			/*
4977 			 * Since a bad option gets to here, sort it
4978 			 * out and return a syntax error return value
4979 			 * if necessary.
4980 			 */
4981 			ret = SA_OK;
4982 			switch (optopt) {
4983 			default:
4984 				ret = SA_SYNTAX_ERR;
4985 				break;
4986 			case 'h':
4987 			case '?':
4988 				break;
4989 			}
4990 			(void) printf(gettext("usage: %s\n"),
4991 			    sa_get_usage(USAGE_START));
4992 			return (ret);
4993 		}
4994 	}
4995 
4996 	if (optind == argc && !all) {
4997 		(void) printf(gettext("usage: %s\n"),
4998 		    sa_get_usage(USAGE_START));
4999 		return (SMF_EXIT_ERR_FATAL);
5000 	}
5001 
5002 	if (!all) {
5003 		while (optind < argc) {
5004 			group = sa_get_group(handle, argv[optind]);
5005 			if (group != NULL) {
5006 				state = sa_get_group_attr(group, "state");
5007 				if (state == NULL ||
5008 				    strcmp(state, "enabled") == 0) {
5009 					worklist = add_list(worklist, group, 0,
5010 					    protocol);
5011 					if (verbose)
5012 						(void) printf(gettext(
5013 						    "Starting group \"%s\"\n"),
5014 						    argv[optind]);
5015 				} else {
5016 					/*
5017 					 * Determine if there are any
5018 					 * protocols.  If there aren't any,
5019 					 * then there isn't anything to do in
5020 					 * any case so no error.
5021 					 */
5022 					if (sa_get_optionset(group,
5023 					    protocol) != NULL) {
5024 						ret = SMF_EXIT_OK;
5025 					}
5026 				}
5027 				if (state != NULL)
5028 					sa_free_attr_string(state);
5029 			}
5030 			optind++;
5031 		}
5032 	} else {
5033 		for (group = sa_get_group(handle, NULL);
5034 		    group != NULL;
5035 		    group = sa_get_next_group(group)) {
5036 			state = sa_get_group_attr(group, "state");
5037 			if (state == NULL || strcmp(state, "enabled") == 0)
5038 				worklist = add_list(worklist, group, 0,
5039 				    protocol);
5040 			if (state != NULL)
5041 				sa_free_attr_string(state);
5042 		}
5043 	}
5044 
5045 	(void) enable_all_groups(handle, worklist, 0, 1, protocol, B_FALSE);
5046 
5047 	if (worklist != NULL)
5048 		free_list(worklist);
5049 	return (ret);
5050 }
5051 
5052 /*
5053  * sa_stop_group(flags, argc, argv)
5054  *
5055  * Implements the stop command.
5056  * This is similar to disable except it doesn't change the state
5057  * of the group(s) and only disables shares if the group is already
5058  * enabled.
5059  */
5060 int
sa_stop_group(sa_handle_t handle,int flags,int argc,char * argv[])5061 sa_stop_group(sa_handle_t handle, int flags, int argc, char *argv[])
5062 {
5063 	int verbose = 0;
5064 	int all = 0;
5065 	int c;
5066 	int ret = SMF_EXIT_OK;
5067 	char *protocol = NULL;
5068 	char *state;
5069 	struct list *worklist = NULL;
5070 	sa_group_t group;
5071 #ifdef lint
5072 	flags = flags;
5073 #endif
5074 
5075 	while ((c = getopt(argc, argv, "?havP:")) != EOF) {
5076 		switch (c) {
5077 		case 'a':
5078 			all = 1;
5079 			break;
5080 		case 'P':
5081 			if (protocol != NULL) {
5082 				(void) printf(gettext(
5083 				    "Specifying multiple protocols "
5084 				    "not supported: %s\n"), protocol);
5085 				return (SA_SYNTAX_ERR);
5086 			}
5087 			protocol = optarg;
5088 			if (!sa_valid_protocol(protocol)) {
5089 				(void) printf(gettext(
5090 				    "Invalid protocol specified: %s\n"),
5091 				    protocol);
5092 				return (SA_INVALID_PROTOCOL);
5093 			}
5094 			break;
5095 		case 'v':
5096 			verbose++;
5097 			break;
5098 		case 'h':
5099 			/* optopt on valid arg isn't defined */
5100 			optopt = c;
5101 			/*FALLTHROUGH*/
5102 		case '?':
5103 		default:
5104 			/*
5105 			 * Since a bad option gets to here, sort it
5106 			 * out and return a syntax error return value
5107 			 * if necessary.
5108 			 */
5109 			ret = SA_OK;
5110 			switch (optopt) {
5111 			default:
5112 				ret = SA_SYNTAX_ERR;
5113 				break;
5114 			case 'h':
5115 			case '?':
5116 				break;
5117 			}
5118 			(void) printf(gettext("usage: %s\n"),
5119 			    sa_get_usage(USAGE_STOP));
5120 			return (ret);
5121 		}
5122 	}
5123 
5124 	if (optind == argc && !all) {
5125 		(void) printf(gettext("usage: %s\n"),
5126 		    sa_get_usage(USAGE_STOP));
5127 		return (SMF_EXIT_ERR_FATAL);
5128 	} else if (!all) {
5129 		while (optind < argc) {
5130 			group = sa_get_group(handle, argv[optind]);
5131 			if (group != NULL) {
5132 				state = sa_get_group_attr(group, "state");
5133 				if (state == NULL ||
5134 				    strcmp(state, "enabled") == 0) {
5135 					worklist = add_list(worklist, group, 0,
5136 					    protocol);
5137 					if (verbose)
5138 						(void) printf(gettext(
5139 						    "Stopping group \"%s\"\n"),
5140 						    argv[optind]);
5141 				} else {
5142 					ret = SMF_EXIT_OK;
5143 				}
5144 				if (state != NULL)
5145 					sa_free_attr_string(state);
5146 			}
5147 			optind++;
5148 		}
5149 	} else {
5150 		for (group = sa_get_group(handle, NULL);
5151 		    group != NULL;
5152 		    group = sa_get_next_group(group)) {
5153 			state = sa_get_group_attr(group, "state");
5154 			if (state == NULL || strcmp(state, "enabled") == 0)
5155 				worklist = add_list(worklist, group, 0,
5156 				    protocol);
5157 			if (state != NULL)
5158 				sa_free_attr_string(state);
5159 		}
5160 	}
5161 	(void) disable_all_groups(handle, worklist, 0);
5162 	ret = sa_update_config(handle);
5163 
5164 	if (worklist != NULL)
5165 		free_list(worklist);
5166 	return (ret);
5167 }
5168 
5169 /*
5170  * remove_all_options(share, proto)
5171  *
5172  * Removes all options on a share.
5173  */
5174 
5175 static void
remove_all_options(sa_share_t share,char * proto)5176 remove_all_options(sa_share_t share, char *proto)
5177 {
5178 	sa_optionset_t optionset;
5179 	sa_security_t security;
5180 	sa_security_t prevsec = NULL;
5181 
5182 	optionset = sa_get_optionset(share, proto);
5183 	if (optionset != NULL)
5184 		(void) sa_destroy_optionset(optionset);
5185 	for (security = sa_get_security(share, NULL, NULL);
5186 	    security != NULL;
5187 	    security = sa_get_next_security(security)) {
5188 		char *type;
5189 		/*
5190 		 * We walk through the list.  prevsec keeps the
5191 		 * previous security so we can delete it without
5192 		 * destroying the list.
5193 		 */
5194 		if (prevsec != NULL) {
5195 			/* remove the previously seen security */
5196 			(void) sa_destroy_security(prevsec);
5197 			/* set to NULL so we don't try multiple times */
5198 			prevsec = NULL;
5199 		}
5200 		type = sa_get_security_attr(security, "type");
5201 		if (type != NULL) {
5202 			/*
5203 			 * if the security matches the specified protocol, we
5204 			 * want to remove it. prevsec holds it until either
5205 			 * the next pass or we fall out of the loop.
5206 			 */
5207 			if (strcmp(type, proto) == 0)
5208 				prevsec = security;
5209 			sa_free_attr_string(type);
5210 		}
5211 	}
5212 	/* in case there is one left */
5213 	if (prevsec != NULL)
5214 		(void) sa_destroy_security(prevsec);
5215 }
5216 
5217 
5218 /*
5219  * for legacy support, we need to handle the old syntax. This is what
5220  * we get if sharemgr is called with the name "share" rather than
5221  * sharemgr.
5222  */
5223 
5224 static int
format_legacy_path(char * buff,int buffsize,char * proto,char * cmd)5225 format_legacy_path(char *buff, int buffsize, char *proto, char *cmd)
5226 {
5227 	int err;
5228 
5229 	err = snprintf(buff, buffsize, "/usr/lib/fs/%s/%s", proto, cmd);
5230 	if (err > buffsize)
5231 		return (-1);
5232 	return (0);
5233 }
5234 
5235 
5236 /*
5237  * check_legacy_cmd(proto, cmd)
5238  *
5239  * Check to see if the cmd exists in /usr/lib/fs/<proto>/<cmd> and is
5240  * executable.
5241  */
5242 
5243 static int
check_legacy_cmd(char * path)5244 check_legacy_cmd(char *path)
5245 {
5246 	struct stat st;
5247 	int ret = 0;
5248 
5249 	if (stat(path, &st) == 0) {
5250 		if (S_ISREG(st.st_mode) &&
5251 		    st.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH))
5252 			ret = 1;
5253 	}
5254 	return (ret);
5255 }
5256 
5257 /*
5258  * run_legacy_command(proto, cmd, argv)
5259  *
5260  * We know the command exists, so attempt to execute it with all the
5261  * arguments. This implements full legacy share support for those
5262  * protocols that don't have plugin providers.
5263  */
5264 
5265 static int
run_legacy_command(char * path,char * argv[])5266 run_legacy_command(char *path, char *argv[])
5267 {
5268 	int ret;
5269 
5270 	ret = execv(path, argv);
5271 	if (ret < 0) {
5272 		switch (errno) {
5273 		case EACCES:
5274 			ret = SA_NO_PERMISSION;
5275 			break;
5276 		default:
5277 			ret = SA_SYSTEM_ERR;
5278 			break;
5279 		}
5280 	}
5281 	return (ret);
5282 }
5283 
5284 /*
5285  * out_share(out, group, proto)
5286  *
5287  * Display the share information in the format that the "share"
5288  * command has traditionally used.
5289  */
5290 
5291 static void
out_share(FILE * out,sa_group_t group,char * proto)5292 out_share(FILE *out, sa_group_t group, char *proto)
5293 {
5294 	sa_share_t share;
5295 	char resfmt[128];
5296 	char *defprop;
5297 
5298 	/*
5299 	 * The original share command defaulted to displaying NFS
5300 	 * shares or allowed a protocol to be specified. We want to
5301 	 * skip those shares that are not the specified protocol.
5302 	 */
5303 	if (proto != NULL && sa_get_optionset(group, proto) == NULL)
5304 		return;
5305 
5306 	if (proto == NULL)
5307 		proto = "nfs";
5308 
5309 	/*
5310 	 * get the default property string.  NFS uses "rw" but
5311 	 * everything else will use "".
5312 	 */
5313 	if (proto != NULL && strcmp(proto, "nfs") != 0)
5314 		defprop = "\"\"";
5315 	else
5316 		defprop = "rw";
5317 
5318 	for (share = sa_get_share(group, NULL);
5319 	    share != NULL;
5320 	    share = sa_get_next_share(share)) {
5321 		char *path;
5322 		char *type;
5323 		char *resource;
5324 		char *description;
5325 		char *groupname;
5326 		char *sharedstate;
5327 		int shared = 1;
5328 		char *soptions;
5329 		char shareopts[MAXNAMLEN];
5330 
5331 		sharedstate = sa_get_share_attr(share, "shared");
5332 		path = sa_get_share_attr(share, "path");
5333 		type = sa_get_share_attr(share, "type");
5334 		resource = get_resource(share);
5335 		groupname = sa_get_group_attr(group, "name");
5336 
5337 		if (groupname != NULL && strcmp(groupname, "default") == 0) {
5338 			sa_free_attr_string(groupname);
5339 			groupname = NULL;
5340 		}
5341 		description = sa_get_share_description(share);
5342 
5343 		/*
5344 		 * Want the sharetab version if it exists, defaulting
5345 		 * to NFS if no protocol specified.
5346 		 */
5347 		(void) snprintf(shareopts, MAXNAMLEN, "shareopts-%s", proto);
5348 		soptions = sa_get_share_attr(share, shareopts);
5349 
5350 		if (sharedstate == NULL)
5351 			shared = 0;
5352 
5353 		if (soptions == NULL)
5354 			soptions = sa_proto_legacy_format(proto, share, 1);
5355 
5356 		if (shared) {
5357 			/* only active shares go here */
5358 			(void) snprintf(resfmt, sizeof (resfmt), "%s%s%s",
5359 			    resource != NULL ? resource : "-",
5360 			    groupname != NULL ? "@" : "",
5361 			    groupname != NULL ? groupname : "");
5362 			(void) fprintf(out, "%-14.14s  %s   %s   \"%s\"  \n",
5363 			    resfmt, (path != NULL) ? path : "",
5364 			    (soptions != NULL && strlen(soptions) > 0) ?
5365 			    soptions : defprop,
5366 			    (description != NULL) ? description : "");
5367 		}
5368 
5369 		if (path != NULL)
5370 			sa_free_attr_string(path);
5371 		if (type != NULL)
5372 			sa_free_attr_string(type);
5373 		if (resource != NULL)
5374 			sa_free_attr_string(resource);
5375 		if (groupname != NULL)
5376 			sa_free_attr_string(groupname);
5377 		if (description != NULL)
5378 			sa_free_share_description(description);
5379 		if (sharedstate != NULL)
5380 			sa_free_attr_string(sharedstate);
5381 		if (soptions != NULL)
5382 			sa_format_free(soptions);
5383 	}
5384 }
5385 
5386 /*
5387  * output_legacy_file(out, proto)
5388  *
5389  * Walk all of the groups for the specified protocol and call
5390  * out_share() to format and write in the format displayed by the
5391  * "share" command with no arguments.
5392  */
5393 
5394 static void
output_legacy_file(FILE * out,char * proto,sa_handle_t handle)5395 output_legacy_file(FILE *out, char *proto, sa_handle_t handle)
5396 {
5397 	sa_group_t group;
5398 
5399 	for (group = sa_get_group(handle, NULL);
5400 	    group != NULL;
5401 	    group = sa_get_next_group(group)) {
5402 		char *zfs;
5403 
5404 		/*
5405 		 * Go through all the groups and ZFS
5406 		 * sub-groups. out_share() will format the shares in
5407 		 * the group appropriately.
5408 		 */
5409 
5410 		zfs = sa_get_group_attr(group, "zfs");
5411 		if (zfs != NULL) {
5412 			sa_group_t zgroup;
5413 			sa_free_attr_string(zfs);
5414 			for (zgroup = sa_get_sub_group(group);
5415 			    zgroup != NULL;
5416 			    zgroup = sa_get_next_group(zgroup)) {
5417 
5418 				/* got a group, so display it */
5419 				out_share(out, zgroup, proto);
5420 			}
5421 		} else {
5422 			out_share(out, group, proto);
5423 		}
5424 	}
5425 }
5426 
5427 int
sa_legacy_share(sa_handle_t handle,int flags,int argc,char * argv[])5428 sa_legacy_share(sa_handle_t handle, int flags, int argc, char *argv[])
5429 {
5430 	char *protocol = "nfs";
5431 	char *options = NULL;
5432 	char *description = NULL;
5433 	char *groupname = NULL;
5434 	char *sharepath = NULL;
5435 	char *resource = NULL;
5436 	char *groupstatus = NULL;
5437 	int persist = SA_SHARE_TRANSIENT;
5438 	int argsused = 0;
5439 	int c;
5440 	int ret = SA_OK;
5441 	int zfs = 0;
5442 	int true_legacy = 0;
5443 	int curtype = SA_SHARE_TRANSIENT;
5444 	char cmd[MAXPATHLEN];
5445 	sa_group_t group = NULL;
5446 	sa_resource_t rsrc = NULL;
5447 	sa_share_t share;
5448 	char dir[MAXPATHLEN];
5449 	uint64_t features;
5450 #ifdef lint
5451 	flags = flags;
5452 #endif
5453 
5454 	while ((c = getopt(argc, argv, "?hF:d:o:p")) != EOF) {
5455 		switch (c) {
5456 		case 'd':
5457 			description = optarg;
5458 			argsused++;
5459 			break;
5460 		case 'F':
5461 			protocol = optarg;
5462 			if (!sa_valid_protocol(protocol)) {
5463 				if (format_legacy_path(cmd, MAXPATHLEN,
5464 				    protocol, "share") == 0 &&
5465 				    check_legacy_cmd(cmd)) {
5466 					true_legacy++;
5467 				} else {
5468 					(void) fprintf(stderr, gettext(
5469 					    "Invalid protocol specified: "
5470 					    "%s\n"), protocol);
5471 					return (SA_INVALID_PROTOCOL);
5472 				}
5473 			}
5474 			break;
5475 		case 'o':
5476 			options = optarg;
5477 			argsused++;
5478 			break;
5479 		case 'p':
5480 			persist = SA_SHARE_PERMANENT;
5481 			argsused++;
5482 			break;
5483 		case 'h':
5484 			/* optopt on valid arg isn't defined */
5485 			optopt = c;
5486 			/*FALLTHROUGH*/
5487 		case '?':
5488 		default:
5489 			/*
5490 			 * Since a bad option gets to here, sort it
5491 			 * out and return a syntax error return value
5492 			 * if necessary.
5493 			 */
5494 			switch (optopt) {
5495 			default:
5496 				ret = SA_LEGACY_ERR;
5497 				break;
5498 			case 'h':
5499 			case '?':
5500 				break;
5501 			}
5502 			(void) fprintf(stderr, gettext("usage: %s\n"),
5503 			    sa_get_usage(USAGE_SHARE));
5504 			return (ret);
5505 		}
5506 	}
5507 
5508 	/* Have the info so construct what is needed */
5509 	if (!argsused && optind == argc) {
5510 		/* display current info in share format */
5511 		(void) output_legacy_file(stdout, protocol, handle);
5512 		return (ret);
5513 	}
5514 
5515 	/* We are modifying the configuration */
5516 	if (optind == argc) {
5517 		(void) fprintf(stderr, gettext("usage: %s\n"),
5518 		    sa_get_usage(USAGE_SHARE));
5519 		return (SA_LEGACY_ERR);
5520 	}
5521 	if (true_legacy) {
5522 		/* If still using legacy share/unshare, exec it */
5523 		ret = run_legacy_command(cmd, argv);
5524 		return (ret);
5525 	}
5526 
5527 	sharepath = argv[optind++];
5528 	if (optind < argc) {
5529 		resource = argv[optind];
5530 		groupname = strchr(resource, '@');
5531 		if (groupname != NULL)
5532 			*groupname++ = '\0';
5533 	}
5534 	if (realpath(sharepath, dir) == NULL)
5535 		ret = SA_BAD_PATH;
5536 	else
5537 		sharepath = dir;
5538 	if (ret == SA_OK)
5539 		share = sa_find_share(handle, sharepath);
5540 	else
5541 		share = NULL;
5542 
5543 	features = sa_proto_get_featureset(protocol);
5544 
5545 	if (groupname != NULL) {
5546 		ret = SA_NOT_ALLOWED;
5547 	} else if (ret == SA_OK) {
5548 		char *legacygroup;
5549 		/*
5550 		 * The legacy group is always present and zfs groups
5551 		 * come and go.  zfs shares may be in sub-groups and
5552 		 * the zfs share will already be in that group so it
5553 		 * isn't an error. If the protocol is "smb", the group
5554 		 * "smb" is used when "default" would otherwise be
5555 		 * used.  "default" is NFS only and "smb" is SMB only.
5556 		 */
5557 		if (strcmp(protocol, "smb") == 0)
5558 			legacygroup = "smb";
5559 		else
5560 			legacygroup = "default";
5561 
5562 		/*
5563 		 * If the share exists (not NULL), then make sure it
5564 		 * is one we want to handle by getting the parent
5565 		 * group.
5566 		 */
5567 		if (share != NULL) {
5568 			group = sa_get_parent_group(share);
5569 		} else {
5570 			group = sa_get_group(handle, legacygroup);
5571 			if (group == NULL && strcmp(legacygroup, "smb") == 0) {
5572 				/*
5573 				 * This group may not exist, so create
5574 				 * as necessary. It only contains the
5575 				 * "smb" protocol.
5576 				 */
5577 				group = sa_create_group(handle, legacygroup,
5578 				    &ret);
5579 				if (group != NULL)
5580 					(void) sa_create_optionset(group,
5581 					    protocol);
5582 			}
5583 		}
5584 
5585 		if (group == NULL) {
5586 			ret = SA_SYSTEM_ERR;
5587 			goto err;
5588 		}
5589 
5590 		groupstatus = group_status(group);
5591 		if (share == NULL) {
5592 			share = sa_add_share(group, sharepath,
5593 			    persist, &ret);
5594 			if (share == NULL &&
5595 			    ret == SA_DUPLICATE_NAME) {
5596 				/*
5597 				 * Could be a ZFS path being started
5598 				 */
5599 				if (sa_zfs_is_shared(handle,
5600 				    sharepath)) {
5601 					ret = SA_OK;
5602 					group = sa_get_group(handle,
5603 					    "zfs");
5604 					if (group == NULL) {
5605 						/*
5606 						 * This shouldn't
5607 						 * happen.
5608 						 */
5609 						ret = SA_CONFIG_ERR;
5610 					} else {
5611 						share = sa_add_share(
5612 						    group, sharepath,
5613 						    persist, &ret);
5614 					}
5615 				}
5616 			}
5617 		} else {
5618 			char *type;
5619 			/*
5620 			 * May want to change persist state, but the
5621 			 * important thing is to change options. We
5622 			 * need to change them regardless of the
5623 			 * source.
5624 			 */
5625 
5626 			if (sa_zfs_is_shared(handle, sharepath)) {
5627 				zfs = 1;
5628 			}
5629 			remove_all_options(share, protocol);
5630 			type = sa_get_share_attr(share, "type");
5631 			if (type != NULL &&
5632 			    strcmp(type, "transient") != 0) {
5633 				curtype = SA_SHARE_PERMANENT;
5634 			}
5635 			if (type != NULL)
5636 				sa_free_attr_string(type);
5637 			if (curtype != persist) {
5638 				(void) sa_set_share_attr(share, "type",
5639 				    persist == SA_SHARE_PERMANENT ?
5640 				    "persist" : "transient");
5641 			}
5642 		}
5643 
5644 		/*
5645 		 * If there is a resource name, we may
5646 		 * actually care about it if this is share for
5647 		 * a protocol that uses resource level sharing
5648 		 * (SMB). We need to find the resource and, if
5649 		 * it exists, make sure it belongs to the
5650 		 * current share. If it doesn't exist, attempt
5651 		 * to create it.
5652 		 */
5653 
5654 		if (ret == SA_OK && resource != NULL) {
5655 			rsrc = sa_find_resource(handle, resource);
5656 			if (rsrc != NULL) {
5657 				if (share != sa_get_resource_parent(rsrc))
5658 					ret = SA_DUPLICATE_NAME;
5659 				} else {
5660 					rsrc = sa_add_resource(share, resource,
5661 					    persist, &ret);
5662 				}
5663 				if (features & SA_FEATURE_RESOURCE)
5664 					share = rsrc;
5665 			}
5666 
5667 			/* Have a group to hold this share path */
5668 			if (ret == SA_OK && options != NULL &&
5669 			    strlen(options) > 0) {
5670 				ret = sa_parse_legacy_options(share,
5671 				    options,
5672 				    protocol);
5673 			}
5674 			if (!zfs) {
5675 				/*
5676 				 * ZFS shares never have a description
5677 				 * and we can't store the values so
5678 				 * don't try.
5679 				 */
5680 				if (ret == SA_OK && description != NULL)
5681 					ret = sa_set_share_description(share,
5682 					    description);
5683 			}
5684 			if (ret == SA_OK &&
5685 			    strcmp(groupstatus, "enabled") == 0) {
5686 				if (rsrc != share)
5687 					ret = sa_enable_share(share, protocol);
5688 				else
5689 					ret = sa_enable_resource(rsrc,
5690 					    protocol);
5691 				if (ret == SA_OK &&
5692 				    persist == SA_SHARE_PERMANENT) {
5693 					(void) sa_update_legacy(share,
5694 					    protocol);
5695 				}
5696 				if (ret == SA_OK)
5697 					ret = sa_update_config(handle);
5698 			}
5699 	}
5700 err:
5701 	if (ret != SA_OK) {
5702 		(void) fprintf(stderr, gettext("Could not share: %s: %s\n"),
5703 		    sharepath, sa_errorstr(ret));
5704 		ret = SA_LEGACY_ERR;
5705 	}
5706 	return (ret);
5707 }
5708 
5709 /*
5710  * sa_legacy_unshare(flags, argc, argv)
5711  *
5712  * Implements the original unshare command.
5713  */
5714 int
sa_legacy_unshare(sa_handle_t handle,int flags,int argc,char * argv[])5715 sa_legacy_unshare(sa_handle_t handle, int flags, int argc, char *argv[])
5716 {
5717 	char *protocol = "nfs"; /* for now */
5718 	char *options = NULL;
5719 	char *sharepath = NULL;
5720 	int persist = SA_SHARE_TRANSIENT;
5721 	int argsused = 0;
5722 	int c;
5723 	int ret = SA_OK;
5724 	int true_legacy = 0;
5725 	uint64_t features = 0;
5726 	sa_resource_t resource = NULL;
5727 	char cmd[MAXPATHLEN];
5728 #ifdef lint
5729 	flags = flags;
5730 	options = options;
5731 #endif
5732 
5733 	while ((c = getopt(argc, argv, "?hF:o:p")) != EOF) {
5734 		switch (c) {
5735 		case 'F':
5736 			protocol = optarg;
5737 			if (!sa_valid_protocol(protocol)) {
5738 				if (format_legacy_path(cmd, MAXPATHLEN,
5739 				    protocol, "unshare") == 0 &&
5740 				    check_legacy_cmd(cmd)) {
5741 					true_legacy++;
5742 				} else {
5743 					(void) printf(gettext(
5744 					    "Invalid file system name\n"));
5745 					return (SA_INVALID_PROTOCOL);
5746 				}
5747 			}
5748 			break;
5749 		case 'o':
5750 			options = optarg;
5751 			argsused++;
5752 			break;
5753 		case 'p':
5754 			persist = SA_SHARE_PERMANENT;
5755 			argsused++;
5756 			break;
5757 		case 'h':
5758 			/* optopt on valid arg isn't defined */
5759 			optopt = c;
5760 			/*FALLTHROUGH*/
5761 		case '?':
5762 		default:
5763 			/*
5764 			 * Since a bad option gets to here, sort it
5765 			 * out and return a syntax error return value
5766 			 * if necessary.
5767 			 */
5768 			switch (optopt) {
5769 			default:
5770 				ret = SA_LEGACY_ERR;
5771 				break;
5772 			case 'h':
5773 			case '?':
5774 				break;
5775 			}
5776 			(void) printf(gettext("usage: %s\n"),
5777 			    sa_get_usage(USAGE_UNSHARE));
5778 			return (ret);
5779 		}
5780 	}
5781 
5782 	/* Have the info so construct what is needed */
5783 	if (optind == argc || (optind + 1) < argc || options != NULL) {
5784 		ret = SA_SYNTAX_ERR;
5785 	} else {
5786 		sa_share_t share;
5787 		char dir[MAXPATHLEN];
5788 		if (true_legacy) {
5789 			/* if still using legacy share/unshare, exec it */
5790 			ret = run_legacy_command(cmd, argv);
5791 			return (ret);
5792 		}
5793 		/*
5794 		 * Find the path in the internal configuration. If it
5795 		 * isn't found, attempt to resolve the path via
5796 		 * realpath() and try again.
5797 		 */
5798 		sharepath = argv[optind++];
5799 		share = sa_find_share(handle, sharepath);
5800 		if (share == NULL) {
5801 			if (realpath(sharepath, dir) == NULL) {
5802 				ret = SA_NO_SUCH_PATH;
5803 			} else {
5804 				share = sa_find_share(handle, dir);
5805 			}
5806 		}
5807 		if (share == NULL) {
5808 			/* Could be a resource name so check that next */
5809 			features = sa_proto_get_featureset(protocol);
5810 			resource = sa_find_resource(handle, sharepath);
5811 			if (resource != NULL) {
5812 				share = sa_get_resource_parent(resource);
5813 				if (features & SA_FEATURE_RESOURCE)
5814 					(void) sa_disable_resource(resource,
5815 					    protocol);
5816 				if (persist == SA_SHARE_PERMANENT) {
5817 					ret = sa_remove_resource(resource);
5818 					if (ret == SA_OK)
5819 						ret = sa_update_config(handle);
5820 				}
5821 				/*
5822 				 * If we still have a resource on the
5823 				 * share, we don't disable the share
5824 				 * itself. IF there aren't anymore, we
5825 				 * need to remove the share. The
5826 				 * removal will be done in the next
5827 				 * section if appropriate.
5828 				 */
5829 				resource = sa_get_share_resource(share, NULL);
5830 				if (resource != NULL)
5831 					share = NULL;
5832 			} else if (ret == SA_OK) {
5833 				/* Didn't find path and no  resource */
5834 				ret = SA_BAD_PATH;
5835 			}
5836 		}
5837 		if (share != NULL && resource == NULL) {
5838 			ret = sa_disable_share(share, protocol);
5839 			/*
5840 			 * Errors are ok and removal should still occur. The
5841 			 * legacy unshare is more forgiving of errors than the
5842 			 * remove-share subcommand which may need the force
5843 			 * flag set for some error conditions. That is, the
5844 			 * "unshare" command will always unshare if it can
5845 			 * while "remove-share" might require the force option.
5846 			 */
5847 			if (persist == SA_SHARE_PERMANENT) {
5848 				ret = sa_remove_share(share);
5849 				if (ret == SA_OK)
5850 					ret = sa_update_config(handle);
5851 			}
5852 		} else if (ret == SA_OK && share == NULL && resource == NULL) {
5853 			/*
5854 			 * If both share and resource are NULL, then
5855 			 * share not found. If one or the other was
5856 			 * found or there was an earlier error, we
5857 			 * assume it was handled earlier.
5858 			 */
5859 			ret = SA_NOT_SHARED;
5860 		}
5861 	}
5862 	switch (ret) {
5863 	default:
5864 		(void) printf("%s: %s\n", sharepath, sa_errorstr(ret));
5865 		ret = SA_LEGACY_ERR;
5866 		break;
5867 	case SA_SYNTAX_ERR:
5868 		(void) printf(gettext("usage: %s\n"),
5869 		    sa_get_usage(USAGE_UNSHARE));
5870 		break;
5871 	case SA_OK:
5872 		break;
5873 	}
5874 	return (ret);
5875 }
5876 
5877 /*
5878  * Common commands that implement the sub-commands used by all
5879  * protocols. The entries are found via the lookup command
5880  */
5881 
5882 static sa_command_t commands[] = {
5883 	{"add-share", 0, sa_addshare, USAGE_ADD_SHARE, SVC_SET},
5884 	{"create", 0, sa_create, USAGE_CREATE, SVC_SET|SVC_ACTION},
5885 	{"delete", 0, sa_delete, USAGE_DELETE, SVC_SET|SVC_ACTION},
5886 	{"disable", 0, sa_disable_group, USAGE_DISABLE, SVC_SET|SVC_ACTION},
5887 	{"enable", 0, sa_enable_group, USAGE_ENABLE, SVC_SET|SVC_ACTION},
5888 	{"list", 0, sa_list, USAGE_LIST},
5889 	{"move-share", 0, sa_moveshare, USAGE_MOVE_SHARE, SVC_SET},
5890 	{"remove-share", 0, sa_removeshare, USAGE_REMOVE_SHARE, SVC_SET},
5891 	{"set", 0, sa_set, USAGE_SET, SVC_SET},
5892 	{"set-share", 0, sa_set_share, USAGE_SET_SHARE, SVC_SET},
5893 	{"show", 0, sa_show, USAGE_SHOW},
5894 	{"share", 0, sa_legacy_share, USAGE_SHARE, SVC_SET|SVC_ACTION},
5895 	{"start", CMD_NODISPLAY, sa_start_group, USAGE_START,
5896 	    SVC_SET|SVC_ACTION},
5897 	{"stop", CMD_NODISPLAY, sa_stop_group, USAGE_STOP, SVC_SET|SVC_ACTION},
5898 	{"unset", 0, sa_unset, USAGE_UNSET, SVC_SET},
5899 	{"unshare", 0, sa_legacy_unshare, USAGE_UNSHARE, SVC_SET|SVC_ACTION},
5900 	{NULL, 0, NULL, NULL}
5901 };
5902 
5903 static char *
sa_get_usage(sa_usage_t index)5904 sa_get_usage(sa_usage_t index)
5905 {
5906 	char *ret = NULL;
5907 	switch (index) {
5908 	case USAGE_ADD_SHARE:
5909 		ret = gettext("add-share [-nth] [-r resource-name] "
5910 		    "[-d \"description text\"] -s sharepath group");
5911 		break;
5912 	case USAGE_CREATE:
5913 		ret = gettext(
5914 		    "create [-nvh] [-P proto [-p property=value]] group");
5915 		break;
5916 	case USAGE_DELETE:
5917 		ret = gettext("delete [-nvh] [-P proto] [-f] group");
5918 		break;
5919 	case USAGE_DISABLE:
5920 		ret = gettext("disable [-nvh] {-a | group ...}");
5921 		break;
5922 	case USAGE_ENABLE:
5923 		ret = gettext("enable [-nvh] {-a | group ...}");
5924 		break;
5925 	case USAGE_LIST:
5926 		ret = gettext("list [-vh] [-P proto]");
5927 		break;
5928 	case USAGE_MOVE_SHARE:
5929 		ret = gettext(
5930 		    "move-share [-nvh] -s sharepath destination-group");
5931 		break;
5932 	case USAGE_REMOVE_SHARE:
5933 		ret = gettext(
5934 		    "remove-share [-fnvh] {-s sharepath | -r resource} "
5935 		    "group");
5936 		break;
5937 	case USAGE_SET:
5938 		ret = gettext("set [-nvh] -P proto [-S optspace] "
5939 		    "[-p property=value]* [-s sharepath] [-r resource]] "
5940 		    "group");
5941 		break;
5942 	case USAGE_SET_SECURITY:
5943 		ret = gettext("set-security [-nvh] -P proto -S security-type "
5944 		    "[-p property=value]* group");
5945 		break;
5946 	case USAGE_SET_SHARE:
5947 		ret = gettext("set-share [-nh] [-r resource] "
5948 		    "[-d \"description text\"] -s sharepath group");
5949 		break;
5950 	case USAGE_SHOW:
5951 		ret = gettext("show [-pvxh] [-P proto] [group ...]");
5952 		break;
5953 	case USAGE_SHARE:
5954 		ret = gettext("share [-F fstype] [-p] [-o optionlist]"
5955 		    "[-d description] [pathname [resourcename]]");
5956 		break;
5957 	case USAGE_START:
5958 		ret = gettext("start [-vh] [-P proto] {-a | group ...}");
5959 		break;
5960 	case USAGE_STOP:
5961 		ret = gettext("stop [-vh] [-P proto] {-a | group ...}");
5962 		break;
5963 	case USAGE_UNSET:
5964 		ret = gettext("unset [-nvh] -P proto [-S optspace] "
5965 		    "[-p property]* group");
5966 		break;
5967 	case USAGE_UNSET_SECURITY:
5968 		ret = gettext("unset-security [-nvh] -P proto "
5969 		    "-S security-type [-p property]* group");
5970 		break;
5971 	case USAGE_UNSHARE:
5972 		ret = gettext(
5973 		    "unshare [-F fstype] [-p] [-o optionlist] sharepath");
5974 		break;
5975 	}
5976 	return (ret);
5977 }
5978 
5979 /*
5980  * sa_lookup(cmd, proto)
5981  *
5982  * Lookup the sub-command. proto isn't currently used, but it may
5983  * eventually provide a way to provide protocol specific sub-commands.
5984  */
5985 sa_command_t *
sa_lookup(char * cmd,char * proto)5986 sa_lookup(char *cmd, char *proto)
5987 {
5988 	int i;
5989 	size_t len;
5990 #ifdef lint
5991 	proto = proto;
5992 #endif
5993 
5994 	len = strlen(cmd);
5995 	for (i = 0; commands[i].cmdname != NULL; i++) {
5996 		if (strncmp(cmd, commands[i].cmdname, len) == 0)
5997 			return (&commands[i]);
5998 	}
5999 	return (NULL);
6000 }
6001 
6002 void
sub_command_help(char * proto)6003 sub_command_help(char *proto)
6004 {
6005 	int i;
6006 #ifdef lint
6007 	proto = proto;
6008 #endif
6009 
6010 	(void) printf(gettext("\tsub-commands:\n"));
6011 	for (i = 0; commands[i].cmdname != NULL; i++) {
6012 		if (!(commands[i].flags & (CMD_ALIAS|CMD_NODISPLAY)))
6013 			(void) printf("\t%s\n",
6014 			    sa_get_usage((sa_usage_t)commands[i].cmdidx));
6015 	}
6016 }
6017