xref: /titanic_51/usr/src/cmd/dfs.cmds/sharemgr/commands.c (revision bbaa8b60dd95d714741fc474adad3cf710ef4efd)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2012 Milan Jurik. All rights reserved.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <getopt.h>
#include <utmpx.h>
#include <pwd.h>
#include <auth_attr.h>
#include <secdb.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <errno.h>

#include <libshare.h>
#include "sharemgr.h"
#include <libscf.h>
#include <libxml/tree.h>
#include <libintl.h>
#include <assert.h>
#include <iconv.h>
#include <langinfo.h>
#include <dirent.h>

static char *sa_get_usage(sa_usage_t);

/*
 * Implementation of the common sub-commands supported by sharemgr.
 * A number of helper functions are also included.
 */

/*
 * has_protocol(group, proto)
 *	If the group has an optionset with the specified protocol,
 *	return true (1) otherwise false (0).
 */
static int
has_protocol(sa_group_t group, char *protocol)
{
	sa_optionset_t optionset;
	int result = 0;

	optionset = sa_get_optionset(group, protocol);
	if (optionset != NULL) {
		result++;
	}
	return (result);
}

/*
 * validresource(name)
 *
 * Check that name only has valid characters in it. The current valid
 * set are the printable characters but not including:
 *	" / \ [ ] : | < > + ; , ? * = \t
 * Note that space is included and there is a maximum length.
 */
static int
validresource(const char *name)
{
	const char *cp;
	size_t len;

	if (name == NULL)
		return (B_FALSE);

	len = strlen(name);
	if (len == 0 || len > SA_MAX_RESOURCE_NAME)
		return (B_FALSE);

	if (strpbrk(name, "\"/\\[]:|<>+;,?*=\t") != NULL) {
		return (B_FALSE);
	}

	for (cp = name; *cp != '\0'; cp++)
		if (iscntrl(*cp))
			return (B_FALSE);

	return (B_TRUE);
}

/*
 * conv_to_utf8(input)
 *
 * Convert the input string to utf8 from the current locale.  If the
 * conversion fails, use the current locale, it is likely close
 * enough. For example, the "C" locale is a subset of utf-8. The
 * return value may be a new string or the original input string.
 */

static char *
conv_to_utf8(char *input)
{
	iconv_t cd;
	char *inval = input;
	char *output = input;
	char *outleft;
	char *curlocale;
	size_t bytesleft;
	size_t size;
	size_t osize;
	static int warned = 0;

	curlocale = nl_langinfo(CODESET);
	if (curlocale == NULL)
		curlocale = "C";
	cd = iconv_open("UTF-8", curlocale);
	if (cd != NULL && cd != (iconv_t)-1) {
		size = strlen(input);
		/* Assume worst case of characters expanding to 4 bytes. */
		bytesleft = size * 4;
		output = calloc(bytesleft, 1);
		if (output != NULL) {
			outleft = output;
			/* inval can be modified on return */
			osize = iconv(cd, (const char **)&inval, &size,
			    &outleft, &bytesleft);
			if (osize == (size_t)-1 || size != 0) {
				free(output);
				output = input;
			}
		} else {
			/* Need to return something. */
			output = input;
		}
		(void) iconv_close(cd);
	} else {
		if (!warned)
			(void) fprintf(stderr,
			    gettext("Cannot convert to UTF-8 from %s\n"),
			    curlocale ? curlocale : gettext("unknown"));
		warned = 1;
	}
	return (output);
}

/*
 * conv_from(input)
 *
 * Convert the input string from utf8 to current locale.  If the
 * conversion isn't supported, just use as is. The return value may be
 * a new string or the original input string.
 */

static char *
conv_from_utf8(char *input)
{
	iconv_t cd;
	char *output = input;
	char *inval = input;
	char *outleft;
	char *curlocale;
	size_t bytesleft;
	size_t size;
	size_t osize;
	static int warned = 0;

	curlocale = nl_langinfo(CODESET);
	if (curlocale == NULL)
		curlocale = "C";
	cd = iconv_open(curlocale, "UTF-8");
	if (cd != NULL && cd != (iconv_t)-1) {
		size = strlen(input);
		/* Assume worst case of characters expanding to 4 bytes. */
		bytesleft = size * 4;
		output = calloc(bytesleft, 1);
		if (output != NULL) {
			outleft = output;
			osize = iconv(cd, (const char **)&inval, &size,
			    &outleft, &bytesleft);
			if (osize == (size_t)-1 || size != 0)
				output = input;
		} else {
			/* Need to return something. */
			output = input;
		}
		(void) iconv_close(cd);
	} else {
		if (!warned)
			(void) fprintf(stderr,
			    gettext("Cannot convert to %s from UTF-8\n"),
			    curlocale ? curlocale : gettext("unknown"));
		warned = 1;
	}
	return (output);
}

/*
 * print_rsrc_desc(resource, sharedesc)
 *
 * Print the resource description string after converting from UTF8 to
 * the current locale. If sharedesc is not NULL and there is no
 * description on the resource, use sharedesc. sharedesc will already
 * be converted to UTF8.
 */

static void
print_rsrc_desc(sa_resource_t resource, char *sharedesc)
{
	char *description;
	char *desc;

	if (resource == NULL)
		return;

	description = sa_get_resource_description(resource);
	if (description != NULL) {
		desc = conv_from_utf8(description);
		if (desc != description) {
			sa_free_share_description(description);
			description = desc;
		}
	} else if (sharedesc != NULL) {
		description = strdup(sharedesc);
	}
	if (description != NULL) {
		(void) printf("\t\"%s\"", description);
		sa_free_share_description(description);
	}
}

/*
 * set_resource_desc(share, description)
 *
 * Set the share description value after converting the description
 * string to UTF8 from the current locale.
 */

static int
set_resource_desc(sa_share_t share, char *description)
{
	char *desc;
	int ret;

	desc = conv_to_utf8(description);
	ret = sa_set_resource_description(share, desc);
	if (description != desc)
		sa_free_share_description(desc);
	return (ret);
}

/*
 * set_share_desc(share, description)
 *
 * Set the resource description value after converting the description
 * string to UTF8 from the current locale.
 */

static int
set_share_desc(sa_share_t share, char *description)
{
	char *desc;
	int ret;

	desc = conv_to_utf8(description);
	ret = sa_set_share_description(share, desc);
	if (description != desc)
		sa_free_share_description(desc);
	return (ret);
}

/*
 * add_list(list, item, data, proto)
 *	Adds a new list member that points holds item in the list.
 *	If list is NULL, it starts a new list.  The function returns
 *	the first member of the list.
 */
struct list *
add_list(struct list *listp, void *item, void *data, char *proto)
{
	struct list *new, *tmp;

	new = malloc(sizeof (struct list));
	if (new != NULL) {
		new->next = NULL;
		new->item = item;
		new->itemdata = data;
		new->proto = proto;
	} else {
		return (listp);
	}

	if (listp == NULL)
		return (new);

	for (tmp = listp; tmp->next != NULL; tmp = tmp->next) {
		/* get to end of list */
	}
	tmp->next = new;
	return (listp);
}

/*
 * free_list(list)
 *	Given a list, free all the members of the list;
 */
static void
free_list(struct list *listp)
{
	struct list *tmp;
	while (listp != NULL) {
		tmp = listp;
		listp = listp->next;
		free(tmp);
	}
}

/*
 * check_authorization(instname, which)
 *
 * Checks to see if the specific type of authorization in which is
 * enabled for the user in this SMF service instance.
 */

static int
check_authorization(char *instname, int which)
{
	scf_handle_t *handle = NULL;
	scf_simple_prop_t *prop = NULL;
	char svcstring[SA_MAX_NAME_LEN + sizeof (SA_SVC_FMRI_BASE) + 1];
	char *authstr = NULL;
	ssize_t numauths;
	int ret = B_TRUE;
	uid_t uid;
	struct passwd *pw = NULL;

	uid = getuid();
	pw = getpwuid(uid);
	if (pw == NULL) {
		ret = B_FALSE;
	} else {
		/*
		 * Since names are restricted to SA_MAX_NAME_LEN won't
		 * overflow.
		 */
		(void) snprintf(svcstring, sizeof (svcstring), "%s:%s",
		    SA_SVC_FMRI_BASE, instname);
		handle = scf_handle_create(SCF_VERSION);
		if (handle != NULL) {
			if (scf_handle_bind(handle) == 0) {
				switch (which) {
				case SVC_SET:
					prop = scf_simple_prop_get(handle,
					    svcstring, "general",
					    SVC_AUTH_VALUE);
					break;
				case SVC_ACTION:
					prop = scf_simple_prop_get(handle,
					    svcstring, "general",
					    SVC_AUTH_ACTION);
					break;
				}
			}
		}
	}
	/* make sure we have an authorization string property */
	if (prop != NULL) {
		int i;
		numauths = scf_simple_prop_numvalues(prop);
		for (ret = 0, i = 0; i < numauths; i++) {
			authstr = scf_simple_prop_next_astring(prop);
			if (authstr != NULL) {
				/* check if this user has one of the strings */
				if (chkauthattr(authstr, pw->pw_name)) {
					ret = 1;
					break;
				}
			}
		}
		endauthattr();
		scf_simple_prop_free(prop);
	} else {
		/* no authorization string defined */
		ret = 0;
	}
	if (handle != NULL)
		scf_handle_destroy(handle);
	return (ret);
}

/*
 * check_authorizations(instname, flags)
 *
 * check all the needed authorizations for the user in this service
 * instance. Return value of 1(true) or 0(false) indicates whether
 * there are authorizations for the user or not.
 */

static int
check_authorizations(char *instname, int flags)
{
	int ret1 = 0;
	int ret2 = 0;
	int ret;

	if (flags & SVC_SET)
		ret1 = check_authorization(instname, SVC_SET);
	if (flags & SVC_ACTION)
		ret2 = check_authorization(instname, SVC_ACTION);
	switch (flags) {
	case SVC_ACTION:
		ret = ret2;
		break;
	case SVC_SET:
		ret = ret1;
		break;
	case SVC_ACTION|SVC_SET:
		ret = ret1 & ret2;
		break;
	default:
		/* if not flags set, we assume we don't need authorizations */
		ret = 1;
	}
	return (ret);
}

/*
 * notify_or_enable_share(share, protocol)
 *
 * Since some protocols don't want an "enable" when properties change,
 * this function will use the protocol specific notify function
 * first. If that fails, it will then attempt to use the
 * sa_enable_share().  "protocol" is the protocol that was specified
 * on the command line.
 */
static void
notify_or_enable_share(sa_share_t share, char *protocol)
{
	sa_group_t group;
	sa_optionset_t opt;
	int ret = SA_OK;
	char *path;
	char *groupproto;
	sa_share_t parent = share;

	/* If really a resource, get parent share */
	if (!sa_is_share(share)) {
		parent = sa_get_resource_parent((sa_resource_t)share);
	}

	/*
	 * Now that we've got a share in "parent", make sure it has a path.
	 */
	path = sa_get_share_attr(parent, "path");
	if (path == NULL)
		return;

	group = sa_get_parent_group(parent);

	if (group == NULL) {
		sa_free_attr_string(path);
		return;
	}
	for (opt = sa_get_optionset(group, NULL);
	    opt != NULL;
	    opt = sa_get_next_optionset(opt)) {
		groupproto = sa_get_optionset_attr(opt, "type");
		if (groupproto == NULL ||
		    (protocol != NULL && strcmp(groupproto, protocol) != 0)) {
			if (groupproto != NULL)
				sa_free_attr_string(groupproto);
			continue;
		}
		if (sa_is_share(share)) {
			if ((ret = sa_proto_change_notify(share,
			    groupproto)) != SA_OK) {
				ret = sa_enable_share(share, groupproto);
				if (ret != SA_OK) {
					(void) printf(
					    gettext("Could not reenable"
					    " share %s: %s\n"),
					    path, sa_errorstr(ret));
				}
			}
		} else {
			/* Must be a resource */
			if ((ret = sa_proto_notify_resource(share,
			    groupproto)) != SA_OK) {
				ret = sa_enable_resource(share, groupproto);
				if (ret != SA_OK) {
					(void) printf(
					    gettext("Could not "
					    "reenable resource %s: "
					    "%s\n"), path,
					    sa_errorstr(ret));
				}
			}
		}
		sa_free_attr_string(groupproto);
	}
	sa_free_attr_string(path);
}

/*
 * enable_group(group, updateproto, notify, proto)
 *
 * enable all the shares in the specified group. This is a helper for
 * enable_all_groups in order to simplify regular and subgroup (zfs)
 * enabling. Group has already been checked for non-NULL. If notify
 * is non-zero, attempt to use the notify interface rather than
 * enable.
 */
static void
enable_group(sa_group_t group, char *updateproto, int notify, char *proto)
{
	sa_share_t share;

	/* If the protocol isn't enabled for this group skip it */
	if (!has_protocol(group, proto))
		return;

	for (share = sa_get_share(group, NULL);
	    share != NULL;
	    share = sa_get_next_share(share)) {
		if (updateproto != NULL)
			(void) sa_update_legacy(share, updateproto);
		if (notify)
			notify_or_enable_share(share, proto);
		else
			(void) sa_enable_share(share, proto);
	}
}

/*
 * isenabled(group)
 *
 * Returns B_TRUE if the group is enabled or B_FALSE if it isn't.
 * Moved to separate function to reduce clutter in the code.
 */

static int
isenabled(sa_group_t group)
{
	char *state;
	int ret = B_FALSE;

	if (group != NULL) {
		state = sa_get_group_attr(group, "state");
		if (state != NULL) {

			if (strcmp(state, "enabled") == 0)
				ret = B_TRUE;
			sa_free_attr_string(state);
		}
	}
	return (ret);
}

/*
 * enable_all_groups(list, setstate, online, updateproto)
 *
 * Given a list of groups, enable each one found.  If updateproto is
 * not NULL, then update all the shares for the protocol that was
 * passed in. If enable is non-zero, tell enable_group to try the
 * notify interface since this is a property change.
 */
static int
enable_all_groups(sa_handle_t handle, struct list *work, int setstate,
    int online, char *updateproto, int enable)
{
	int ret;
	char instance[SA_MAX_NAME_LEN + sizeof (SA_SVC_FMRI_BASE) + 1];
	char *state;
	char *name;
	char *zfs = NULL;
	sa_group_t group;
	sa_group_t subgroup;

	for (ret = SA_OK; work != NULL;	work = work->next) {
		group = (sa_group_t)work->item;

		/*
		 * If setstate == TRUE, then make sure to set
		 * enabled. This needs to be done here in order for
		 * the isenabled check to succeed on a newly enabled
		 * group.
		 */
		if (setstate == B_TRUE) {
			ret = sa_set_group_attr(group, "state",	"enabled");
			if (ret != SA_OK)
				break;
		}

		/*
		 * Check to see if group is enabled. If it isn't, skip
		 * the rest.  We don't want shares starting if the
		 * group is disabled. The properties may have been
		 * updated, but there won't be a change until the
		 * group is enabled.
		 */
		if (!isenabled(group))
			continue;

		/* if itemdata != NULL then a single share */
		if (work->itemdata != NULL) {
			if (enable) {
				if (work->itemdata != NULL)
					notify_or_enable_share(work->itemdata,
					    updateproto);
				else
					ret = SA_CONFIG_ERR;
			} else {
				if (sa_is_share(work->itemdata)) {
					ret = sa_enable_share(
					    (sa_share_t)work->itemdata,
					    updateproto);
				} else {
					ret = sa_enable_resource(
					    (sa_resource_t)work->itemdata,
					    updateproto);
				}
			}
		}
		if (ret != SA_OK)
			break;

		/* if itemdata == NULL then the whole group */
		if (work->itemdata == NULL) {
			zfs = sa_get_group_attr(group, "zfs");
			/*
			 * If the share is managed by ZFS, don't
			 * update any of the protocols since ZFS is
			 * handling this.  Updateproto will contain
			 * the name of the protocol that we want to
			 * update legacy files for.
			 */
			enable_group(group, zfs == NULL ? updateproto : NULL,
			    enable, work->proto);
			if (zfs != NULL)
				sa_free_attr_string(zfs);

			for (subgroup = sa_get_sub_group(group);
			    subgroup != NULL;
			    subgroup = sa_get_next_group(subgroup)) {
				/* never update legacy for ZFS subgroups */
				enable_group(subgroup, NULL, enable,
				    work->proto);
			}
		}
		if (online) {
			zfs = sa_get_group_attr(group, "zfs");
			name = sa_get_group_attr(group, "name");
			if (name != NULL) {
				if (zfs == NULL) {
					(void) snprintf(instance,
					    sizeof (instance), "%s:%s",
					    SA_SVC_FMRI_BASE, name);
					state = smf_get_state(instance);
					if (state == NULL ||
					    strcmp(state, "online") != 0) {
						(void) smf_enable_instance(
						    instance, 0);
						free(state);
					}
				} else {
					sa_free_attr_string(zfs);
					zfs = NULL;
				}
				if (name != NULL)
					sa_free_attr_string(name);
			}
		}
	}
	if (ret == SA_OK) {
		ret = sa_update_config(handle);
	}
	return (ret);
}

/*
 * chk_opt(optlistp, security, proto)
 *
 * Do a sanity check on the optlist provided for the protocol.  This
 * is a syntax check and verification that the property is either a
 * general or specific to a names optionset.
 */

static int
chk_opt(struct options *optlistp, int security, char *proto)
{
	struct options *optlist;
	char *sep = "";
	int notfirst = 0;
	int ret;

	for (optlist = optlistp; optlist != NULL; optlist = optlist->next) {
		char *optname;

		optname = optlist->optname;
		ret = OPT_ADD_OK;
		/* extract property/value pair */
		if (sa_is_security(optname, proto)) {
			if (!security)
				ret = OPT_ADD_SECURITY;
		} else {
			if (security)
				ret = OPT_ADD_PROPERTY;
		}
		if (ret != OPT_ADD_OK) {
			if (notfirst == 0)
				(void) printf(
				    gettext("Property syntax error: "));
			switch (ret) {
			case OPT_ADD_SYNTAX:
				(void) printf(gettext("%ssyntax error: %s"),
				    sep, optname);
				sep = ", ";
				break;
			case OPT_ADD_SECURITY:
				(void) printf(gettext("%s%s requires -S"),
				    optname, sep);
				sep = ", ";
				break;
			case OPT_ADD_PROPERTY:
				(void) printf(
				    gettext("%s%s not supported with -S"),
				    optname, sep);
				sep = ", ";
				break;
			}
			notfirst++;
		}
	}
	if (notfirst) {
		(void) printf("\n");
		ret = SA_SYNTAX_ERR;
	}
	return (ret);
}

/*
 * free_opt(optlist)
 *	Free the specified option list.
 */
static void
free_opt(struct options *optlist)
{
	struct options *nextopt;
	while (optlist != NULL) {
		nextopt = optlist->next;
		free(optlist);
		optlist = nextopt;
	}
}

/*
 * check property list for valid properties
 * A null value is a remove which is always valid.
 */
static int
valid_options(sa_handle_t handle, struct options *optlist, char *proto,
    void *object, char *sec)
{
	int ret = SA_OK;
	struct options *cur;
	sa_property_t prop;
	sa_optionset_t parent = NULL;

	if (object != NULL) {
		if (sec == NULL)
			parent = sa_get_optionset(object, proto);
		else
			parent = sa_get_security(object, sec, proto);
	}

	for (cur = optlist; cur != NULL; cur = cur->next) {
		if (cur->optvalue == NULL)
			continue;
		prop = sa_create_property(cur->optname, cur->optvalue);
		if (prop == NULL)
			ret = SA_NO_MEMORY;
		if (ret != SA_OK ||
		    (ret = sa_valid_property(handle, parent, proto, prop)) !=
		    SA_OK) {
			(void) printf(
			    gettext("Could not add property %s: %s\n"),
			    cur->optname, sa_errorstr(ret));
		}
		(void) sa_remove_property(prop);
	}
	return (ret);
}

/*
 * add_optionset(group, optlist, protocol, *err)
 *	Add the options in optlist to an optionset and then add the optionset
 *	to the group.
 *
 *	The return value indicates if there was a "change" while errors are
 *	returned via the *err parameters.
 */
static int
add_optionset(sa_group_t group, struct options *optlist, char *proto, int *err)
{
	sa_optionset_t optionset;
	int ret = SA_OK;
	int result = B_FALSE;
	sa_handle_t handle;

	optionset = sa_get_optionset(group, proto);
	if (optionset == NULL) {
		optionset = sa_create_optionset(group, proto);
		if (optionset == NULL)
			ret = SA_NO_MEMORY;
		result = B_TRUE; /* adding a protocol is a change */
	}
	if (optionset == NULL) {
		ret = SA_NO_MEMORY;
		goto out;
	}
	handle = sa_find_group_handle(group);
	if (handle == NULL) {
		ret = SA_CONFIG_ERR;
		goto out;
	}
	while (optlist != NULL) {
		sa_property_t prop;
		prop = sa_get_property(optionset, optlist->optname);
		if (prop == NULL) {
			/*
			 * add the property, but only if it is
			 * a non-NULL or non-zero length value
			 */
			if (optlist->optvalue != NULL) {
				prop = sa_create_property(optlist->optname,
				    optlist->optvalue);
				if (prop != NULL) {
					ret = sa_valid_property(handle,
					    optionset, proto, prop);
					if (ret != SA_OK) {
						(void) sa_remove_property(prop);
						(void) printf(gettext("Could "
						    "not add property "
						    "%s: %s\n"),
						    optlist->optname,
						    sa_errorstr(ret));
					}
				}
				if (ret == SA_OK) {
					ret = sa_add_property(optionset, prop);
					if (ret != SA_OK) {
						(void) printf(gettext(
						    "Could not add property "
						    "%s: %s\n"),
						    optlist->optname,
						    sa_errorstr(ret));
					} else {
						/* there was a change */
						result = B_TRUE;
					}
				}
			}
		} else {
			ret = sa_update_property(prop, optlist->optvalue);
			/* should check to see if value changed */
			if (ret != SA_OK) {
				(void) printf(gettext("Could not update "
				    "property %s: %s\n"), optlist->optname,
				    sa_errorstr(ret));
			} else {
				result = B_TRUE;
			}
		}
		optlist = optlist->next;
	}
	ret = sa_commit_properties(optionset, 0);

out:
	if (err != NULL)
		*err = ret;
	return (result);
}

/*
 * resource_compliant(group)
 *
 * Go through all the shares in the group. Assume compliant, but if
 * any share doesn't have at least one resource name, it isn't
 * compliant.
 */
static int
resource_compliant(sa_group_t group)
{
	sa_share_t share;

	for (share = sa_get_share(group, NULL); share != NULL;
	    share = sa_get_next_share(share)) {
		if (sa_get_share_resource(share, NULL) == NULL) {
			return (B_FALSE);
		}
	}
	return (B_TRUE);
}

/*
 * fix_path(path)
 *
 * change all illegal characters to something else.  For now, all get
 * converted to '_' and the leading '/' is stripped off. This is used
 * to construct an resource name (SMB share name) that is valid.
 * Caller must pass a valid path.
 */
static void
fix_path(char *path)
{
	char *cp;
	size_t len;

	assert(path != NULL);

	/* make sure we are appropriate length */
	cp = path + 1; /* skip leading slash */
	while (cp != NULL && strlen(cp) > SA_MAX_RESOURCE_NAME) {
		cp = strchr(cp, '/');
		if (cp != NULL)
			cp++;
	}
	/* two cases - cp == NULL and cp is substring of path */
	if (cp == NULL) {
		/* just take last SA_MAX_RESOURCE_NAME chars */
		len = 1 + strlen(path) - SA_MAX_RESOURCE_NAME;
		(void) memmove(path, path + len, SA_MAX_RESOURCE_NAME);
		path[SA_MAX_RESOURCE_NAME] = '\0';
	} else {
		len = strlen(cp) + 1;
		(void) memmove(path, cp, len);
	}

	/*
	 * Don't want any of the characters that are not allowed
	 * in and SMB share name. Replace them with '_'.
	 */
	while (*path) {
		switch (*path) {
		case '/':
		case '"':
		case '\\':
		case '[':
		case ']':
		case ':':
		case '|':
		case '<':
		case '>':
		case '+':
		case ';':
		case ',':
		case '?':
		case '*':
		case '=':
		case '\t':
			*path = '_';
			break;
		}
		path++;
	}
}

/*
 * name_adjust(path, count)
 *
 * Add a ~<count> in place of last few characters. The total number of
 * characters is dependent on count.
 */
#define	MAX_MANGLE_NUMBER	10000

static int
name_adjust(char *path, int count)
{
	size_t len;

	len = strlen(path) - 2;
	if (count > 10)
		len--;
	if (count > 100)
		len--;
	if (count > 1000)
		len--;
	if (len > 0)
		(void) sprintf(path + len, "~%d", count);
	else
		return (SA_BAD_VALUE);

	return (SA_OK);
}

/*
 * make_resources(group)
 *
 * Go through all the shares in the group and make them have resource
 * names.
 */
static void
make_resources(sa_group_t group)
{
	sa_share_t share;
	int count;
	int err = SA_OK;

	for (share = sa_get_share(group, NULL); share != NULL;
	    share = sa_get_next_share(share)) {
		/* Skip those with resources */
		if (sa_get_share_resource(share, NULL) == NULL) {
			char *path;
			path = sa_get_share_attr(share, "path");
			if (path == NULL)
				continue;
			fix_path(path);
			count = 0;	/* reset for next resource */
			while (sa_add_resource(share, path,
			    SA_SHARE_PERMANENT, &err) == NULL &&
			    err == SA_DUPLICATE_NAME) {
				int ret;
				ret = name_adjust(path, count);
				count++;
				if (ret != SA_OK ||
				    count >= MAX_MANGLE_NUMBER) {
					(void) printf(gettext(
					    "Cannot create resource name for"
					    " path: %s\n"), path);
					break;
				}
			}
			sa_free_attr_string(path);
		}
	}
}

/*
 * check_valid_group(group, protocol)
 *
 * Check to see that the group should have the protocol added (if
 * there is one specified).
 */

static int
check_valid_group(sa_group_t group, char *groupname, char *protocol)
{

	if (protocol != NULL) {
		if (has_protocol(group, protocol)) {
			(void) printf(gettext(
			    "Group \"%s\" already exists"
			    " with protocol %s\n"), groupname,
			    protocol);
			return (SA_DUPLICATE_NAME);
		} else if (strcmp(groupname, "default") == 0 &&
		    strcmp(protocol, "nfs") != 0) {
			(void) printf(gettext(
			    "Group \"%s\" only allows protocol "
			    "\"%s\"\n"), groupname, "nfs");
			return (SA_INVALID_PROTOCOL);
		}
	} else {
		/* must add new protocol */
		(void) printf(gettext(
		    "Group already exists and no protocol "
		    "specified.\n"));
		return (SA_DUPLICATE_NAME);
	}
	return (SA_OK);
}

/*
 * enforce_featureset(group, protocol, dryrun, force)
 *
 * Check the protocol featureset against the group and enforce any
 * rules that might be imposed.
 */

static int
enforce_featureset(sa_group_t group, char *protocol, boolean_t dryrun,
    boolean_t force)
{
	uint64_t features;

	if (protocol == NULL)
		return (SA_OK);

	/*
	 * First check to see if specified protocol is one we want to
	 * allow on a group. Only server protocols are allowed here.
	 */
	features = sa_proto_get_featureset(protocol);
	if (!(features & SA_FEATURE_SERVER)) {
		(void) printf(
		    gettext("Protocol \"%s\" not supported.\n"), protocol);
		return (SA_INVALID_PROTOCOL);
	}

	/*
	 * Check to see if the new protocol is one that requires
	 * resource names and make sure we are compliant before
	 * proceeding.
	 */
	if ((features & SA_FEATURE_RESOURCE) &&
	    !resource_compliant(group)) {
		if (force && !dryrun) {
			make_resources(group);
		} else {
			(void) printf(
			    gettext("Protocol requires resource names to be "
			    "set: %s\n"), protocol);
			return (SA_RESOURCE_REQUIRED);
		}
	}
	return (SA_OK);
}

/*
 * set_all_protocols(group)
 *
 * Get the list of all protocols and add all server protocols to the
 * group.
 */

static int
set_all_protocols(sa_group_t group)
{
	char **protolist;
	int numprotos, i;
	uint64_t features;
	sa_optionset_t optionset;
	int ret = SA_OK;

	/*
	 * Now make sure we really want to put this protocol on a
	 * group. Only server protocols can go here.
	 */
	numprotos = sa_get_protocols(&protolist);
	for (i = 0; i < numprotos; i++) {
		features = sa_proto_get_featureset(protolist[i]);
		if (features & SA_FEATURE_SERVER) {
			optionset = sa_create_optionset(group, protolist[i]);
			if (optionset == NULL) {
				ret = SA_NO_MEMORY;
				break;
			}
		}
	}

	if (protolist != NULL)
		free(protolist);

	return (ret);
}

/*
 * sa_create(flags, argc, argv)
 *	create a new group
 *	this may or may not have a protocol associated with it.
 *	No protocol means "all" protocols in this case.
 */
static int
sa_create(sa_handle_t handle, int flags, int argc, char *argv[])
{
	char *groupname;

	sa_group_t group;
	boolean_t force = B_FALSE;
	boolean_t verbose = B_FALSE;
	boolean_t dryrun = B_FALSE;
	int c;
	char *protocol = NULL;
	int ret = SA_OK;
	struct options *optlist = NULL;
	int err = SA_OK;
	int auth;
	boolean_t created = B_FALSE;

	while ((c = getopt(argc, argv, "?fhvnP:p:")) != EOF) {
		switch (c) {
		case 'f':
			force = B_TRUE;
			break;
		case 'v':
			verbose = B_TRUE;
			break;
		case 'n':
			dryrun = B_TRUE;
			break;
		case 'P':
			if (protocol != NULL) {
				(void) printf(gettext("Specifying "
				    "multiple protocols "
				    "not supported: %s\n"), protocol);
				return (SA_SYNTAX_ERR);
			}
			protocol = optarg;
			if (sa_valid_protocol(protocol))
				break;
			(void) printf(gettext(
			    "Invalid protocol specified: %s\n"), protocol);
			return (SA_INVALID_PROTOCOL);
		case 'p':
			ret = add_opt(&optlist, optarg, 0);
			switch (ret) {
			case OPT_ADD_SYNTAX:
				(void) printf(gettext(
				    "Property syntax error for property: %s\n"),
				    optarg);
				return (SA_SYNTAX_ERR);
			case OPT_ADD_SECURITY:
				(void) printf(gettext(
				    "Security properties need "
				    "to be set with set-security: %s\n"),
				    optarg);
				return (SA_SYNTAX_ERR);
			default:
				break;
			}
			break;
		case 'h':
			/* optopt on valid arg isn't defined */
			optopt = c;
			/*FALLTHROUGH*/
		case '?':
		default:
			/*
			 * Since a bad option gets to here, sort it
			 * out and return a syntax error return value
			 * if necessary.
			 */
			switch (optopt) {
			default:
				err = SA_SYNTAX_ERR;
				break;
			case 'h':
			case '?':
				break;
			}
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_CREATE));
			return (err);
		}
	}

	if (optind >= argc) {
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_CREATE));
		(void) printf(gettext("\tgroup must be specified.\n"));
		return (SA_BAD_PATH);
	}

	if ((optind + 1) < argc) {
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_CREATE));
		(void) printf(gettext("\textraneous group(s) at end\n"));
		return (SA_SYNTAX_ERR);
	}

	if (protocol == NULL && optlist != NULL) {
		/* lookup default protocol */
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_CREATE));
		(void) printf(gettext("\tprotocol must be specified "
		    "with properties\n"));
		return (SA_INVALID_PROTOCOL);
	}

	if (optlist != NULL)
		ret = chk_opt(optlist, 0, protocol);
	if (ret == OPT_ADD_SECURITY) {
		(void) printf(gettext("Security properties not "
		    "supported with create\n"));
		return (SA_SYNTAX_ERR);
	}

	/*
	 * If a group already exists, we can only add a new protocol
	 * to it and not create a new one or add the same protocol
	 * again.
	 */

	groupname = argv[optind];

	auth = check_authorizations(groupname, flags);

	group = sa_get_group(handle, groupname);
	if (group != NULL) {
		/* group exists so must be a protocol add */
		ret = check_valid_group(group, groupname, protocol);
	} else {
		/*
		 * is it a valid name? Must comply with SMF instance
		 * name restrictions.
		 */
		if (!sa_valid_group_name(groupname)) {
			ret = SA_INVALID_NAME;
			(void) printf(gettext("Invalid group name: %s\n"),
			    groupname);
		}
	}
	if (ret == SA_OK) {
		/* check protocol vs optlist */
		if (optlist != NULL) {
			/* check options, if any, for validity */
			ret = valid_options(handle, optlist, protocol,
			    group, NULL);
		}
	}
	if (ret == SA_OK && !dryrun) {
		if (group == NULL) {
			group = sa_create_group(handle, (char *)groupname,
			    &err);
			created = B_TRUE;
		}
		if (group != NULL) {
			sa_optionset_t optionset;

			/*
			 * Check group and protocol against featureset
			 * requirements.
			 */
			ret = enforce_featureset(group, protocol,
			    dryrun, force);
			if (ret != SA_OK)
				goto err;

			/*
			 * So far so good. Now add the required
			 * optionset(s) to the group.
			 */
			if (optlist != NULL) {
				(void) add_optionset(group, optlist, protocol,
				    &ret);
			} else if (protocol != NULL) {
				optionset = sa_create_optionset(group,
				    protocol);
				if (optionset == NULL)
					ret = SA_NO_MEMORY;
			} else if (protocol == NULL) {
				/* default group create so add all protocols */
				ret = set_all_protocols(group);
			}
			/*
			 * We have a group and legal additions
			 */
			if (ret == SA_OK) {
				/*
				 * Commit to configuration for protocols that
				 * need to do block updates. For NFS, this
				 * doesn't do anything but it will be run for
				 * all protocols that implement the
				 * appropriate plugin.
				 */
				ret = sa_update_config(handle);
			} else {
				if (group != NULL)
					(void) sa_remove_group(group);
			}
		} else {
			ret = err;
			(void) printf(gettext("Could not create group: %s\n"),
			    sa_errorstr(ret));
		}
	}
	if (dryrun && ret == SA_OK && !auth && verbose) {
		(void) printf(gettext("Command would fail: %s\n"),
		    sa_errorstr(SA_NO_PERMISSION));
		ret = SA_NO_PERMISSION;
	}
err:
	if (ret != SA_OK && created)
		ret = sa_remove_group(group);

	free_opt(optlist);
	return (ret);
}

/*
 * group_status(group)
 *
 * return the current status (enabled/disabled) of the group.
 */

static char *
group_status(sa_group_t group)
{
	char *state;
	int enabled = 0;

	state = sa_get_group_attr(group, "state");
	if (state != NULL) {
		if (strcmp(state, "enabled") == 0) {
			enabled = 1;
		}
		sa_free_attr_string(state);
	}
	return (enabled ? "enabled" : "disabled");
}

/*
 * sa_delete(flags, argc, argv)
 *
 *	Delete a group.
 */

static int
sa_delete(sa_handle_t handle, int flags, int argc, char *argv[])
{
	char *groupname;
	sa_group_t group;
	sa_share_t share;
	int verbose = 0;
	int dryrun = 0;
	int force = 0;
	int c;
	char *protocol = NULL;
	char *sectype = NULL;
	int ret = SA_OK;
	int auth;

	while ((c = getopt(argc, argv, "?hvnP:fS:")) != EOF) {
		switch (c) {
		case 'v':
			verbose++;
			break;
		case 'n':
			dryrun++;
			break;
		case 'P':
			if (protocol != NULL) {
				(void) printf(gettext("Specifying "
				    "multiple protocols "
				    "not supported: %s\n"), protocol);
				return (SA_SYNTAX_ERR);
			}
			protocol = optarg;
			if (!sa_valid_protocol(protocol)) {
				(void) printf(gettext("Invalid protocol "
				    "specified: %s\n"), protocol);
				return (SA_INVALID_PROTOCOL);
			}
			break;
		case 'S':
			if (sectype != NULL) {
				(void) printf(gettext("Specifying "
				    "multiple property "
				    "spaces not supported: %s\n"), sectype);
				return (SA_SYNTAX_ERR);
			}
			sectype = optarg;
			break;
		case 'f':
			force++;
			break;
		case 'h':
			/* optopt on valid arg isn't defined */
			optopt = c;
			/*FALLTHROUGH*/
		case '?':
		default:
			/*
			 * Since a bad option gets to here, sort it
			 * out and return a syntax error return value
			 * if necessary.
			 */
			switch (optopt) {
			default:
				ret = SA_SYNTAX_ERR;
				break;
			case 'h':
			case '?':
				break;
			}
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_DELETE));
			return (ret);
		}
	}

	if (optind >= argc) {
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_DELETE));
		(void) printf(gettext("\tgroup must be specified.\n"));
		return (SA_SYNTAX_ERR);
	}

	if ((optind + 1) < argc) {
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_DELETE));
		(void) printf(gettext("\textraneous group(s) at end\n"));
		return (SA_SYNTAX_ERR);
	}

	if (sectype != NULL && protocol == NULL) {
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_DELETE));
		(void) printf(gettext("\tsecurity requires protocol to be "
		    "specified.\n"));
		return (SA_SYNTAX_ERR);
	}

	/*
	 * Determine if the group already exists since it must in
	 * order to be removed.
	 *
	 * We can delete when:
	 *
	 *	- group is empty
	 *	- force flag is set
	 *	- if protocol specified, only delete the protocol
	 */

	groupname = argv[optind];
	group = sa_get_group(handle, groupname);
	if (group == NULL) {
		ret = SA_NO_SUCH_GROUP;
		goto done;
	}
	auth = check_authorizations(groupname, flags);
	if (protocol == NULL) {
		share = sa_get_share(group, NULL);
		if (share != NULL)
			ret = SA_BUSY;
		if (share == NULL || (share != NULL && force == 1)) {
			ret = SA_OK;
			if (!dryrun) {
				while (share != NULL) {
					sa_share_t next_share;
					next_share = sa_get_next_share(share);
					/*
					 * need to do the disable of
					 * each share, but don't
					 * actually do anything on a
					 * dryrun.
					 */
					ret = sa_disable_share(share, NULL);
					ret = sa_remove_share(share);
					share = next_share;
				}
				ret = sa_remove_group(group);
			}
		}
		/* Commit to configuration if not a dryrun */
		if (!dryrun && ret == SA_OK) {
			ret = sa_update_config(handle);
		}
	} else {
		/* a protocol delete */
		sa_optionset_t optionset;
		sa_security_t security;
		if (sectype != NULL) {
			/* only delete specified security */
			security = sa_get_security(group, sectype, protocol);
			if (security != NULL && !dryrun)
				ret = sa_destroy_security(security);
			else
				ret = SA_INVALID_PROTOCOL;
		} else {
			optionset = sa_get_optionset(group, protocol);
			if (optionset != NULL && !dryrun) {
				/*
				 * have an optionset with
				 * protocol to delete
				 */
				ret = sa_destroy_optionset(optionset);
				/*
				 * Now find all security sets
				 * for the protocol and remove
				 * them. Don't remove other
				 * protocols.
				 */
				for (security =
				    sa_get_security(group, NULL, NULL);
				    ret == SA_OK && security != NULL;
				    security = sa_get_next_security(security)) {
					char *secprot;
					secprot = sa_get_security_attr(security,
					    "type");
					if (secprot != NULL &&
					    strcmp(secprot, protocol) == 0)
						ret = sa_destroy_security(
						    security);
					if (secprot != NULL)
						sa_free_attr_string(secprot);
				}
			} else {
				if (!dryrun)
					ret = SA_INVALID_PROTOCOL;
			}
		}
		/*
		 * With the protocol items removed, make sure that all
		 * the shares are updated in the legacy files, if
		 * necessary.
		 */
		for (share = sa_get_share(group, NULL);
		    share != NULL;
		    share = sa_get_next_share(share)) {
			(void) sa_delete_legacy(share, protocol);
		}
	}

done:
	if (ret != SA_OK) {
		(void) printf(gettext("Could not delete group: %s\n"),
		    sa_errorstr(ret));
	} else if (dryrun && !auth && verbose) {
		(void) printf(gettext("Command would fail: %s\n"),
		    sa_errorstr(SA_NO_PERMISSION));
	}
	return (ret);
}

/*
 * strndupr(*buff, str, buffsize)
 *
 * used with small strings to duplicate and possibly increase the
 * buffer size of a string.
 */
static char *
strndupr(char *buff, char *str, int *buffsize)
{
	int limit;
	char *orig_buff = buff;

	if (buff == NULL) {
		buff = (char *)malloc(64);
		if (buff == NULL)
			return (NULL);
		*buffsize = 64;
		buff[0] = '\0';
	}
	limit = strlen(buff) + strlen(str) + 1;
	if (limit > *buffsize) {
		limit = *buffsize = *buffsize + ((limit / 64) + 64);
		buff = realloc(buff, limit);
	}
	if (buff != NULL) {
		(void) strcat(buff, str);
	} else {
		/* if it fails, fail it hard */
		if (orig_buff != NULL)
			free(orig_buff);
	}
	return (buff);
}

/*
 * group_proto(group)
 *
 * return a string of all the protocols (space separated) associated
 * with this group.
 */

static char *
group_proto(sa_group_t group)
{
	sa_optionset_t optionset;
	char *proto;
	char *buff = NULL;
	int buffsize = 0;
	int addspace = 0;
	/*
	 * get the protocol list by finding the optionsets on this
	 * group and extracting the type value. The initial call to
	 * strndupr() initailizes buff.
	 */
	buff = strndupr(buff, "", &buffsize);
	if (buff != NULL) {
		for (optionset = sa_get_optionset(group, NULL);
		    optionset != NULL && buff != NULL;
		    optionset = sa_get_next_optionset(optionset)) {
			/*
			 * extract out the protocol type from this optionset
			 * and append it to the buffer "buff". strndupr() will
			 * reallocate space as necessay.
			 */
			proto = sa_get_optionset_attr(optionset, "type");
			if (proto != NULL) {
				if (addspace++)
					buff = strndupr(buff, " ", &buffsize);
				buff = strndupr(buff, proto, &buffsize);
				sa_free_attr_string(proto);
			}
		}
	}
	return (buff);
}

/*
 * sa_list(flags, argc, argv)
 *
 * implements the "list" subcommand to list groups and optionally
 * their state and protocols.
 */

static int
sa_list(sa_handle_t handle, int flags, int argc, char *argv[])
{
	sa_group_t group;
	int verbose = 0;
	int c;
	char *protocol = NULL;
	int ret = SA_OK;
#ifdef lint
	flags = flags;
#endif

	while ((c = getopt(argc, argv, "?hvP:")) != EOF) {
		switch (c) {
		case 'v':
			verbose++;
			break;
		case 'P':
			if (protocol != NULL) {
				(void) printf(gettext(
				    "Specifying multiple protocols "
				    "not supported: %s\n"),
				    protocol);
				return (SA_SYNTAX_ERR);
			}
			protocol = optarg;
			if (!sa_valid_protocol(protocol)) {
				(void) printf(gettext(
				    "Invalid protocol specified: %s\n"),
				    protocol);
				return (SA_INVALID_PROTOCOL);
			}
			break;
		case 'h':
			/* optopt on valid arg isn't defined */
			optopt = c;
			/*FALLTHROUGH*/
		case '?':
		default:
			/*
			 * Since a bad option gets to here, sort it
			 * out and return a syntax error return value
			 * if necessary.
			 */
			switch (optopt) {
			default:
				ret = SA_SYNTAX_ERR;
				break;
			case 'h':
			case '?':
				break;
			}
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_LIST));
				return (ret);
		}
	}

	if (optind != argc) {
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_LIST));
		return (SA_SYNTAX_ERR);
	}

	for (group = sa_get_group(handle, NULL);
	    group != NULL;
	    group = sa_get_next_group(group)) {
		char *name;
		char *proto;
		if (protocol == NULL || has_protocol(group, protocol)) {
			name = sa_get_group_attr(group, "name");
			if (name != NULL && (verbose > 1 || name[0] != '#')) {
				(void) printf("%s", (char *)name);
				if (verbose) {
					/*
					 * Need the list of protocols
					 * and current status once
					 * available. We do want to
					 * translate the
					 * enabled/disabled text here.
					 */
					(void) printf("\t%s", isenabled(group) ?
					    gettext("enabled") :
					    gettext("disabled"));
					proto = group_proto(group);
					if (proto != NULL) {
						(void) printf("\t%s",
						    (char *)proto);
						free(proto);
					}
				}
				(void) printf("\n");
			}
			if (name != NULL)
				sa_free_attr_string(name);
		}
	}
	return (0);
}

/*
 * out_properties(optionset, proto, sec)
 *
 * Format the properties and encode the protocol and optional named
 * optionset into the string.
 *
 * format is protocol[:name]=(property-list)
 */

static void
out_properties(sa_optionset_t optionset, char *proto, char *sec)
{
	char *type;
	char *value;
	int spacer;
	sa_property_t prop;

	if (sec == NULL)
		(void) printf(" %s=(", proto ? proto : gettext("all"));
	else
		(void) printf(" %s:%s=(", proto ? proto : gettext("all"), sec);

	for (spacer = 0, prop = sa_get_property(optionset, NULL);
	    prop != NULL;
	    prop = sa_get_next_property(prop)) {

		/*
		 * extract the property name/value and output with
		 * appropriate spacing. I.e. no prefixed space the
		 * first time through but a space on subsequent
		 * properties.
		 */
		type = sa_get_property_attr(prop, "type");
		value = sa_get_property_attr(prop, "value");
		if (type != NULL) {
			(void) printf("%s%s=", spacer ? " " : "",	type);
			spacer = 1;
			if (value != NULL)
				(void) printf("\"%s\"", value);
			else
				(void) printf("\"\"");
		}
		if (type != NULL)
			sa_free_attr_string(type);
		if (value != NULL)
			sa_free_attr_string(value);
	}
	(void) printf(")");
}

/*
 * show_properties(group, protocol, prefix)
 *
 * print the properties for a group. If protocol is NULL, do all
 * protocols otherwise only the specified protocol. All security
 * (named groups specific to the protocol) are included.
 *
 * The "prefix" is always applied. The caller knows whether it wants
 * some type of prefix string (white space) or not.  Once the prefix
 * has been output, it is reduced to the zero length string for the
 * remainder of the property output.
 */

static void
show_properties(sa_group_t group, char *protocol, char *prefix)
{
	sa_optionset_t optionset;
	sa_security_t security;
	char *value;
	char *secvalue;

	if (protocol != NULL) {
		optionset = sa_get_optionset(group, protocol);
		if (optionset != NULL) {
			(void) printf("%s", prefix);
			prefix = "";
			out_properties(optionset, protocol, NULL);
		}
		security = sa_get_security(group, protocol, NULL);
		if (security != NULL) {
			(void) printf("%s", prefix);
			prefix = "";
			out_properties(security, protocol, NULL);
		}
	} else {
		for (optionset = sa_get_optionset(group, protocol);
		    optionset != NULL;
		    optionset = sa_get_next_optionset(optionset)) {

			value = sa_get_optionset_attr(optionset, "type");
			(void) printf("%s", prefix);
			prefix = "";
			out_properties(optionset, value, 0);
			if (value != NULL)
				sa_free_attr_string(value);
		}
		for (security = sa_get_security(group, NULL, protocol);
		    security != NULL;
		    security = sa_get_next_security(security)) {

			value = sa_get_security_attr(security, "type");
			secvalue = sa_get_security_attr(security, "sectype");
			(void) printf("%s", prefix);
			prefix = "";
			out_properties(security, value, secvalue);
			if (value != NULL)
				sa_free_attr_string(value);
			if (secvalue != NULL)
				sa_free_attr_string(secvalue);
		}
	}
}

/*
 * get_resource(share)
 *
 * Get the first resource name, if any, and fix string to be in
 * current locale and have quotes if it has embedded spaces.  Return
 * an attr string that must be freed.
 */

static char *
get_resource(sa_share_t share)
{
	sa_resource_t resource;
	char *resstring = NULL;
	char *retstring;

	if ((resource = sa_get_share_resource(share, NULL)) != NULL) {
		resstring = sa_get_resource_attr(resource, "name");
		if (resstring != NULL) {
			char *cp;
			int len;

			retstring = conv_from_utf8(resstring);
			if (retstring != resstring) {
				sa_free_attr_string(resstring);
				resstring = retstring;
			}
			if (strpbrk(resstring, " ") != NULL) {
				/* account for quotes */
				len = strlen(resstring) + 3;
				cp = calloc(len, sizeof (char));
				if (cp != NULL) {
					(void) snprintf(cp, len,
					    "\"%s\"", resstring);
					sa_free_attr_string(resstring);
					resstring = cp;
				} else {
					sa_free_attr_string(resstring);
					resstring = NULL;
				}
			}
		}
	}
	return (resstring);
}

/*
 * has_resource_with_opt(share)
 *
 * Check to see if the share has any resource names with optionsets
 * set. Also indicate if multiple resource names since the syntax
 * would be about the same.
 */
static int
has_resource_with_opt(sa_share_t share)
{
	sa_resource_t resource;
	int ret = B_FALSE;

	for (resource = sa_get_share_resource(share, NULL);
	    resource != NULL;
	    resource = sa_get_next_resource(resource)) {

		if (sa_get_optionset(resource, NULL) != NULL) {
			ret = B_TRUE;
			break;
		}
	}
	return (ret);
}

/*
 * has_multiple_resource(share)
 *
 * Check to see if the share has multiple resource names since
 * the syntax would be about the same.
 */
static boolean_t
has_multiple_resource(sa_share_t share)
{
	sa_resource_t resource;
	int num;

	for (num = 0, resource = sa_get_share_resource(share, NULL);
	    resource != NULL;
	    resource = sa_get_next_resource(resource)) {
		num++;
		if (num > 1)
			return (B_TRUE);
	}
	return (B_FALSE);
}

/*
 * show_share(share, verbose, properties, proto, iszfs, sharepath)
 *
 * print out the share information. With the addition of resource as a
 * full object that can have multiple instances below the share, we
 * need to display that as well.
 */

static void
show_share(sa_share_t share, int verbose, int properties, char *proto,
    int iszfs, char *sharepath)
{
	char *drive;
	char *exclude;
	sa_resource_t resource = NULL;
	char *description;
	char *rsrcname;
	int rsrcwithopt;
	boolean_t multiple;
	char *type;

	rsrcwithopt = has_resource_with_opt(share);

	if (verbose || (properties && rsrcwithopt)) {
		/* First, indicate if transient */
		type = sa_get_share_attr(share, "type");
		if (type != NULL && !iszfs && verbose &&
		    strcmp(type, "transient") == 0)
			(void) printf("\t* ");
		else
			(void) printf("\t  ");

		if (type != NULL)
			sa_free_attr_string(type);

		/*
		 * If we came in with verbose, we want to handle the case of
		 * multiple resources as though they had properties set.
		 */
		multiple = has_multiple_resource(share);

		/*
		 * if there is a description on the share and there
		 * are resources, treat as multiple resources in order
		 * to get all descriptions displayed.
		 */
		description = sa_get_share_description(share);
		resource = sa_get_share_resource(share, NULL);

		if (description != NULL && resource != NULL)
			multiple = B_TRUE;

		/* Next, if not multiple follow old model */
		if (!multiple && !rsrcwithopt) {
			rsrcname = get_resource(share);
			if (rsrcname != NULL && strlen(rsrcname) > 0) {
				(void) printf("%s=%s", rsrcname, sharepath);
			} else {
				(void) printf("%s", sharepath);
			}
			if (rsrcname != NULL)
				sa_free_attr_string(rsrcname);
			/* Print the description string if there is one. */
			print_rsrc_desc(resource, description);
		} else {
			/* Treat as simple and then resources come later */
			(void) printf("%s", sharepath);
		}
		drive = sa_get_share_attr(share, "drive-letter");
		if (drive != NULL) {
			if (strlen(drive) > 0)
				(void) printf(gettext("\tdrive-letter=\"%s:\""),
				    drive);
			sa_free_attr_string(drive);
		}
		if (properties)
			show_properties(share, proto, "\t");
		exclude = sa_get_share_attr(share, "exclude");
		if (exclude != NULL) {
			(void) printf(gettext("\tnot-shared-with=[%s]"),
			    exclude);
			sa_free_attr_string(exclude);
		}

		if (description != NULL) {
			print_rsrc_desc((sa_resource_t)share, description);
		}
		/*
		 * If there are resource names with options, show them
		 * here, with one line per resource. Resource specific
		 * options are at the end of the line followed by
		 * description, if any.
		 */
		if (rsrcwithopt || multiple) {
			for (resource = sa_get_share_resource(share, NULL);
			    resource != NULL;
			    resource = sa_get_next_resource(resource)) {
				int has_space;
				char *rsrc;

				(void) printf("\n\t\t  ");
				rsrcname = sa_get_resource_attr(resource,
				    "name");
				if (rsrcname == NULL)
					continue;

				rsrc = conv_from_utf8(rsrcname);
				has_space = strpbrk(rsrc, " ") != NULL;

				if (has_space)
					(void) printf("\"%s\"=%s", rsrc,
					    sharepath);
				else
					(void) printf("%s=%s", rsrc,
					    sharepath);
				if (rsrc != rsrcname)
					sa_free_attr_string(rsrc);
				sa_free_attr_string(rsrcname);
				if (properties || rsrcwithopt)
					show_properties(resource, proto, "\t");

				/* Get description string if any */
				print_rsrc_desc(resource, description);
			}
		}
		if (description != NULL)
			sa_free_share_description(description);
	} else {
		(void) printf("\t  %s", sharepath);
		if (properties)
			show_properties(share, proto, "\t");
	}
	(void) printf("\n");
}

/*
 * show_group(group, verbose, properties, proto, subgroup)
 *
 * helper function to show the contents of a group.
 */

static void
show_group(sa_group_t group, int verbose, int properties, char *proto,
    char *subgroup)
{
	sa_share_t share;
	char *groupname;
	char *zfs = NULL;
	int iszfs = 0;
	char *sharepath;

	groupname = sa_get_group_attr(group, "name");
	if (groupname != NULL) {
		if (proto != NULL && !has_protocol(group, proto)) {
			sa_free_attr_string(groupname);
			return;
		}
		/*
		 * check to see if the group is managed by ZFS. If
		 * there is an attribute, then it is. A non-NULL zfs
		 * variable will trigger the different way to display
		 * and will remove the transient property indicator
		 * from the output.
		 */
		zfs = sa_get_group_attr(group, "zfs");
		if (zfs != NULL) {
			iszfs = 1;
			sa_free_attr_string(zfs);
		}
		share = sa_get_share(group, NULL);
		if (subgroup == NULL)
			(void) printf("%s", groupname);
		else
			(void) printf("    %s/%s", subgroup, groupname);
		if (properties)
			show_properties(group, proto, "");
		(void) printf("\n");
		if (strcmp(groupname, "zfs") == 0) {
			sa_group_t zgroup;

			for (zgroup = sa_get_sub_group(group);
			    zgroup != NULL;
			    zgroup = sa_get_next_group(zgroup)) {
				show_group(zgroup, verbose, properties, proto,
				    "zfs");
			}
			sa_free_attr_string(groupname);
			return;
		}
		/*
		 * Have a group, so list the contents. Resource and
		 * description are only listed if verbose is set.
		 */
		for (share = sa_get_share(group, NULL);
		    share != NULL;
		    share = sa_get_next_share(share)) {
			sharepath = sa_get_share_attr(share, "path");
			if (sharepath != NULL) {
				show_share(share, verbose, properties, proto,
				    iszfs, sharepath);
				sa_free_attr_string(sharepath);
			}
		}
	}
	if (groupname != NULL) {
		sa_free_attr_string(groupname);
	}
}

/*
 * show_group_xml_init()
 *
 * Create an XML document that will be used to display config info via
 * XML format.
 */

xmlDocPtr
show_group_xml_init()
{
	xmlDocPtr doc;
	xmlNodePtr root;

	doc = xmlNewDoc((xmlChar *)"1.0");
	if (doc != NULL) {
		root = xmlNewNode(NULL, (xmlChar *)"sharecfg");
		if (root != NULL)
			(void) xmlDocSetRootElement(doc, root);
	}
	return (doc);
}

/*
 * show_group_xml(doc, group)
 *
 * Copy the group info into the XML doc.
 */

static void
show_group_xml(xmlDocPtr doc, sa_group_t group)
{
	xmlNodePtr node;
	xmlNodePtr root;

	root = xmlDocGetRootElement(doc);
	node = xmlCopyNode((xmlNodePtr)group, 1);
	if (node != NULL && root != NULL) {
		(void) xmlAddChild(root, node);
		/*
		 * In the future, we may have interally used tags that
		 * should not appear in the XML output. Remove
		 * anything we don't want to show here.
		 */
	}
}

/*
 * sa_show(flags, argc, argv)
 *
 * Implements the show subcommand.
 */

int
sa_show(sa_handle_t handle, int flags, int argc, char *argv[])
{
	sa_group_t group;
	int verbose = 0;
	int properties = 0;
	int c;
	int ret = SA_OK;
	char *protocol = NULL;
	int xml = 0;
	xmlDocPtr doc;
#ifdef lint
	flags = flags;
#endif

	while ((c = getopt(argc, argv, "?hvP:px")) !=	EOF) {
		switch (c) {
		case 'v':
			verbose++;
			break;
		case 'p':
			properties++;
			break;
		case 'P':
			if (protocol != NULL) {
				(void) printf(gettext(
				    "Specifying multiple protocols "
				    "not supported: %s\n"),
				    protocol);
				return (SA_SYNTAX_ERR);
			}
			protocol = optarg;
			if (!sa_valid_protocol(protocol)) {
				(void) printf(gettext(
				    "Invalid protocol specified: %s\n"),
				    protocol);
				return (SA_INVALID_PROTOCOL);
			}
			break;
		case 'x':
			xml++;
			break;
		case 'h':
			/* optopt on valid arg isn't defined */
			optopt = c;
			/*FALLTHROUGH*/
		case '?':
		default:
			/*
			 * Since a bad option gets to here, sort it
			 * out and return a syntax error return value
			 * if necessary.
			 */
			switch (optopt) {
			default:
				ret = SA_SYNTAX_ERR;
				break;
			case 'h':
			case '?':
				break;
			}
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_SHOW));
			return (ret);
		}
	}

	if (xml) {
		doc = show_group_xml_init();
		if (doc == NULL)
			ret = SA_NO_MEMORY;
	}

	if (optind == argc) {
		/* No group specified so go through them all */
		for (group = sa_get_group(handle, NULL);
		    group != NULL;
		    group = sa_get_next_group(group)) {
			/*
			 * Have a group so check if one we want and then list
			 * contents with appropriate options.
			 */
			if (xml)
				show_group_xml(doc, group);
			else
				show_group(group, verbose, properties, protocol,
				    NULL);
		}
	} else {
		/* Have a specified list of groups */
		for (; optind < argc; optind++) {
			group = sa_get_group(handle, argv[optind]);
			if (group != NULL) {
				if (xml)
					show_group_xml(doc, group);
				else
					show_group(group, verbose, properties,
					    protocol, NULL);
			} else {
				(void) printf(gettext("%s: not found\n"),
				    argv[optind]);
				ret = SA_NO_SUCH_GROUP;
			}
		}
	}
	if (xml && ret == SA_OK) {
		(void) xmlDocFormatDump(stdout, doc, 1);
		xmlFreeDoc(doc);
	}
	return (ret);

}

/*
 * enable_share(group, share, update_legacy)
 *
 * helper function to enable a share if the group is enabled.
 */

static int
enable_share(sa_handle_t handle, sa_group_t group, sa_share_t share,
    int update_legacy)
{
	char *value;
	int enabled;
	sa_optionset_t optionset;
	int err;
	int ret = SA_OK;
	char *zfs = NULL;
	int iszfs = 0;
	int isshare;

	/*
	 * need to enable this share if the group is enabled but not
	 * otherwise. The enable is also done on each protocol
	 * represented in the group.
	 */
	value = sa_get_group_attr(group, "state");
	enabled = value != NULL && strcmp(value, "enabled") == 0;
	if (value != NULL)
		sa_free_attr_string(value);
	/* remove legacy config if necessary */
	if (update_legacy)
		ret = sa_delete_legacy(share, NULL);
	zfs = sa_get_group_attr(group, "zfs");
	if (zfs != NULL) {
		iszfs++;
		sa_free_attr_string(zfs);
	}

	/*
	 * Step through each optionset at the group level and
	 * enable the share based on the protocol type. This
	 * works because protocols must be set on the group
	 * for the protocol to be enabled.
	 */
	isshare = sa_is_share(share);
	for (optionset = sa_get_optionset(group, NULL);
	    optionset != NULL && ret == SA_OK;
	    optionset = sa_get_next_optionset(optionset)) {
		value = sa_get_optionset_attr(optionset, "type");
		if (value != NULL) {
			if (enabled) {
				if (isshare) {
					err = sa_enable_share(share, value);
				} else {
					err = sa_enable_resource(share, value);
					if (err == SA_NOT_SUPPORTED) {
						sa_share_t parent;
						parent = sa_get_resource_parent(
						    share);
						if (parent != NULL)
							err = sa_enable_share(
							    parent, value);
					}
				}
				if (err != SA_OK) {
					ret = err;
					(void) printf(gettext(
					    "Failed to enable share for "
					    "\"%s\": %s\n"),
					    value, sa_errorstr(ret));
				}
			}
			/*
			 * If we want to update the legacy, use a copy of
			 * share so we can avoid breaking the loop we are in
			 * since we might also need to go up the tree to the
			 * parent.
			 */
			if (update_legacy && !iszfs) {
				sa_share_t update = share;
				if (!sa_is_share(share)) {
					update = sa_get_resource_parent(share);
				}
				(void) sa_update_legacy(update, value);
			}
			sa_free_attr_string(value);
		}
	}
	if (ret == SA_OK)
		(void) sa_update_config(handle);
	return (ret);
}

/*
 * sa_require_resource(group)
 *
 * if any of the defined protocols on the group require resource
 * names, then all shares must have them.
 */

static int
sa_require_resource(sa_group_t group)
{
	sa_optionset_t optionset;

	for (optionset = sa_get_optionset(group, NULL);
	    optionset != NULL;
	    optionset = sa_get_next_optionset(optionset)) {
		char *proto;

		proto = sa_get_optionset_attr(optionset, "type");
		if (proto != NULL) {
			uint64_t features;

			features = sa_proto_get_featureset(proto);
			if (features & SA_FEATURE_RESOURCE) {
				sa_free_attr_string(proto);
				return (B_TRUE);
			}
			sa_free_attr_string(proto);
		}
	}
	return (B_FALSE);
}

/*
 * sa_addshare(flags, argc, argv)
 *
 * implements add-share subcommand.
 */

static int
sa_addshare(sa_handle_t handle, int flags, int argc, char *argv[])
{
	int verbose = 0;
	int dryrun = 0;
	int c;
	int ret = SA_OK;
	sa_group_t group;
	sa_share_t share;
	sa_resource_t resource = NULL;
	char *sharepath = NULL;
	char *description = NULL;
	char *rsrcname = NULL;
	char *rsrc = NULL;
	int persist = SA_SHARE_PERMANENT; /* default to persist */
	int auth;
	char dir[MAXPATHLEN];

	while ((c = getopt(argc, argv, "?hvns:d:r:t")) != EOF) {
		switch (c) {
		case 'n':
			dryrun++;
			break;
		case 'v':
			verbose++;
			break;
		case 'd':
			description = optarg;
			break;
		case 'r':
			if (rsrcname != NULL) {
				(void) printf(gettext("Adding multiple "
				    "resource names not"
				    " supported\n"));
				return (SA_SYNTAX_ERR);
			}
			rsrcname = optarg;
			break;
		case 's':
			/*
			 * Save share path into group. Currently limit
			 * to one share per command.
			 */
			if (sharepath != NULL) {
				(void) printf(gettext(
				    "Adding multiple shares not supported\n"));
				return (SA_SYNTAX_ERR);
			}
			sharepath = optarg;
			break;
		case 't':
			persist = SA_SHARE_TRANSIENT;
			break;
		case 'h':
			/* optopt on valid arg isn't defined */
			optopt = c;
			/*FALLTHROUGH*/
		case '?':
		default:
			/*
			 * Since a bad option gets to here, sort it
			 * out and return a syntax error return value
			 * if necessary.
			 */
			switch (optopt) {
			default:
				ret = SA_SYNTAX_ERR;
				break;
			case 'h':
			case '?':
				break;
			}
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_ADD_SHARE));
			return (ret);
		}
	}

	if (optind >= argc) {
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_ADD_SHARE));
		if (dryrun || sharepath != NULL || description != NULL ||
		    rsrcname != NULL || verbose || persist) {
			(void) printf(gettext("\tgroup must be specified\n"));
			ret = SA_NO_SUCH_GROUP;
		} else {
			ret = SA_OK;
		}
	} else {
		if (sharepath == NULL) {
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_ADD_SHARE));
			(void) printf(gettext(
			    "\t-s sharepath must be specified\n"));
			ret = SA_BAD_PATH;
		}
		if (ret == SA_OK) {
			if (realpath(sharepath, dir) == NULL) {
				ret = SA_BAD_PATH;
				(void) printf(gettext("Path "
				    "is not valid: %s\n"),
				    sharepath);
			} else {
				sharepath = dir;
			}
		}
		if (ret == SA_OK && rsrcname != NULL) {
			/* check for valid syntax */
			if (validresource(rsrcname)) {
				rsrc = conv_to_utf8(rsrcname);
				resource = sa_find_resource(handle, rsrc);
				if (resource != NULL) {
					/*
					 * Resource names must be
					 * unique in the system
					 */
					ret = SA_DUPLICATE_NAME;
					(void) printf(gettext("usage: %s\n"),
					    sa_get_usage(USAGE_ADD_SHARE));
					(void) printf(gettext(
					    "\tresource names must be unique "
					    "in the system\n"));
				}
			} else {
				(void) printf(gettext("usage: %s\n"),
				    sa_get_usage(USAGE_ADD_SHARE));
				(void) printf(gettext(
				    "\tresource names use restricted "
				    "character set\n"));
				ret = SA_INVALID_NAME;
			}
		}

		if (ret != SA_OK) {
			if (rsrc != NULL && rsrcname != rsrc)
				sa_free_attr_string(rsrc);
			return (ret);
		}

		share = sa_find_share(handle, sharepath);
		if (share != NULL) {
			if (rsrcname == NULL) {
				/*
				 * Can only have a duplicate share if a new
				 * resource name is being added.
				 */
				ret = SA_DUPLICATE_NAME;
				(void) printf(gettext("Share path already "
				    "shared: %s\n"), sharepath);
			}
		}
		if (ret != SA_OK)
			return (ret);

		group = sa_get_group(handle, argv[optind]);
		if (group != NULL) {
			if (sa_require_resource(group) == B_TRUE &&
			    rsrcname == NULL) {
				(void) printf(gettext(
				    "Resource name is required "
				    "by at least one enabled protocol "
				    "in group\n"));
				return (SA_RESOURCE_REQUIRED);
			}
			if (share == NULL && ret == SA_OK) {
				if (dryrun)
					ret = sa_check_path(group, sharepath,
					    SA_CHECK_NORMAL);
				else
					share = sa_add_share(group, sharepath,
					    persist, &ret);
			}
			/*
			 * Make sure this isn't an attempt to put a resourced
			 * share into a different group than it already is in.
			 */
			if (share != NULL) {
				sa_group_t parent;
				parent = sa_get_parent_group(share);
				if (parent != group) {
					ret = SA_DUPLICATE_NAME;
					(void) printf(gettext(
					    "Share path already "
					    "shared: %s\n"), sharepath);
				}
			}
			if (!dryrun && share == NULL) {
				(void) printf(gettext(
				    "Could not add share: %s\n"),
				    sa_errorstr(ret));
			} else {
				auth = check_authorizations(argv[optind],
				    flags);
				if (!dryrun && ret == SA_OK) {
					if (rsrcname != NULL) {
						resource = sa_add_resource(
						    share,
						    rsrc,
						    SA_SHARE_PERMANENT,
						    &ret);
					}
					if (ret == SA_OK &&
					    description != NULL) {
						if (resource != NULL)
							ret =
							    set_resource_desc(
							    resource,
							    description);
						else
							ret =
							    set_share_desc(
							    share,
							    description);
					}
					if (ret == SA_OK) {
						/* now enable the share(s) */
						if (resource != NULL) {
							ret = enable_share(
							    handle,
							    group,
							    resource,
							    1);
						} else {
							ret = enable_share(
							    handle,
							    group,
							    share,
							    1);
						}
						ret = sa_update_config(handle);
					}
					switch (ret) {
					case SA_DUPLICATE_NAME:
						(void) printf(gettext(
						    "Resource name in"
						    "use: %s\n"),
						    rsrcname);
						break;
					default:
						(void) printf(gettext(
						    "Could not set "
						    "attribute: %s\n"),
						    sa_errorstr(ret));
						break;
					case SA_OK:
						break;
					}
				} else if (dryrun && ret == SA_OK &&
				    !auth && verbose) {
					(void) printf(gettext(
					    "Command would fail: %s\n"),
					    sa_errorstr(SA_NO_PERMISSION));
					ret = SA_NO_PERMISSION;
				}
			}
		} else {
			switch (ret) {
			default:
				(void) printf(gettext(
				    "Group \"%s\" not found\n"), argv[optind]);
				ret = SA_NO_SUCH_GROUP;
				break;
			case SA_BAD_PATH:
			case SA_DUPLICATE_NAME:
				break;
			}
		}
	}
	return (ret);
}

/*
 * sa_moveshare(flags, argc, argv)
 *
 * implements move-share subcommand.
 */

int
sa_moveshare(sa_handle_t handle, int flags, int argc, char *argv[])
{
	int verbose = 0;
	int dryrun = 0;
	int c;
	int ret = SA_OK;
	sa_group_t group;
	sa_share_t share;
	char *rsrcname = NULL;
	char *sharepath = NULL;
	int authsrc = 0, authdst = 0;
	char dir[MAXPATHLEN];

	while ((c = getopt(argc, argv, "?hvnr:s:")) != EOF) {
		switch (c) {
		case 'n':
			dryrun++;
			break;
		case 'v':
			verbose++;
			break;
		case 'r':
			if (rsrcname != NULL) {
				(void) printf(gettext(
				    "Moving multiple resource names not"
				    " supported\n"));
				return (SA_SYNTAX_ERR);
			}
			rsrcname = optarg;
			break;
		case 's':
			/*
			 * Remove share path from group. Currently limit
			 * to one share per command.
			 */
			if (sharepath != NULL) {
				(void) printf(gettext("Moving multiple shares"
				    " not supported\n"));
				return (SA_SYNTAX_ERR);
			}
			sharepath = optarg;
			break;
		case 'h':
			/* optopt on valid arg isn't defined */
			optopt = c;
			/*FALLTHROUGH*/
		case '?':
		default:
			/*
			 * Since a bad option gets to here, sort it
			 * out and return a syntax error return value
			 * if necessary.
			 */
			switch (optopt) {
			default:
				ret = SA_SYNTAX_ERR;
				break;
			case 'h':
			case '?':
				break;
			}
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_MOVE_SHARE));
			return (ret);
		}
	}

	if (optind >= argc || sharepath == NULL) {
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_MOVE_SHARE));
		if (dryrun || verbose || sharepath != NULL) {
			(void) printf(gettext("\tgroup must be specified\n"));
			ret = SA_NO_SUCH_GROUP;
		} else {
			if (sharepath == NULL) {
				ret = SA_SYNTAX_ERR;
				(void) printf(gettext(
				    "\tsharepath must be specified\n"));
			} else {
				ret = SA_OK;
			}
		}
	} else {
		sa_group_t parent;
		char *zfsold;
		char *zfsnew;

		if (sharepath == NULL) {
			(void) printf(gettext(
			    "sharepath must be specified with the -s "
			    "option\n"));
			return (SA_BAD_PATH);
		}
		group = sa_get_group(handle, argv[optind]);
		if (group == NULL) {
			(void) printf(gettext("Group \"%s\" not found\n"),
			    argv[optind]);
			return (SA_NO_SUCH_GROUP);
		}
		share = sa_find_share(handle, sharepath);
		/*
		 * If a share wasn't found, it may have been a symlink
		 * or has a trailing '/'. Try again after resolving
		 * with realpath().
		 */
		if (share == NULL) {
			if (realpath(sharepath, dir) == NULL) {
				(void) printf(gettext("Path "
				    "is not valid: %s\n"),
				    sharepath);
				return (SA_BAD_PATH);
			}
			sharepath = dir;
			share = sa_find_share(handle, sharepath);
		}
		if (share == NULL) {
			(void) printf(gettext("Share not found: %s\n"),
			    sharepath);
			return (SA_NO_SUCH_PATH);
		}
		authdst = check_authorizations(argv[optind], flags);

		parent = sa_get_parent_group(share);
		if (parent != NULL) {
			char *pname;
			pname = sa_get_group_attr(parent, "name");
			if (pname != NULL) {
				authsrc = check_authorizations(pname, flags);
				sa_free_attr_string(pname);
			}
			zfsold = sa_get_group_attr(parent, "zfs");
			zfsnew = sa_get_group_attr(group, "zfs");
			if ((zfsold != NULL && zfsnew == NULL) ||
			    (zfsold == NULL && zfsnew != NULL)) {
				ret = SA_NOT_ALLOWED;
			}
			if (zfsold != NULL)
				sa_free_attr_string(zfsold);
			if (zfsnew != NULL)
				sa_free_attr_string(zfsnew);
		}

		if (ret == SA_OK && parent != group && !dryrun) {
			char *oldstate;
			/*
			 * Note that the share may need to be
			 * "unshared" if the new group is disabled and
			 * the old was enabled or it may need to be
			 * share to update if the new group is
			 * enabled. We disable before the move and
			 * will have to enable after the move in order
			 * to cleanup entries for protocols that
			 * aren't in the new group.
			 */
			oldstate = sa_get_group_attr(parent, "state");
			if (oldstate != NULL) {
				/* enable_share determines what to do */
				if (strcmp(oldstate, "enabled") == 0)
					(void) sa_disable_share(share, NULL);
				sa_free_attr_string(oldstate);
			}
		}

		if (!dryrun && ret == SA_OK)
			ret = sa_move_share(group, share);

		/*
		 * Reenable and update any config information.
		 */
		if (ret == SA_OK && parent != group && !dryrun) {
			ret = sa_update_config(handle);

			(void) enable_share(handle, group, share, 1);
		}

		if (ret != SA_OK)
			(void) printf(gettext("Could not move share: %s\n"),
			    sa_errorstr(ret));

		if (dryrun && ret == SA_OK && !(authsrc & authdst) &&
		    verbose) {
			(void) printf(gettext("Command would fail: %s\n"),
			    sa_errorstr(SA_NO_PERMISSION));
		}
	}
	return (ret);
}

/*
 * sa_removeshare(flags, argc, argv)
 *
 * implements remove-share subcommand.
 */

int
sa_removeshare(sa_handle_t handle, int flags, int argc, char *argv[])
{
	int verbose = 0;
	int dryrun = 0;
	int force = 0;
	int c;
	int ret = SA_OK;
	sa_group_t group;
	sa_resource_t resource = NULL;
	sa_share_t share = NULL;
	char *rsrcname = NULL;
	char *sharepath = NULL;
	char dir[MAXPATHLEN];
	int auth;

	while ((c = getopt(argc, argv, "?hfnr:s:v")) != EOF) {
		switch (c) {
		case 'n':
			dryrun++;
			break;
		case 'v':
			verbose++;
			break;
		case 'f':
			force++;
			break;
		case 's':
			/*
			 * Remove share path from group. Currently limit
			 * to one share per command.
			 */
			if (sharepath != NULL) {
				(void) printf(gettext(
				    "Removing multiple shares not "
				    "supported\n"));
				return (SA_SYNTAX_ERR);
			}
			sharepath = optarg;
			break;
		case 'r':
			/*
			 * Remove share from group if last resource or remove
			 * resource from share if multiple resources.
			 */
			if (rsrcname != NULL) {
				(void) printf(gettext(
				    "Removing multiple resource names not "
				    "supported\n"));
				return (SA_SYNTAX_ERR);
			}
			rsrcname = optarg;
			break;
		case 'h':
			/* optopt on valid arg isn't defined */
			optopt = c;
			/*FALLTHROUGH*/
		case '?':
		default:
			/*
			 * Since a bad option gets to here, sort it
			 * out and return a syntax error return value
			 * if necessary.
			 */
			switch (optopt) {
			default:
				ret = SA_SYNTAX_ERR;
				break;
			case 'h':
			case '?':
				break;
			}
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_REMOVE_SHARE));
			return (ret);
		}
	}

	if (optind >= argc || (rsrcname == NULL && sharepath == NULL)) {
		if (sharepath == NULL && rsrcname == NULL) {
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_REMOVE_SHARE));
			(void) printf(gettext("\t-s sharepath or -r resource"
			    " must be specified\n"));
			ret = SA_BAD_PATH;
		} else {
			ret = SA_OK;
		}
	}
	if (ret != SA_OK) {
		return (ret);
	}

	if (optind < argc) {
		if ((optind + 1) < argc) {
			(void) printf(gettext("Extraneous group(s) at end of "
			    "command\n"));
			ret = SA_SYNTAX_ERR;
		} else {
			group = sa_get_group(handle, argv[optind]);
			if (group == NULL) {
				(void) printf(gettext(
				    "Group \"%s\" not found\n"), argv[optind]);
				ret = SA_NO_SUCH_GROUP;
			}
		}
	} else {
		group = NULL;
	}

	if (rsrcname != NULL) {
		resource = sa_find_resource(handle, rsrcname);
		if (resource == NULL) {
			ret = SA_NO_SUCH_RESOURCE;
			(void) printf(gettext(
			    "Resource name not found for share: %s\n"),
			    rsrcname);
		}
	}

	/*
	 * Lookup the path in the internal configuration. Care
	 * must be taken to handle the case where the
	 * underlying path has been removed since we need to
	 * be able to deal with that as well.
	 */
	if (ret == SA_OK) {
		if (sharepath != NULL) {
			if (group != NULL)
				share = sa_get_share(group, sharepath);
			else
				share = sa_find_share(handle, sharepath);
		}

		if (resource != NULL) {
			sa_share_t rsrcshare;
			rsrcshare = sa_get_resource_parent(resource);
			if (share == NULL)
				share = rsrcshare;
			else if (share != rsrcshare) {
				ret = SA_NO_SUCH_RESOURCE;
				(void) printf(gettext(
				    "Bad resource name for share: %s\n"),
				    rsrcname);
				share = NULL;
			}
		}

		/*
		 * If we didn't find the share with the provided path,
		 * it may be a symlink so attempt to resolve it using
		 * realpath and try again. Realpath will resolve any
		 * symlinks and place them in "dir". Note that
		 * sharepath is only used for the lookup the first
		 * time and later for error messages. dir will be used
		 * on the second attempt. Once a share is found, all
		 * operations are based off of the share variable.
		 */
		if (share == NULL) {
			if (realpath(sharepath, dir) == NULL) {
				ret = SA_BAD_PATH;
				(void) printf(gettext(
				    "Path is not valid: %s\n"), sharepath);
			} else {
				if (group != NULL)
					share = sa_get_share(group, dir);
				else
					share = sa_find_share(handle, dir);
			}
		}
	}

	/*
	 * If there hasn't been an error, there was likely a
	 * path found. If not, give the appropriate error
	 * message and set the return error. If it was found,
	 * then disable the share and then remove it from the
	 * configuration.
	 */
	if (ret != SA_OK) {
		return (ret);
	}
	if (share == NULL) {
		if (group != NULL)
			(void) printf(gettext("Share not found in group %s:"
			    " %s\n"), argv[optind], sharepath);
		else
			(void) printf(gettext("Share not found: %s\n"),
			    sharepath);
		ret = SA_NO_SUCH_PATH;
	} else {
		if (group == NULL)
			group = sa_get_parent_group(share);
		if (!dryrun) {
			if (ret == SA_OK) {
				if (resource != NULL)
					ret = sa_disable_resource(resource,
					    NULL);
				else
					ret = sa_disable_share(share, NULL);
				/*
				 * We don't care if it fails since it
				 * could be disabled already. Some
				 * unexpected errors could occur that
				 * prevent removal, so also check for
				 * force being set.
				 */
				if ((ret == SA_OK || ret == SA_NO_SUCH_PATH ||
				    ret == SA_NOT_SUPPORTED ||
				    ret == SA_SYSTEM_ERR || force) &&
				    resource == NULL)
					ret = sa_remove_share(share);

				if ((ret == SA_OK || ret == SA_NO_SUCH_PATH ||
				    ret == SA_NOT_SUPPORTED ||
				    ret == SA_SYSTEM_ERR || force) &&
				    resource != NULL) {
					ret = sa_remove_resource(resource);
					if (ret == SA_OK) {
						/*
						 * If this was the
						 * last one, remove
						 * the share as well.
						 */
						resource =
						    sa_get_share_resource(
						    share, NULL);
						if (resource == NULL)
							ret = sa_remove_share(
							    share);
					}
				}
				if (ret == SA_OK)
					ret = sa_update_config(handle);
			}
			if (ret != SA_OK)
				(void) printf(gettext("Could not remove share:"
				    " %s\n"), sa_errorstr(ret));
		} else if (ret == SA_OK) {
			char *pname;
			pname = sa_get_group_attr(group, "name");
			if (pname != NULL) {
				auth = check_authorizations(pname, flags);
				sa_free_attr_string(pname);
			}
			if (!auth && verbose) {
				(void) printf(gettext(
				    "Command would fail: %s\n"),
				    sa_errorstr(SA_NO_PERMISSION));
			}
		}
	}
	return (ret);
}

/*
 * sa_set_share(flags, argc, argv)
 *
 * implements set-share subcommand.
 */

int
sa_set_share(sa_handle_t handle, int flags, int argc, char *argv[])
{
	int dryrun = 0;
	int c;
	int ret = SA_OK;
	sa_group_t group, sharegroup;
	sa_share_t share = NULL;
	sa_resource_t resource = NULL;
	char *sharepath = NULL;
	char *description = NULL;
	char *rsrcname = NULL;
	char *rsrc = NULL;
	char *newname = NULL;
	char *newrsrc;
	char *groupname = NULL;
	int auth;
	int verbose = 0;

	while ((c = getopt(argc, argv, "?hnd:r:s:")) != EOF) {
		switch (c) {
		case 'n':
			dryrun++;
			break;
		case 'd':
			description = optarg;
			break;
		case 'v':
			verbose++;
			break;
		case 'r':
			/*
			 * Update share by resource name
			 */
			if (rsrcname != NULL) {
				(void) printf(gettext(
				    "Updating multiple resource names not "
				    "supported\n"));
				return (SA_SYNTAX_ERR);
			}
			rsrcname = optarg;
			break;
		case 's':
			/*
			 * Save share path into group. Currently limit
			 * to one share per command.
			 */
			if (sharepath != NULL) {
				(void) printf(gettext(
				    "Updating multiple shares not "
				    "supported\n"));
				return (SA_SYNTAX_ERR);
			}
			sharepath = optarg;
			break;
		case 'h':
			/* optopt on valid arg isn't defined */
			optopt = c;
			/*FALLTHROUGH*/
		case '?':
		default:
			/*
			 * Since a bad option gets to here, sort it
			 * out and return a syntax error return value
			 * if necessary.
			 */
			switch (optopt) {
			default:
				ret = SA_SYNTAX_ERR;
				break;
			case 'h':
			case '?':
				break;
			}
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_SET_SHARE));
			return (ret);
		}
	}

	if (optind >= argc && sharepath == NULL && rsrcname == NULL) {
		if (sharepath == NULL) {
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_SET_SHARE));
			(void) printf(gettext("\tgroup must be specified\n"));
			ret = SA_BAD_PATH;
		} else {
			ret = SA_OK;
		}
	}
	if ((optind + 1) < argc) {
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_SET_SHARE));
		(void) printf(gettext("\tExtraneous group(s) at end\n"));
		ret = SA_SYNTAX_ERR;
	}

	/*
	 * Must have at least one of sharepath and rsrcrname.
	 * It is a syntax error to be missing both.
	 */
	if (sharepath == NULL && rsrcname == NULL) {
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_SET_SHARE));
		ret = SA_SYNTAX_ERR;
	}

	if (ret != SA_OK)
		return (ret);

	if (optind < argc) {
		groupname = argv[optind];
		group = sa_get_group(handle, groupname);
	} else {
		group = NULL;
		groupname = NULL;
	}
	if (rsrcname != NULL) {
		/*
		 * If rsrcname exists, split rename syntax and then
		 * convert to utf 8 if no errors.
		 */
		newname = strchr(rsrcname, '=');
		if (newname != NULL) {
			*newname++ = '\0';
		}
		if (!validresource(rsrcname)) {
			ret = SA_INVALID_NAME;
			(void) printf(gettext("Invalid resource name: "
			    "\"%s\"\n"), rsrcname);
		} else {
			rsrc = conv_to_utf8(rsrcname);
		}
		if (newname != NULL) {
			if (!validresource(newname)) {
				ret = SA_INVALID_NAME;
				(void) printf(gettext("Invalid resource name: "
				    "%s\n"), newname);
				newname = NULL;
			} else {
				newrsrc = conv_to_utf8(newname);
			}
		}
	}

	if (ret != SA_OK) {
		if (rsrcname != NULL && rsrcname != rsrc)
			sa_free_attr_string(rsrc);
		if (newname != NULL && newname != newrsrc)
			sa_free_attr_string(newrsrc);
		return (ret);
	}

	if (sharepath != NULL) {
		share = sa_find_share(handle, sharepath);
	} else if (rsrcname != NULL) {
		resource = sa_find_resource(handle, rsrc);
		if (resource != NULL)
			share = sa_get_resource_parent(resource);
		else
			ret = SA_NO_SUCH_RESOURCE;
	}
	if (share != NULL) {
		sharegroup = sa_get_parent_group(share);
		if (group != NULL && group != sharegroup) {
			(void) printf(gettext("Group \"%s\" does not contain "
			    "share %s\n"),
			    argv[optind], sharepath);
			ret = SA_BAD_PATH;
		} else {
			int delgroupname = 0;
			if (groupname == NULL) {
				groupname = sa_get_group_attr(sharegroup,
				    "name");
				delgroupname = 1;
			}
			if (groupname != NULL) {
				auth = check_authorizations(groupname, flags);
				if (delgroupname) {
					sa_free_attr_string(groupname);
					groupname = NULL;
				}
			} else {
				ret = SA_NO_MEMORY;
			}
			if (rsrcname != NULL) {
				resource = sa_find_resource(handle, rsrc);
				if (!dryrun) {
					if (newname != NULL &&
					    resource != NULL)
						ret = sa_rename_resource(
						    resource, newrsrc);
					else if (newname != NULL)
						ret = SA_NO_SUCH_RESOURCE;
					if (newname != NULL &&
					    newname != newrsrc)
						sa_free_attr_string(newrsrc);
				}
				if (rsrc != rsrcname)
					sa_free_attr_string(rsrc);
			}

			/*
			 * If the user has set a description, it will be
			 * on the resource if -r was used otherwise it
			 * must be on the share.
			 */
			if (!dryrun && ret == SA_OK && description != NULL) {
				char *desc;
				desc = conv_to_utf8(description);
				if (resource != NULL)
					ret = sa_set_resource_description(
					    resource, desc);
				else
					ret = sa_set_share_description(share,
					    desc);
				if (desc != description)
					sa_free_share_description(desc);
			}
		}
		if (!dryrun && ret == SA_OK) {
			if (resource != NULL)
				(void) sa_enable_resource(resource, NULL);
			ret = sa_update_config(handle);
		}
		switch (ret) {
		case SA_DUPLICATE_NAME:
			(void) printf(gettext("Resource name in use: %s\n"),
			    rsrcname);
			break;
		default:
			(void) printf(gettext("Could not set: %s\n"),
			    sa_errorstr(ret));
			break;
		case SA_OK:
			if (dryrun && !auth && verbose) {
				(void) printf(gettext(
				    "Command would fail: %s\n"),
				    sa_errorstr(SA_NO_PERMISSION));
			}
			break;
		}
	} else {
		switch (ret) {
		case SA_NO_SUCH_RESOURCE:
			(void) printf(gettext("Resource \"%s\" not found\n"),
			    rsrcname);
			break;
		default:
			if (sharepath != NULL) {
				(void) printf(
				    gettext("Share path \"%s\" not found\n"),
				    sharepath);
				ret = SA_NO_SUCH_PATH;
			} else {
				(void) printf(gettext("Set failed: %s\n"),
				    sa_errorstr(ret));
			}
		}
	}

	return (ret);
}

/*
 * add_security(group, sectype, optlist, proto, *err)
 *
 * Helper function to add a security option (named optionset) to the
 * group.
 */

static int
add_security(sa_group_t group, char *sectype,
    struct options *optlist, char *proto, int *err)
{
	sa_security_t security;
	int ret = SA_OK;
	int result = 0;
	sa_handle_t handle;

	sectype = sa_proto_space_alias(proto, sectype);
	security = sa_get_security(group, sectype, proto);
	if (security == NULL)
		security = sa_create_security(group, sectype, proto);

	if (sectype != NULL)
		sa_free_attr_string(sectype);

	if (security == NULL)
		goto done;

	handle = sa_find_group_handle(group);
	if (handle == NULL) {
		ret = SA_CONFIG_ERR;
		goto done;
	}
	while (optlist != NULL) {
		sa_property_t prop;
		prop = sa_get_property(security, optlist->optname);
		if (prop == NULL) {
			/*
			 * Add the property, but only if it is
			 * a non-NULL or non-zero length value
			 */
			if (optlist->optvalue != NULL) {
				prop = sa_create_property(optlist->optname,
				    optlist->optvalue);
				if (prop != NULL) {
					ret = sa_valid_property(handle,
					    security, proto, prop);
					if (ret != SA_OK) {
						(void) sa_remove_property(prop);
						(void) printf(gettext(
						    "Could not add "
						    "property %s: %s\n"),
						    optlist->optname,
						    sa_errorstr(ret));
					}
					if (ret == SA_OK) {
						ret = sa_add_property(security,
						    prop);
						if (ret != SA_OK) {
							(void) printf(gettext(
							    "Could not add "
							    "property (%s=%s):"
							    " %s\n"),
							    optlist->optname,
							    optlist->optvalue,
							    sa_errorstr(ret));
						} else {
							result = 1;
						}
					}
				}
			}
		} else {
			ret = sa_update_property(prop, optlist->optvalue);
			result = 1; /* should check if really changed */
		}
		optlist = optlist->next;
	}
	/*
	 * When done, properties may have all been removed but
	 * we need to keep the security type itself until
	 * explicitly removed.
	 */
	if (result)
		ret = sa_commit_properties(security, 0);
done:
	*err = ret;
	return (result);
}

/*
 * zfscheck(group, share)
 *
 * For the special case where a share was provided, make sure it is a
 * compatible path for a ZFS property change.  The only path
 * acceptable is the path that defines the zfs sub-group (dataset with
 * the sharenfs property set) and not one of the paths that inherited
 * the NFS properties. Returns SA_OK if it is usable and
 * SA_NOT_ALLOWED if it isn't.
 *
 * If group is not a ZFS group/subgroup, we assume OK since the check
 * on return will catch errors for those cases.  What we are looking
 * for here is that the group is ZFS and the share is not the defining
 * share.  All else is SA_OK.
 */

static int
zfscheck(sa_group_t group, sa_share_t share)
{
	int ret = SA_OK;
	char *attr;

	if (sa_group_is_zfs(group)) {
		/*
		 * The group is a ZFS group.  Does the share represent
		 * the dataset that defined the group? It is only OK
		 * if the attribute "subgroup" exists on the share and
		 * has a value of "true".
		 */

		ret = SA_NOT_ALLOWED;
		attr = sa_get_share_attr(share, "subgroup");
		if (attr != NULL) {
			if (strcmp(attr, "true") == 0)
				ret = SA_OK;
			sa_free_attr_string(attr);
		}
	}
	return (ret);
}

/*
 * basic_set(groupname, optlist, protocol, sharepath, rsrcname, dryrun)
 *
 * This function implements "set" when a name space (-S) is not
 * specified. It is a basic set. Options and other CLI parsing has
 * already been done.
 *
 * "rsrcname" is a "resource name". If it is non-NULL, it must match
 * the sharepath if present or group if present, otherwise it is used
 * to set options.
 *
 * Resource names may take options if the protocol supports it. If the
 * protocol doesn't support resource level options, rsrcname is just
 * an alias for the share.
 */

static int
basic_set(sa_handle_t handle, char *groupname, struct options *optlist,
    char *protocol, char *sharepath, char *rsrcname, int dryrun)
{
	sa_group_t group;
	int ret = SA_OK;
	int change = 0;
	struct list *worklist = NULL;

	group = sa_get_group(handle, groupname);
	if (group != NULL) {
		sa_share_t share = NULL;
		sa_resource_t resource = NULL;

		/*
		 * If there is a sharepath, make sure it belongs to
		 * the group.
		 */
		if (sharepath != NULL) {
			share = sa_get_share(group, sharepath);
			if (share == NULL) {
				(void) printf(gettext(
				    "Share does not exist in group %s\n"),
				    groupname, sharepath);
				ret = SA_NO_SUCH_PATH;
			} else {
				/* if ZFS and OK, then only group */
				ret = zfscheck(group, share);
				if (ret == SA_OK &&
				    sa_group_is_zfs(group))
					share = NULL;
				if (ret == SA_NOT_ALLOWED)
					(void) printf(gettext(
					    "Properties on ZFS group shares "
					    "not supported: %s\n"), sharepath);
			}
		}

		/*
		 * If a resource name exists, make sure it belongs to
		 * the share if present else it belongs to the
		 * group. Also check the protocol to see if it
		 * supports resource level properties or not. If not,
		 * use share only.
		 */
		if (rsrcname != NULL) {
			if (share != NULL) {
				resource = sa_get_share_resource(share,
				    rsrcname);
				if (resource == NULL)
					ret = SA_NO_SUCH_RESOURCE;
			} else {
				resource = sa_get_resource(group, rsrcname);
				if (resource != NULL)
					share = sa_get_resource_parent(
					    resource);
				else
					ret = SA_NO_SUCH_RESOURCE;
			}
			if (ret == SA_OK && resource != NULL) {
				uint64_t features;
				/*
				 * Check to see if the resource can take
				 * properties. If so, stick the resource into
				 * "share" so it will all just work.
				 */
				features = sa_proto_get_featureset(protocol);
				if (features & SA_FEATURE_RESOURCE)
					share = (sa_share_t)resource;
			}
		}

		if (ret == SA_OK) {
			/* group must exist */
			ret = valid_options(handle, optlist, protocol,
			    share == NULL ? group : share, NULL);
			if (ret == SA_OK && !dryrun) {
				if (share != NULL)
					change |= add_optionset(share, optlist,
					    protocol, &ret);
				else
					change |= add_optionset(group, optlist,
					    protocol, &ret);
				if (ret == SA_OK && change)
					worklist = add_list(worklist, group,
					    share, protocol);
			}
		}
		free_opt(optlist);
	} else {
		(void) printf(gettext("Group \"%s\" not found\n"), groupname);
		ret = SA_NO_SUCH_GROUP;
	}
	/*
	 * we have a group and potentially legal additions
	 */

	/*
	 * Commit to configuration if not a dryrunp and properties
	 * have changed.
	 */
	if (!dryrun && ret == SA_OK && change && worklist != NULL)
		/* properties changed, so update all shares */
		(void) enable_all_groups(handle, worklist, 0, 0, protocol,
		    B_TRUE);

	if (worklist != NULL)
		free_list(worklist);
	return (ret);
}

/*
 * space_set(groupname, optlist, protocol, sharepath, dryrun)
 *
 * This function implements "set" when a name space (-S) is
 * specified. It is a namespace set. Options and other CLI parsing has
 * already been done.
 */

static int
space_set(sa_handle_t handle, char *groupname, struct options *optlist,
    char *protocol, char *sharepath, int dryrun, char *sectype)
{
	sa_group_t group;
	int ret = SA_OK;
	int change = 0;
	struct list *worklist = NULL;

	/*
	 * make sure protcol and sectype are valid
	 */

	if (sa_proto_valid_space(protocol, sectype) == 0) {
		(void) printf(gettext("Option space \"%s\" not valid "
		    "for protocol.\n"), sectype);
		return (SA_INVALID_SECURITY);
	}

	group = sa_get_group(handle, groupname);
	if (group != NULL) {
		sa_share_t share = NULL;
		if (sharepath != NULL) {
			share = sa_get_share(group, sharepath);
			if (share == NULL) {
				(void) printf(gettext(
				    "Share does not exist in group %s\n"),
				    groupname, sharepath);
				ret = SA_NO_SUCH_PATH;
			} else {
				/* if ZFS and OK, then only group */
				ret = zfscheck(group, share);
				if (ret == SA_OK &&
				    sa_group_is_zfs(group))
					share = NULL;
				if (ret == SA_NOT_ALLOWED)
					(void) printf(gettext(
					    "Properties on ZFS group shares "
					    "not supported: %s\n"), sharepath);
			}
		}
		if (ret == SA_OK) {
			/* group must exist */
			ret = valid_options(handle, optlist, protocol,
			    share == NULL ? group : share, sectype);
			if (ret == SA_OK && !dryrun) {
				if (share != NULL)
					change = add_security(share, sectype,
					    optlist, protocol, &ret);
				else
					change = add_security(group, sectype,
					    optlist, protocol, &ret);
				if (ret != SA_OK)
					(void) printf(gettext(
					    "Could not set property: %s\n"),
					    sa_errorstr(ret));
			}
			if (ret == SA_OK && change)
				worklist = add_list(worklist, group, share,
				    protocol);
		}
		free_opt(optlist);
	} else {
		(void) printf(gettext("Group \"%s\" not found\n"), groupname);
		ret = SA_NO_SUCH_GROUP;
	}

	/*
	 * We have a group and potentially legal additions.
	 */

	/* Commit to configuration if not a dryrun */
	if (!dryrun && ret == 0) {
		if (change && worklist != NULL) {
			/* properties changed, so update all shares */
			(void) enable_all_groups(handle, worklist, 0, 0,
			    protocol, B_TRUE);
		}
		ret = sa_update_config(handle);
	}
	if (worklist != NULL)
		free_list(worklist);
	return (ret);
}

/*
 * sa_set(flags, argc, argv)
 *
 * Implements the set subcommand. It keys off of -S to determine which
 * set of operations to actually do.
 */

int
sa_set(sa_handle_t handle, int flags, int argc, char *argv[])
{
	char *groupname;
	int verbose = 0;
	int dryrun = 0;
	int c;
	char *protocol = NULL;
	int ret = SA_OK;
	struct options *optlist = NULL;
	char *rsrcname = NULL;
	char *sharepath = NULL;
	char *optset = NULL;
	int auth;

	while ((c = getopt(argc, argv, "?hvnP:p:r:s:S:")) != EOF) {
		switch (c) {
		case 'v':
			verbose++;
			break;
		case 'n':
			dryrun++;
			break;
		case 'P':
			if (protocol != NULL) {
				(void) printf(gettext(
				    "Specifying multiple protocols "
				    "not supported: %s\n"), protocol);
				return (SA_SYNTAX_ERR);
			}
			protocol = optarg;
			if (!sa_valid_protocol(protocol)) {
				(void) printf(gettext(
				    "Invalid protocol specified: %s\n"),
				    protocol);
				return (SA_INVALID_PROTOCOL);
			}
			break;
		case 'p':
			ret = add_opt(&optlist, optarg, 0);
			switch (ret) {
			case OPT_ADD_SYNTAX:
				(void) printf(gettext("Property syntax error:"
				    " %s\n"), optarg);
				return (SA_SYNTAX_ERR);
			case OPT_ADD_MEMORY:
				(void) printf(gettext("No memory to set "
				    "property: %s\n"), optarg);
				return (SA_NO_MEMORY);
			default:
				break;
			}
			break;
		case 'r':
			if (rsrcname != NULL) {
				(void) printf(gettext(
				    "Setting multiple resource names not"
				    " supported\n"));
				return (SA_SYNTAX_ERR);
			}
			rsrcname = optarg;
			break;
		case 's':
			if (sharepath != NULL) {
				(void) printf(gettext(
				    "Setting multiple shares not supported\n"));
				return (SA_SYNTAX_ERR);
			}
			sharepath = optarg;
			break;
		case 'S':
			if (optset != NULL) {
				(void) printf(gettext(
				    "Specifying multiple property "
				    "spaces not supported: %s\n"), optset);
				return (SA_SYNTAX_ERR);
			}
			optset = optarg;
			break;
		case 'h':
			/* optopt on valid arg isn't defined */
			optopt = c;
			/*FALLTHROUGH*/
		case '?':
		default:
			/*
			 * Since a bad option gets to here, sort it
			 * out and return a syntax error return value
			 * if necessary.
			 */
			switch (optopt) {
			default:
				ret = SA_SYNTAX_ERR;
				break;
			case 'h':
			case '?':
				break;
			}
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_SET));
			return (ret);
		}
	}

	if (optlist != NULL)
		ret = chk_opt(optlist, optset != NULL, protocol);

	if (optind >= argc || (optlist == NULL && optset == NULL) ||
	    protocol == NULL || ret != OPT_ADD_OK) {
		char *sep = "\t";

		(void) printf(gettext("usage: %s\n"), sa_get_usage(USAGE_SET));
		if (optind >= argc) {
			(void) printf(gettext("%sgroup must be specified"),
			    sep);
			sep = ", ";
		}
		if (optlist == NULL) {
			(void) printf(gettext("%sat least one property must be"
			    " specified"), sep);
			sep = ", ";
		}
		if (protocol == NULL) {
			(void) printf(gettext("%sprotocol must be specified"),
			    sep);
			sep = ", ";
		}
		(void) printf("\n");
		ret = SA_SYNTAX_ERR;
	} else {
		/*
		 * Group already exists so we can proceed after a few
		 * additional checks related to ZFS handling.
		 */

		groupname = argv[optind];
		if (strcmp(groupname, "zfs") == 0) {
			(void) printf(gettext("Changing properties for group "
			    "\"zfs\" not allowed\n"));
			return (SA_NOT_ALLOWED);
		}

		auth = check_authorizations(groupname, flags);
		if (optset == NULL)
			ret = basic_set(handle, groupname, optlist, protocol,
			    sharepath, rsrcname, dryrun);
		else
			ret = space_set(handle, groupname, optlist, protocol,
			    sharepath, dryrun, optset);
		if (dryrun && ret == SA_OK && !auth && verbose) {
			(void) printf(gettext("Command would fail: %s\n"),
			    sa_errorstr(SA_NO_PERMISSION));
		}
	}
	return (ret);
}

/*
 * remove_options(group, optlist, proto, *err)
 *
 * Helper function to actually remove options from a group after all
 * preprocessing is done.
 */

static int
remove_options(sa_group_t group, struct options *optlist,
    char *proto, int *err)
{
	struct options *cur;
	sa_optionset_t optionset;
	sa_property_t prop;
	int change = 0;
	int ret = SA_OK;

	optionset = sa_get_optionset(group, proto);
	if (optionset != NULL) {
		for (cur = optlist; cur != NULL; cur = cur->next) {
			prop = sa_get_property(optionset, cur->optname);
			if (prop != NULL) {
				ret = sa_remove_property(prop);
				if (ret != SA_OK)
					break;
				change = 1;
			}
		}
	}
	if (ret == SA_OK && change)
		ret = sa_commit_properties(optionset, 0);

	if (err != NULL)
		*err = ret;
	return (change);
}

/*
 * valid_unset(group, optlist, proto)
 *
 * Sanity check the optlist to make sure they can be removed. Issue an
 * error if a property doesn't exist.
 */

static int
valid_unset(sa_group_t group, struct options *optlist, char *proto)
{
	struct options *cur;
	sa_optionset_t optionset;
	sa_property_t prop;
	int ret = SA_OK;

	optionset = sa_get_optionset(group, proto);
	if (optionset != NULL) {
		for (cur = optlist; cur != NULL; cur = cur->next) {
			prop = sa_get_property(optionset, cur->optname);
			if (prop == NULL) {
				(void) printf(gettext(
				    "Could not unset property %s: not set\n"),
				    cur->optname);
				ret = SA_NO_SUCH_PROP;
			}
		}
	}
	return (ret);
}

/*
 * valid_unset_security(group, optlist, proto)
 *
 * Sanity check the optlist to make sure they can be removed. Issue an
 * error if a property doesn't exist.
 */

static int
valid_unset_security(sa_group_t group, struct options *optlist, char *proto,
    char *sectype)
{
	struct options *cur;
	sa_security_t security;
	sa_property_t prop;
	int ret = SA_OK;
	char *sec;

	sec = sa_proto_space_alias(proto, sectype);
	security = sa_get_security(group, sec, proto);
	if (security != NULL) {
		for (cur = optlist; cur != NULL; cur = cur->next) {
			prop = sa_get_property(security, cur->optname);
			if (prop == NULL) {
				(void) printf(gettext(
				    "Could not unset property %s: not set\n"),
				    cur->optname);
				ret = SA_NO_SUCH_PROP;
			}
		}
	} else {
		(void) printf(gettext(
		    "Could not unset %s: space not defined\n"), sectype);
		ret = SA_NO_SUCH_SECURITY;
	}
	if (sec != NULL)
		sa_free_attr_string(sec);
	return (ret);
}

/*
 * remove_security(group, optlist, proto)
 *
 * Remove the properties since they were checked as valid.
 */

static int
remove_security(sa_group_t group, char *sectype,
    struct options *optlist, char *proto, int *err)
{
	sa_security_t security;
	int ret = SA_OK;
	int change = 0;

	sectype = sa_proto_space_alias(proto, sectype);
	security = sa_get_security(group, sectype, proto);
	if (sectype != NULL)
		sa_free_attr_string(sectype);

	if (security != NULL) {
		while (optlist != NULL) {
			sa_property_t prop;
			prop = sa_get_property(security, optlist->optname);
			if (prop != NULL) {
				ret = sa_remove_property(prop);
				if (ret != SA_OK)
					break;
				change = 1;
			}
			optlist = optlist->next;
		}
		/*
		 * when done, properties may have all been removed but
		 * we need to keep the security type itself until
		 * explicitly removed.
		 */
		if (ret == SA_OK && change)
			ret = sa_commit_properties(security, 0);
	} else {
		ret = SA_NO_SUCH_PROP;
	}
	if (err != NULL)
		*err = ret;
	return (change);
}

/*
 * basic_unset(groupname, optlist, protocol, sharepath, rsrcname, dryrun)
 *
 * Unset non-named optionset properties.
 */

static int
basic_unset(sa_handle_t handle, char *groupname, struct options *optlist,
    char *protocol, char *sharepath, char *rsrcname, int dryrun)
{
	sa_group_t group;
	int ret = SA_OK;
	int change = 0;
	struct list *worklist = NULL;
	sa_share_t share = NULL;
	sa_resource_t resource = NULL;

	group = sa_get_group(handle, groupname);
	if (group == NULL)
		return (ret);

	/*
	 * If there is a sharepath, make sure it belongs to
	 * the group.
	 */
	if (sharepath != NULL) {
		share = sa_get_share(group, sharepath);
		if (share == NULL) {
			(void) printf(gettext(
			    "Share does not exist in group %s\n"),
			    groupname, sharepath);
			ret = SA_NO_SUCH_PATH;
		}
	}
	/*
	 * If a resource name exists, make sure it belongs to
	 * the share if present else it belongs to the
	 * group. Also check the protocol to see if it
	 * supports resource level properties or not. If not,
	 * use share only.
	 */
	if (rsrcname != NULL) {
		if (share != NULL) {
			resource = sa_get_share_resource(share, rsrcname);
			if (resource == NULL)
				ret = SA_NO_SUCH_RESOURCE;
		} else {
			resource = sa_get_resource(group, rsrcname);
			if (resource != NULL) {
				share = sa_get_resource_parent(resource);
			} else {
				ret = SA_NO_SUCH_RESOURCE;
			}
		}
		if (ret == SA_OK && resource != NULL) {
			uint64_t features;
			/*
			 * Check to see if the resource can take
			 * properties. If so, stick the resource into
			 * "share" so it will all just work.
			 */
			features = sa_proto_get_featureset(protocol);
			if (features & SA_FEATURE_RESOURCE)
				share = (sa_share_t)resource;
		}
	}

	if (ret == SA_OK) {
		/* group must exist */
		ret = valid_unset(share != NULL ? share : group,
		    optlist, protocol);
		if (ret == SA_OK && !dryrun) {
			if (share != NULL) {
				sa_optionset_t optionset;
				sa_property_t prop;
				change |= remove_options(share, optlist,
				    protocol, &ret);
				/*
				 * If a share optionset is
				 * empty, remove it.
				 */
				optionset = sa_get_optionset((sa_share_t)share,
				    protocol);
				if (optionset != NULL) {
					prop = sa_get_property(optionset, NULL);
					if (prop == NULL)
						(void) sa_destroy_optionset(
						    optionset);
				}
			} else {
				change |= remove_options(group,
				    optlist, protocol, &ret);
			}
			if (ret == SA_OK && change)
				worklist = add_list(worklist, group, share,
				    protocol);
			if (ret != SA_OK)
				(void) printf(gettext(
				    "Could not remove properties: "
				    "%s\n"), sa_errorstr(ret));
		}
	} else {
		(void) printf(gettext("Group \"%s\" not found\n"), groupname);
		ret = SA_NO_SUCH_GROUP;
	}
	free_opt(optlist);

	/*
	 * We have a group and potentially legal additions
	 *
	 * Commit to configuration if not a dryrun
	 */
	if (!dryrun && ret == SA_OK) {
		if (change && worklist != NULL) {
			/* properties changed, so update all shares */
			(void) enable_all_groups(handle, worklist, 0, 0,
			    protocol, B_TRUE);
		}
	}
	if (worklist != NULL)
		free_list(worklist);
	return (ret);
}

/*
 * space_unset(groupname, optlist, protocol, sharepath, dryrun)
 *
 * Unset named optionset properties.
 */
static int
space_unset(sa_handle_t handle, char *groupname, struct options *optlist,
    char *protocol, char *sharepath, int dryrun, char *sectype)
{
	sa_group_t group;
	int ret = SA_OK;
	int change = 0;
	struct list *worklist = NULL;
	sa_share_t share = NULL;

	group = sa_get_group(handle, groupname);
	if (group == NULL) {
		(void) printf(gettext("Group \"%s\" not found\n"), groupname);
		return (SA_NO_SUCH_GROUP);
	}
	if (sharepath != NULL) {
		share = sa_get_share(group, sharepath);
		if (share == NULL) {
			(void) printf(gettext(
			    "Share does not exist in group %s\n"),
			    groupname, sharepath);
			return (SA_NO_SUCH_PATH);
		}
	}
	ret = valid_unset_security(share != NULL ? share : group,
	    optlist, protocol, sectype);

	if (ret == SA_OK && !dryrun) {
		if (optlist != NULL) {
			if (share != NULL) {
				sa_security_t optionset;
				sa_property_t prop;
				change = remove_security(share,
				    sectype, optlist, protocol, &ret);

				/* If a share security is empty, remove it */
				optionset = sa_get_security((sa_group_t)share,
				    sectype, protocol);
				if (optionset != NULL) {
					prop = sa_get_property(optionset,
					    NULL);
					if (prop == NULL)
						ret = sa_destroy_security(
						    optionset);
				}
			} else {
				change = remove_security(group, sectype,
				    optlist, protocol, &ret);
			}
		} else {
			sa_security_t security;
			char *sec;
			sec = sa_proto_space_alias(protocol, sectype);
			security = sa_get_security(group, sec, protocol);
			if (sec != NULL)
				sa_free_attr_string(sec);
			if (security != NULL) {
				ret = sa_destroy_security(security);
				if (ret == SA_OK)
					change = 1;
			} else {
				ret = SA_NO_SUCH_PROP;
			}
		}
		if (ret != SA_OK)
			(void) printf(gettext("Could not unset property: %s\n"),
			    sa_errorstr(ret));
	}

	if (ret == SA_OK && change)
		worklist = add_list(worklist, group, 0, protocol);

	free_opt(optlist);
	/*
	 * We have a group and potentially legal additions
	 */

	/* Commit to configuration if not a dryrun */
	if (!dryrun && ret == 0) {
		/* properties changed, so update all shares */
		if (change && worklist != NULL)
			(void) enable_all_groups(handle, worklist, 0, 0,
			    protocol, B_TRUE);
		ret = sa_update_config(handle);
	}
	if (worklist != NULL)
		free_list(worklist);
	return (ret);
}

/*
 * sa_unset(flags, argc, argv)
 *
 * Implements the unset subcommand. Parsing done here and then basic
 * or space versions of the real code are called.
 */

int
sa_unset(sa_handle_t handle, int flags, int argc, char *argv[])
{
	char *groupname;
	int verbose = 0;
	int dryrun = 0;
	int c;
	char *protocol = NULL;
	int ret = SA_OK;
	struct options *optlist = NULL;
	char *rsrcname = NULL;
	char *sharepath = NULL;
	char *optset = NULL;
	int auth;

	while ((c = getopt(argc, argv, "?hvnP:p:r:s:S:")) != EOF) {
		switch (c) {
		case 'v':
			verbose++;
			break;
		case 'n':
			dryrun++;
			break;
		case 'P':
			if (protocol != NULL) {
				(void) printf(gettext(
				    "Specifying multiple protocols "
				    "not supported: %s\n"), protocol);
				return (SA_SYNTAX_ERR);
			}
			protocol = optarg;
			if (!sa_valid_protocol(protocol)) {
				(void) printf(gettext(
				    "Invalid protocol specified: %s\n"),
				    protocol);
				return (SA_INVALID_PROTOCOL);
			}
			break;
		case 'p':
			ret = add_opt(&optlist, optarg, 1);
			switch (ret) {
			case OPT_ADD_SYNTAX:
				(void) printf(gettext("Property syntax error "
				    "for property %s\n"), optarg);
				return (SA_SYNTAX_ERR);

			case OPT_ADD_PROPERTY:
				(void) printf(gettext("Properties need to be "
				    "set with set command: %s\n"), optarg);
				return (SA_SYNTAX_ERR);

			default:
				break;
			}
			break;
		case 'r':
			/*
			 * Unset properties on resource if applicable or on
			 * share if resource for this protocol doesn't use
			 * resources.
			 */
			if (rsrcname != NULL) {
				(void) printf(gettext(
				    "Unsetting multiple resource "
				    "names not supported\n"));
				return (SA_SYNTAX_ERR);
			}
			rsrcname = optarg;
			break;
		case 's':
			if (sharepath != NULL) {
				(void) printf(gettext(
				    "Adding multiple shares not supported\n"));
				return (SA_SYNTAX_ERR);
			}
			sharepath = optarg;
			break;
		case 'S':
			if (optset != NULL) {
				(void) printf(gettext(
				    "Specifying multiple property "
				    "spaces not supported: %s\n"), optset);
				return (SA_SYNTAX_ERR);
			}
			optset = optarg;
			break;
		case 'h':
			/* optopt on valid arg isn't defined */
			optopt = c;
			/*FALLTHROUGH*/
		case '?':
		default:
			/*
			 * Since a bad option gets to here, sort it
			 * out and return a syntax error return value
			 * if necessary.
			 */
			switch (optopt) {
			default:
				ret = SA_SYNTAX_ERR;
				break;
			case 'h':
			case '?':
				break;
			}
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_UNSET));
			return (ret);
		}
	}

	if (optlist != NULL)
		ret = chk_opt(optlist, optset != NULL, protocol);

	if (optind >= argc || (optlist == NULL && optset == NULL) ||
	    protocol == NULL) {
		char *sep = "\t";
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_UNSET));
		if (optind >= argc) {
			(void) printf(gettext("%sgroup must be specified"),
			    sep);
			sep = ", ";
		}
		if (optlist == NULL) {
			(void) printf(gettext("%sat least one property must "
			    "be specified"), sep);
			sep = ", ";
		}
		if (protocol == NULL) {
			(void) printf(gettext("%sprotocol must be specified"),
			    sep);
			sep = ", ";
		}
		(void) printf("\n");
		ret = SA_SYNTAX_ERR;
	} else {

		/*
		 * If a group already exists, we can only add a new
		 * protocol to it and not create a new one or add the
		 * same protocol again.
		 */

		groupname = argv[optind];
		auth = check_authorizations(groupname, flags);
		if (optset == NULL)
			ret = basic_unset(handle, groupname, optlist, protocol,
			    sharepath, rsrcname, dryrun);
		else
			ret = space_unset(handle, groupname, optlist, protocol,
			    sharepath, dryrun, optset);

		if (dryrun && ret == SA_OK && !auth && verbose)
			(void) printf(gettext("Command would fail: %s\n"),
			    sa_errorstr(SA_NO_PERMISSION));
	}
	return (ret);
}

/*
 * sa_enable_group(flags, argc, argv)
 *
 * Implements the enable subcommand
 */

int
sa_enable_group(sa_handle_t handle, int flags, int argc, char *argv[])
{
	int verbose = 0;
	int dryrun = 0;
	int all = 0;
	int c;
	int ret = SA_OK;
	char *protocol = NULL;
	char *state;
	struct list *worklist = NULL;
	int auth = 1;
	sa_group_t group;

	while ((c = getopt(argc, argv, "?havnP:")) != EOF) {
		switch (c) {
		case 'a':
			all = 1;
			break;
		case 'n':
			dryrun++;
			break;
		case 'P':
			if (protocol != NULL) {
				(void) printf(gettext(
				    "Specifying multiple protocols "
				    "not supported: %s\n"), protocol);
				return (SA_SYNTAX_ERR);
			}
			protocol = optarg;
			if (!sa_valid_protocol(protocol)) {
				(void) printf(gettext(
				    "Invalid protocol specified: %s\n"),
				    protocol);
				return (SA_INVALID_PROTOCOL);
			}
			break;
		case 'v':
			verbose++;
			break;
		case 'h':
			/* optopt on valid arg isn't defined */
			optopt = c;
			/*FALLTHROUGH*/
		case '?':
		default:
			/*
			 * Since a bad option gets to here, sort it
			 * out and return a syntax error return value
			 * if necessary.
			 */
			switch (optopt) {
			default:
				ret = SA_SYNTAX_ERR;
				break;
			case 'h':
			case '?':
				(void) printf(gettext("usage: %s\n"),
				    sa_get_usage(USAGE_ENABLE));
				return (ret);
			}
		}
	}

	if (optind == argc && !all) {
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_ENABLE));
		(void) printf(gettext("\tmust specify group\n"));
		return (SA_NO_SUCH_PATH);
	}
	if (!all) {
		while (optind < argc) {
			group = sa_get_group(handle, argv[optind]);
			if (group != NULL) {
				auth &= check_authorizations(argv[optind],
				    flags);
				state = sa_get_group_attr(group, "state");
				if (state != NULL &&
				    strcmp(state, "enabled") == 0) {
					/* already enabled */
					if (verbose)
						(void) printf(gettext(
						    "Group \"%s\" is already "
						    "enabled\n"),
						    argv[optind]);
					ret = SA_BUSY; /* already enabled */
				} else {
					worklist = add_list(worklist, group,
					    0, protocol);
					if (verbose)
						(void) printf(gettext(
						    "Enabling group \"%s\"\n"),
						    argv[optind]);
				}
				if (state != NULL)
					sa_free_attr_string(state);
			} else {
				ret = SA_NO_SUCH_GROUP;
			}
			optind++;
		}
	} else {
		for (group = sa_get_group(handle, NULL);
		    group != NULL;
		    group = sa_get_next_group(group)) {
			worklist = add_list(worklist, group, 0, protocol);
		}
	}
	if (!dryrun && ret == SA_OK)
		ret = enable_all_groups(handle, worklist, 1, 0, NULL, B_FALSE);

	if (ret != SA_OK && ret != SA_BUSY)
		(void) printf(gettext("Could not enable group: %s\n"),
		    sa_errorstr(ret));
	if (ret == SA_BUSY)
		ret = SA_OK;

	if (worklist != NULL)
		free_list(worklist);
	if (dryrun && ret == SA_OK && !auth && verbose) {
		(void) printf(gettext("Command would fail: %s\n"),
		    sa_errorstr(SA_NO_PERMISSION));
	}
	return (ret);
}

/*
 * disable_group(group, proto)
 *
 * Disable all the shares in the specified group.. This is a helper
 * for disable_all_groups in order to simplify regular and subgroup
 * (zfs) disabling. Group has already been checked for non-NULL.
 */

static int
disable_group(sa_group_t group, char *proto)
{
	sa_share_t share;
	int ret = SA_OK;

	/*
	 * If the protocol isn't enabled, skip it and treat as
	 * successful.
	 */
	if (!has_protocol(group, proto))
		return (ret);

	for (share = sa_get_share(group, NULL);
	    share != NULL && ret == SA_OK;
	    share = sa_get_next_share(share)) {
		ret = sa_disable_share(share, proto);
		if (ret == SA_NO_SUCH_PATH) {
			/*
			 * this is OK since the path is gone. we can't
			 * re-share it anyway so no error.
			 */
			ret = SA_OK;
		}
	}
	return (ret);
}

/*
 * disable_all_groups(work, setstate)
 *
 * helper function that disables the shares in the list of groups
 * provided. It optionally marks the group as disabled. Used by both
 * enable and start subcommands.
 */

static int
disable_all_groups(sa_handle_t handle, struct list *work, int setstate)
{
	int ret = SA_OK;
	sa_group_t subgroup, group;

	while (work != NULL && ret == SA_OK) {
		group = (sa_group_t)work->item;
		if (setstate)
			ret = sa_set_group_attr(group, "state", "disabled");
		if (ret == SA_OK) {
			char *name;
			name = sa_get_group_attr(group, "name");
			if (name != NULL && strcmp(name, "zfs") == 0) {
				/* need to get the sub-groups for stopping */
				for (subgroup = sa_get_sub_group(group);
				    subgroup != NULL;
				    subgroup = sa_get_next_group(subgroup)) {
					ret = disable_group(subgroup,
					    work->proto);
				}
			} else {
				ret = disable_group(group, work->proto);
			}
			if (name != NULL)
				sa_free_attr_string(name);
			/*
			 * We don't want to "disable" since it won't come
			 * up after a reboot.  The SMF framework should do
			 * the right thing. On enable we do want to do
			 * something.
			 */
		}
		work = work->next;
	}
	if (ret == SA_OK)
		ret = sa_update_config(handle);
	return (ret);
}

/*
 * sa_disable_group(flags, argc, argv)
 *
 * Implements the disable subcommand
 */

int
sa_disable_group(sa_handle_t handle, int flags, int argc, char *argv[])
{
	int verbose = 0;
	int dryrun = 0;
	int all = 0;
	int c;
	int ret = SA_OK;
	char *protocol = NULL;
	char *state;
	struct list *worklist = NULL;
	sa_group_t group;
	int auth = 1;

	while ((c = getopt(argc, argv, "?havn")) != EOF) {
		switch (c) {
		case 'a':
			all = 1;
			break;
		case 'n':
			dryrun++;
			break;
		case 'P':
			if (protocol != NULL) {
				(void) printf(gettext(
				    "Specifying multiple protocols "
				    "not supported: %s\n"), protocol);
				return (SA_SYNTAX_ERR);
			}
			protocol = optarg;
			if (!sa_valid_protocol(protocol)) {
				(void) printf(gettext(
				    "Invalid protocol specified: %s\n"),
				    protocol);
				return (SA_INVALID_PROTOCOL);
			}
			break;
		case 'v':
			verbose++;
			break;
		case 'h':
			/* optopt on valid arg isn't defined */
			optopt = c;
			/*FALLTHROUGH*/
		case '?':
		default:
			/*
			 * Since a bad option gets to here, sort it
			 * out and return a syntax error return value
			 * if necessary.
			 */
			switch (optopt) {
			default:
				ret = SA_SYNTAX_ERR;
				break;
			case 'h':
			case '?':
				break;
			}
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_DISABLE));
			return (ret);
		}
	}

	if (optind == argc && !all) {
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_DISABLE));
		(void) printf(gettext("\tmust specify group\n"));
		return (SA_NO_SUCH_PATH);
	}
	if (!all) {
		while (optind < argc) {
			group = sa_get_group(handle, argv[optind]);
			if (group != NULL) {
				auth &= check_authorizations(argv[optind],
				    flags);
				state = sa_get_group_attr(group, "state");
				if (state == NULL ||
				    strcmp(state, "disabled") == 0) {
					/* already disabled */
					if (verbose)
						(void) printf(gettext(
						    "Group \"%s\" is "
						    "already disabled\n"),
						    argv[optind]);
					ret = SA_BUSY; /* already disabled */
				} else {
					worklist = add_list(worklist, group, 0,
					    protocol);
					if (verbose)
						(void) printf(gettext(
						    "Disabling group "
						    "\"%s\"\n"), argv[optind]);
				}
				if (state != NULL)
					sa_free_attr_string(state);
			} else {
				ret = SA_NO_SUCH_GROUP;
			}
			optind++;
		}
	} else {
		for (group = sa_get_group(handle, NULL);
		    group != NULL;
		    group = sa_get_next_group(group))
			worklist = add_list(worklist, group, 0, protocol);
	}

	if (ret == SA_OK && !dryrun)
		ret = disable_all_groups(handle, worklist, 1);
	if (ret != SA_OK && ret != SA_BUSY)
		(void) printf(gettext("Could not disable group: %s\n"),
		    sa_errorstr(ret));
	if (ret == SA_BUSY)
		ret = SA_OK;
	if (worklist != NULL)
		free_list(worklist);
	if (dryrun && ret == SA_OK && !auth && verbose)
		(void) printf(gettext("Command would fail: %s\n"),
		    sa_errorstr(SA_NO_PERMISSION));
	return (ret);
}

/*
 * sa_start_group(flags, argc, argv)
 *
 * Implements the start command.
 * This is similar to enable except it doesn't change the state
 * of the group(s) and only enables shares if the group is already
 * enabled.
 */

int
sa_start_group(sa_handle_t handle, int flags, int argc, char *argv[])
{
	int verbose = 0;
	int all = 0;
	int c;
	int ret = SMF_EXIT_OK;
	char *protocol = NULL;
	char *state;
	struct list *worklist = NULL;
	sa_group_t group;
#ifdef lint
	flags = flags;
#endif

	while ((c = getopt(argc, argv, "?havP:")) != EOF) {
		switch (c) {
		case 'a':
			all = 1;
			break;
		case 'P':
			if (protocol != NULL) {
				(void) printf(gettext(
				    "Specifying multiple protocols "
				    "not supported: %s\n"), protocol);
				return (SA_SYNTAX_ERR);
			}
			protocol = optarg;
			if (!sa_valid_protocol(protocol)) {
				(void) printf(gettext(
				    "Invalid protocol specified: %s\n"),
				    protocol);
				return (SA_INVALID_PROTOCOL);
			}
			break;
		case 'v':
			verbose++;
			break;
		case 'h':
			/* optopt on valid arg isn't defined */
			optopt = c;
			/*FALLTHROUGH*/
		case '?':
		default:
			/*
			 * Since a bad option gets to here, sort it
			 * out and return a syntax error return value
			 * if necessary.
			 */
			ret = SA_OK;
			switch (optopt) {
			default:
				ret = SA_SYNTAX_ERR;
				break;
			case 'h':
			case '?':
				break;
			}
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_START));
			return (ret);
		}
	}

	if (optind == argc && !all) {
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_START));
		return (SMF_EXIT_ERR_FATAL);
	}

	if (!all) {
		while (optind < argc) {
			group = sa_get_group(handle, argv[optind]);
			if (group != NULL) {
				state = sa_get_group_attr(group, "state");
				if (state == NULL ||
				    strcmp(state, "enabled") == 0) {
					worklist = add_list(worklist, group, 0,
					    protocol);
					if (verbose)
						(void) printf(gettext(
						    "Starting group \"%s\"\n"),
						    argv[optind]);
				} else {
					/*
					 * Determine if there are any
					 * protocols.  If there aren't any,
					 * then there isn't anything to do in
					 * any case so no error.
					 */
					if (sa_get_optionset(group,
					    protocol) != NULL) {
						ret = SMF_EXIT_OK;
					}
				}
				if (state != NULL)
					sa_free_attr_string(state);
			}
			optind++;
		}
	} else {
		for (group = sa_get_group(handle, NULL);
		    group != NULL;
		    group = sa_get_next_group(group)) {
			state = sa_get_group_attr(group, "state");
			if (state == NULL || strcmp(state, "enabled") == 0)
				worklist = add_list(worklist, group, 0,
				    protocol);
			if (state != NULL)
				sa_free_attr_string(state);
		}
	}

	(void) enable_all_groups(handle, worklist, 0, 1, protocol, B_FALSE);

	if (worklist != NULL)
		free_list(worklist);
	return (ret);
}

/*
 * sa_stop_group(flags, argc, argv)
 *
 * Implements the stop command.
 * This is similar to disable except it doesn't change the state
 * of the group(s) and only disables shares if the group is already
 * enabled.
 */
int
sa_stop_group(sa_handle_t handle, int flags, int argc, char *argv[])
{
	int verbose = 0;
	int all = 0;
	int c;
	int ret = SMF_EXIT_OK;
	char *protocol = NULL;
	char *state;
	struct list *worklist = NULL;
	sa_group_t group;
#ifdef lint
	flags = flags;
#endif

	while ((c = getopt(argc, argv, "?havP:")) != EOF) {
		switch (c) {
		case 'a':
			all = 1;
			break;
		case 'P':
			if (protocol != NULL) {
				(void) printf(gettext(
				    "Specifying multiple protocols "
				    "not supported: %s\n"), protocol);
				return (SA_SYNTAX_ERR);
			}
			protocol = optarg;
			if (!sa_valid_protocol(protocol)) {
				(void) printf(gettext(
				    "Invalid protocol specified: %s\n"),
				    protocol);
				return (SA_INVALID_PROTOCOL);
			}
			break;
		case 'v':
			verbose++;
			break;
		case 'h':
			/* optopt on valid arg isn't defined */
			optopt = c;
			/*FALLTHROUGH*/
		case '?':
		default:
			/*
			 * Since a bad option gets to here, sort it
			 * out and return a syntax error return value
			 * if necessary.
			 */
			ret = SA_OK;
			switch (optopt) {
			default:
				ret = SA_SYNTAX_ERR;
				break;
			case 'h':
			case '?':
				break;
			}
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_STOP));
			return (ret);
		}
	}

	if (optind == argc && !all) {
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_STOP));
		return (SMF_EXIT_ERR_FATAL);
	} else if (!all) {
		while (optind < argc) {
			group = sa_get_group(handle, argv[optind]);
			if (group != NULL) {
				state = sa_get_group_attr(group, "state");
				if (state == NULL ||
				    strcmp(state, "enabled") == 0) {
					worklist = add_list(worklist, group, 0,
					    protocol);
					if (verbose)
						(void) printf(gettext(
						    "Stopping group \"%s\"\n"),
						    argv[optind]);
				} else {
					ret = SMF_EXIT_OK;
				}
				if (state != NULL)
					sa_free_attr_string(state);
			}
			optind++;
		}
	} else {
		for (group = sa_get_group(handle, NULL);
		    group != NULL;
		    group = sa_get_next_group(group)) {
			state = sa_get_group_attr(group, "state");
			if (state == NULL || strcmp(state, "enabled") == 0)
				worklist = add_list(worklist, group, 0,
				    protocol);
			if (state != NULL)
				sa_free_attr_string(state);
		}
	}
	(void) disable_all_groups(handle, worklist, 0);
	ret = sa_update_config(handle);

	if (worklist != NULL)
		free_list(worklist);
	return (ret);
}

/*
 * remove_all_options(share, proto)
 *
 * Removes all options on a share.
 */

static void
remove_all_options(sa_share_t share, char *proto)
{
	sa_optionset_t optionset;
	sa_security_t security;
	sa_security_t prevsec = NULL;

	optionset = sa_get_optionset(share, proto);
	if (optionset != NULL)
		(void) sa_destroy_optionset(optionset);
	for (security = sa_get_security(share, NULL, NULL);
	    security != NULL;
	    security = sa_get_next_security(security)) {
		char *type;
		/*
		 * We walk through the list.  prevsec keeps the
		 * previous security so we can delete it without
		 * destroying the list.
		 */
		if (prevsec != NULL) {
			/* remove the previously seen security */
			(void) sa_destroy_security(prevsec);
			/* set to NULL so we don't try multiple times */
			prevsec = NULL;
		}
		type = sa_get_security_attr(security, "type");
		if (type != NULL) {
			/*
			 * if the security matches the specified protocol, we
			 * want to remove it. prevsec holds it until either
			 * the next pass or we fall out of the loop.
			 */
			if (strcmp(type, proto) == 0)
				prevsec = security;
			sa_free_attr_string(type);
		}
	}
	/* in case there is one left */
	if (prevsec != NULL)
		(void) sa_destroy_security(prevsec);
}


/*
 * for legacy support, we need to handle the old syntax. This is what
 * we get if sharemgr is called with the name "share" rather than
 * sharemgr.
 */

static int
format_legacy_path(char *buff, int buffsize, char *proto, char *cmd)
{
	int err;

	err = snprintf(buff, buffsize, "/usr/lib/fs/%s/%s", proto, cmd);
	if (err > buffsize)
		return (-1);
	return (0);
}


/*
 * check_legacy_cmd(proto, cmd)
 *
 * Check to see if the cmd exists in /usr/lib/fs/<proto>/<cmd> and is
 * executable.
 */

static int
check_legacy_cmd(char *path)
{
	struct stat st;
	int ret = 0;

	if (stat(path, &st) == 0) {
		if (S_ISREG(st.st_mode) &&
		    st.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH))
			ret = 1;
	}
	return (ret);
}

/*
 * run_legacy_command(proto, cmd, argv)
 *
 * We know the command exists, so attempt to execute it with all the
 * arguments. This implements full legacy share support for those
 * protocols that don't have plugin providers.
 */

static int
run_legacy_command(char *path, char *argv[])
{
	int ret;

	ret = execv(path, argv);
	if (ret < 0) {
		switch (errno) {
		case EACCES:
			ret = SA_NO_PERMISSION;
			break;
		default:
			ret = SA_SYSTEM_ERR;
			break;
		}
	}
	return (ret);
}

/*
 * out_share(out, group, proto)
 *
 * Display the share information in the format that the "share"
 * command has traditionally used.
 */

static void
out_share(FILE *out, sa_group_t group, char *proto)
{
	sa_share_t share;
	char resfmt[128];
	char *defprop;

	/*
	 * The original share command defaulted to displaying NFS
	 * shares or allowed a protocol to be specified. We want to
	 * skip those shares that are not the specified protocol.
	 */
	if (proto != NULL && sa_get_optionset(group, proto) == NULL)
		return;

	if (proto == NULL)
		proto = "nfs";

	/*
	 * get the default property string.  NFS uses "rw" but
	 * everything else will use "".
	 */
	if (proto != NULL && strcmp(proto, "nfs") != 0)
		defprop = "\"\"";
	else
		defprop = "rw";

	for (share = sa_get_share(group, NULL);
	    share != NULL;
	    share = sa_get_next_share(share)) {
		char *path;
		char *type;
		char *resource;
		char *description;
		char *groupname;
		char *sharedstate;
		int shared = 1;
		char *soptions;
		char shareopts[MAXNAMLEN];

		sharedstate = sa_get_share_attr(share, "shared");
		path = sa_get_share_attr(share, "path");
		type = sa_get_share_attr(share, "type");
		resource = get_resource(share);
		groupname = sa_get_group_attr(group, "name");

		if (groupname != NULL && strcmp(groupname, "default") == 0) {
			sa_free_attr_string(groupname);
			groupname = NULL;
		}
		description = sa_get_share_description(share);

		/*
		 * Want the sharetab version if it exists, defaulting
		 * to NFS if no protocol specified.
		 */
		(void) snprintf(shareopts, MAXNAMLEN, "shareopts-%s", proto);
		soptions = sa_get_share_attr(share, shareopts);

		if (sharedstate == NULL)
			shared = 0;

		if (soptions == NULL)
			soptions = sa_proto_legacy_format(proto, share, 1);

		if (shared) {
			/* only active shares go here */
			(void) snprintf(resfmt, sizeof (resfmt), "%s%s%s",
			    resource != NULL ? resource : "-",
			    groupname != NULL ? "@" : "",
			    groupname != NULL ? groupname : "");
			(void) fprintf(out, "%-14.14s  %s   %s   \"%s\"  \n",
			    resfmt, (path != NULL) ? path : "",
			    (soptions != NULL && strlen(soptions) > 0) ?
			    soptions : defprop,
			    (description != NULL) ? description : "");
		}

		if (path != NULL)
			sa_free_attr_string(path);
		if (type != NULL)
			sa_free_attr_string(type);
		if (resource != NULL)
			sa_free_attr_string(resource);
		if (groupname != NULL)
			sa_free_attr_string(groupname);
		if (description != NULL)
			sa_free_share_description(description);
		if (sharedstate != NULL)
			sa_free_attr_string(sharedstate);
		if (soptions != NULL)
			sa_format_free(soptions);
	}
}

/*
 * output_legacy_file(out, proto)
 *
 * Walk all of the groups for the specified protocol and call
 * out_share() to format and write in the format displayed by the
 * "share" command with no arguments.
 */

static void
output_legacy_file(FILE *out, char *proto, sa_handle_t handle)
{
	sa_group_t group;

	for (group = sa_get_group(handle, NULL);
	    group != NULL;
	    group = sa_get_next_group(group)) {
		char *zfs;

		/*
		 * Go through all the groups and ZFS
		 * sub-groups. out_share() will format the shares in
		 * the group appropriately.
		 */

		zfs = sa_get_group_attr(group, "zfs");
		if (zfs != NULL) {
			sa_group_t zgroup;
			sa_free_attr_string(zfs);
			for (zgroup = sa_get_sub_group(group);
			    zgroup != NULL;
			    zgroup = sa_get_next_group(zgroup)) {

				/* got a group, so display it */
				out_share(out, zgroup, proto);
			}
		} else {
			out_share(out, group, proto);
		}
	}
}

int
sa_legacy_share(sa_handle_t handle, int flags, int argc, char *argv[])
{
	char *protocol = "nfs";
	char *options = NULL;
	char *description = NULL;
	char *groupname = NULL;
	char *sharepath = NULL;
	char *resource = NULL;
	char *groupstatus = NULL;
	int persist = SA_SHARE_TRANSIENT;
	int argsused = 0;
	int c;
	int ret = SA_OK;
	int zfs = 0;
	int true_legacy = 0;
	int curtype = SA_SHARE_TRANSIENT;
	char cmd[MAXPATHLEN];
	sa_group_t group = NULL;
	sa_resource_t rsrc = NULL;
	sa_share_t share;
	char dir[MAXPATHLEN];
	uint64_t features;
#ifdef lint
	flags = flags;
#endif

	while ((c = getopt(argc, argv, "?hF:d:o:p")) != EOF) {
		switch (c) {
		case 'd':
			description = optarg;
			argsused++;
			break;
		case 'F':
			protocol = optarg;
			if (!sa_valid_protocol(protocol)) {
				if (format_legacy_path(cmd, MAXPATHLEN,
				    protocol, "share") == 0 &&
				    check_legacy_cmd(cmd)) {
					true_legacy++;
				} else {
					(void) fprintf(stderr, gettext(
					    "Invalid protocol specified: "
					    "%s\n"), protocol);
					return (SA_INVALID_PROTOCOL);
				}
			}
			break;
		case 'o':
			options = optarg;
			argsused++;
			break;
		case 'p':
			persist = SA_SHARE_PERMANENT;
			argsused++;
			break;
		case 'h':
			/* optopt on valid arg isn't defined */
			optopt = c;
			/*FALLTHROUGH*/
		case '?':
		default:
			/*
			 * Since a bad option gets to here, sort it
			 * out and return a syntax error return value
			 * if necessary.
			 */
			switch (optopt) {
			default:
				ret = SA_LEGACY_ERR;
				break;
			case 'h':
			case '?':
				break;
			}
			(void) fprintf(stderr, gettext("usage: %s\n"),
			    sa_get_usage(USAGE_SHARE));
			return (ret);
		}
	}

	/* Have the info so construct what is needed */
	if (!argsused && optind == argc) {
		/* display current info in share format */
		(void) output_legacy_file(stdout, protocol, handle);
		return (ret);
	}

	/* We are modifying the configuration */
	if (optind == argc) {
		(void) fprintf(stderr, gettext("usage: %s\n"),
		    sa_get_usage(USAGE_SHARE));
		return (SA_LEGACY_ERR);
	}
	if (true_legacy) {
		/* If still using legacy share/unshare, exec it */
		ret = run_legacy_command(cmd, argv);
		return (ret);
	}

	sharepath = argv[optind++];
	if (optind < argc) {
		resource = argv[optind];
		groupname = strchr(resource, '@');
		if (groupname != NULL)
			*groupname++ = '\0';
	}
	if (realpath(sharepath, dir) == NULL)
		ret = SA_BAD_PATH;
	else
		sharepath = dir;
	if (ret == SA_OK)
		share = sa_find_share(handle, sharepath);
	else
		share = NULL;

	features = sa_proto_get_featureset(protocol);

	if (groupname != NULL) {
		ret = SA_NOT_ALLOWED;
	} else if (ret == SA_OK) {
		char *legacygroup;
		/*
		 * The legacy group is always present and zfs groups
		 * come and go.  zfs shares may be in sub-groups and
		 * the zfs share will already be in that group so it
		 * isn't an error. If the protocol is "smb", the group
		 * "smb" is used when "default" would otherwise be
		 * used.  "default" is NFS only and "smb" is SMB only.
		 */
		if (strcmp(protocol, "smb") == 0)
			legacygroup = "smb";
		else
			legacygroup = "default";

		/*
		 * If the share exists (not NULL), then make sure it
		 * is one we want to handle by getting the parent
		 * group.
		 */
		if (share != NULL) {
			group = sa_get_parent_group(share);
		} else {
			group = sa_get_group(handle, legacygroup);
			if (group == NULL && strcmp(legacygroup, "smb") == 0) {
				/*
				 * This group may not exist, so create
				 * as necessary. It only contains the
				 * "smb" protocol.
				 */
				group = sa_create_group(handle, legacygroup,
				    &ret);
				if (group != NULL)
					(void) sa_create_optionset(group,
					    protocol);
			}
		}

		if (group == NULL) {
			ret = SA_SYSTEM_ERR;
			goto err;
		}

		groupstatus = group_status(group);
		if (share == NULL) {
			share = sa_add_share(group, sharepath,
			    persist, &ret);
			if (share == NULL &&
			    ret == SA_DUPLICATE_NAME) {
				/*
				 * Could be a ZFS path being started
				 */
				if (sa_zfs_is_shared(handle,
				    sharepath)) {
					ret = SA_OK;
					group = sa_get_group(handle,
					    "zfs");
					if (group == NULL) {
						/*
						 * This shouldn't
						 * happen.
						 */
						ret = SA_CONFIG_ERR;
					} else {
						share = sa_add_share(
						    group, sharepath,
						    persist, &ret);
					}
				}
			}
		} else {
			char *type;
			/*
			 * May want to change persist state, but the
			 * important thing is to change options. We
			 * need to change them regardless of the
			 * source.
			 */

			if (sa_zfs_is_shared(handle, sharepath)) {
				zfs = 1;
			}
			remove_all_options(share, protocol);
			type = sa_get_share_attr(share, "type");
			if (type != NULL &&
			    strcmp(type, "transient") != 0) {
				curtype = SA_SHARE_PERMANENT;
			}
			if (type != NULL)
				sa_free_attr_string(type);
			if (curtype != persist) {
				(void) sa_set_share_attr(share, "type",
				    persist == SA_SHARE_PERMANENT ?
				    "persist" : "transient");
			}
		}

		/*
		 * If there is a resource name, we may
		 * actually care about it if this is share for
		 * a protocol that uses resource level sharing
		 * (SMB). We need to find the resource and, if
		 * it exists, make sure it belongs to the
		 * current share. If it doesn't exist, attempt
		 * to create it.
		 */

		if (ret == SA_OK && resource != NULL) {
			rsrc = sa_find_resource(handle, resource);
			if (rsrc != NULL) {
				if (share != sa_get_resource_parent(rsrc))
					ret = SA_DUPLICATE_NAME;
				} else {
					rsrc = sa_add_resource(share, resource,
					    persist, &ret);
				}
				if (features & SA_FEATURE_RESOURCE)
					share = rsrc;
			}

			/* Have a group to hold this share path */
			if (ret == SA_OK && options != NULL &&
			    strlen(options) > 0) {
				ret = sa_parse_legacy_options(share,
				    options,
				    protocol);
			}
			if (!zfs) {
				/*
				 * ZFS shares never have a description
				 * and we can't store the values so
				 * don't try.
				 */
				if (ret == SA_OK && description != NULL)
					ret = sa_set_share_description(share,
					    description);
			}
			if (ret == SA_OK &&
			    strcmp(groupstatus, "enabled") == 0) {
				if (rsrc != share)
					ret = sa_enable_share(share, protocol);
				else
					ret = sa_enable_resource(rsrc,
					    protocol);
				if (ret == SA_OK &&
				    persist == SA_SHARE_PERMANENT) {
					(void) sa_update_legacy(share,
					    protocol);
				}
				if (ret == SA_OK)
					ret = sa_update_config(handle);
			}
	}
err:
	if (ret != SA_OK) {
		(void) fprintf(stderr, gettext("Could not share: %s: %s\n"),
		    sharepath, sa_errorstr(ret));
		ret = SA_LEGACY_ERR;
	}
	return (ret);
}

/*
 * sa_legacy_unshare(flags, argc, argv)
 *
 * Implements the original unshare command.
 */
int
sa_legacy_unshare(sa_handle_t handle, int flags, int argc, char *argv[])
{
	char *protocol = "nfs"; /* for now */
	char *options = NULL;
	char *sharepath = NULL;
	int persist = SA_SHARE_TRANSIENT;
	int argsused = 0;
	int c;
	int ret = SA_OK;
	int true_legacy = 0;
	uint64_t features = 0;
	sa_resource_t resource = NULL;
	char cmd[MAXPATHLEN];
#ifdef lint
	flags = flags;
	options = options;
#endif

	while ((c = getopt(argc, argv, "?hF:o:p")) != EOF) {
		switch (c) {
		case 'F':
			protocol = optarg;
			if (!sa_valid_protocol(protocol)) {
				if (format_legacy_path(cmd, MAXPATHLEN,
				    protocol, "unshare") == 0 &&
				    check_legacy_cmd(cmd)) {
					true_legacy++;
				} else {
					(void) printf(gettext(
					    "Invalid file system name\n"));
					return (SA_INVALID_PROTOCOL);
				}
			}
			break;
		case 'o':
			options = optarg;
			argsused++;
			break;
		case 'p':
			persist = SA_SHARE_PERMANENT;
			argsused++;
			break;
		case 'h':
			/* optopt on valid arg isn't defined */
			optopt = c;
			/*FALLTHROUGH*/
		case '?':
		default:
			/*
			 * Since a bad option gets to here, sort it
			 * out and return a syntax error return value
			 * if necessary.
			 */
			switch (optopt) {
			default:
				ret = SA_LEGACY_ERR;
				break;
			case 'h':
			case '?':
				break;
			}
			(void) printf(gettext("usage: %s\n"),
			    sa_get_usage(USAGE_UNSHARE));
			return (ret);
		}
	}

	/* Have the info so construct what is needed */
	if (optind == argc || (optind + 1) < argc || options != NULL) {
		ret = SA_SYNTAX_ERR;
	} else {
		sa_share_t share;
		char dir[MAXPATHLEN];
		if (true_legacy) {
			/* if still using legacy share/unshare, exec it */
			ret = run_legacy_command(cmd, argv);
			return (ret);
		}
		/*
		 * Find the path in the internal configuration. If it
		 * isn't found, attempt to resolve the path via
		 * realpath() and try again.
		 */
		sharepath = argv[optind++];
		share = sa_find_share(handle, sharepath);
		if (share == NULL) {
			if (realpath(sharepath, dir) == NULL) {
				ret = SA_NO_SUCH_PATH;
			} else {
				share = sa_find_share(handle, dir);
			}
		}
		if (share == NULL) {
			/* Could be a resource name so check that next */
			features = sa_proto_get_featureset(protocol);
			resource = sa_find_resource(handle, sharepath);
			if (resource != NULL) {
				share = sa_get_resource_parent(resource);
				if (features & SA_FEATURE_RESOURCE)
					(void) sa_disable_resource(resource,
					    protocol);
				if (persist == SA_SHARE_PERMANENT) {
					ret = sa_remove_resource(resource);
					if (ret == SA_OK)
						ret = sa_update_config(handle);
				}
				/*
				 * If we still have a resource on the
				 * share, we don't disable the share
				 * itself. IF there aren't anymore, we
				 * need to remove the share. The
				 * removal will be done in the next
				 * section if appropriate.
				 */
				resource = sa_get_share_resource(share, NULL);
				if (resource != NULL)
					share = NULL;
			} else if (ret == SA_OK) {
				/* Didn't find path and no  resource */
				ret = SA_BAD_PATH;
			}
		}
		if (share != NULL && resource == NULL) {
			ret = sa_disable_share(share, protocol);
			/*
			 * Errors are ok and removal should still occur. The
			 * legacy unshare is more forgiving of errors than the
			 * remove-share subcommand which may need the force
			 * flag set for some error conditions. That is, the
			 * "unshare" command will always unshare if it can
			 * while "remove-share" might require the force option.
			 */
			if (persist == SA_SHARE_PERMANENT) {
				ret = sa_remove_share(share);
				if (ret == SA_OK)
					ret = sa_update_config(handle);
			}
		} else if (ret == SA_OK && share == NULL && resource == NULL) {
			/*
			 * If both share and resource are NULL, then
			 * share not found. If one or the other was
			 * found or there was an earlier error, we
			 * assume it was handled earlier.
			 */
			ret = SA_NOT_SHARED;
		}
	}
	switch (ret) {
	default:
		(void) printf("%s: %s\n", sharepath, sa_errorstr(ret));
		ret = SA_LEGACY_ERR;
		break;
	case SA_SYNTAX_ERR:
		(void) printf(gettext("usage: %s\n"),
		    sa_get_usage(USAGE_UNSHARE));
		break;
	case SA_OK:
		break;
	}
	return (ret);
}

/*
 * Common commands that implement the sub-commands used by all
 * protocols. The entries are found via the lookup command
 */

static sa_command_t commands[] = {
	{"add-share", 0, sa_addshare, USAGE_ADD_SHARE, SVC_SET},
	{"create", 0, sa_create, USAGE_CREATE, SVC_SET|SVC_ACTION},
	{"delete", 0, sa_delete, USAGE_DELETE, SVC_SET|SVC_ACTION},
	{"disable", 0, sa_disable_group, USAGE_DISABLE, SVC_SET|SVC_ACTION},
	{"enable", 0, sa_enable_group, USAGE_ENABLE, SVC_SET|SVC_ACTION},
	{"list", 0, sa_list, USAGE_LIST},
	{"move-share", 0, sa_moveshare, USAGE_MOVE_SHARE, SVC_SET},
	{"remove-share", 0, sa_removeshare, USAGE_REMOVE_SHARE, SVC_SET},
	{"set", 0, sa_set, USAGE_SET, SVC_SET},
	{"set-share", 0, sa_set_share, USAGE_SET_SHARE, SVC_SET},
	{"show", 0, sa_show, USAGE_SHOW},
	{"share", 0, sa_legacy_share, USAGE_SHARE, SVC_SET|SVC_ACTION},
	{"start", CMD_NODISPLAY, sa_start_group, USAGE_START,
	    SVC_SET|SVC_ACTION},
	{"stop", CMD_NODISPLAY, sa_stop_group, USAGE_STOP, SVC_SET|SVC_ACTION},
	{"unset", 0, sa_unset, USAGE_UNSET, SVC_SET},
	{"unshare", 0, sa_legacy_unshare, USAGE_UNSHARE, SVC_SET|SVC_ACTION},
	{NULL, 0, NULL, NULL}
};

static char *
sa_get_usage(sa_usage_t index)
{
	char *ret = NULL;
	switch (index) {
	case USAGE_ADD_SHARE:
		ret = gettext("add-share [-nth] [-r resource-name] "
		    "[-d \"description text\"] -s sharepath group");
		break;
	case USAGE_CREATE:
		ret = gettext(
		    "create [-nvh] [-P proto [-p property=value]] group");
		break;
	case USAGE_DELETE:
		ret = gettext("delete [-nvh] [-P proto] [-f] group");
		break;
	case USAGE_DISABLE:
		ret = gettext("disable [-nvh] {-a | group ...}");
		break;
	case USAGE_ENABLE:
		ret = gettext("enable [-nvh] {-a | group ...}");
		break;
	case USAGE_LIST:
		ret = gettext("list [-vh] [-P proto]");
		break;
	case USAGE_MOVE_SHARE:
		ret = gettext(
		    "move-share [-nvh] -s sharepath destination-group");
		break;
	case USAGE_REMOVE_SHARE:
		ret = gettext(
		    "remove-share [-fnvh] {-s sharepath | -r resource} "
		    "group");
		break;
	case USAGE_SET:
		ret = gettext("set [-nvh] -P proto [-S optspace] "
		    "[-p property=value]* [-s sharepath] [-r resource]] "
		    "group");
		break;
	case USAGE_SET_SECURITY:
		ret = gettext("set-security [-nvh] -P proto -S security-type "
		    "[-p property=value]* group");
		break;
	case USAGE_SET_SHARE:
		ret = gettext("set-share [-nh] [-r resource] "
		    "[-d \"description text\"] -s sharepath group");
		break;
	case USAGE_SHOW:
		ret = gettext("show [-pvxh] [-P proto] [group ...]");
		break;
	case USAGE_SHARE:
		ret = gettext("share [-F fstype] [-p] [-o optionlist]"
		    "[-d description] [pathname [resourcename]]");
		break;
	case USAGE_START:
		ret = gettext("start [-vh] [-P proto] {-a | group ...}");
		break;
	case USAGE_STOP:
		ret = gettext("stop [-vh] [-P proto] {-a | group ...}");
		break;
	case USAGE_UNSET:
		ret = gettext("unset [-nvh] -P proto [-S optspace] "
		    "[-p property]* group");
		break;
	case USAGE_UNSET_SECURITY:
		ret = gettext("unset-security [-nvh] -P proto "
		    "-S security-type [-p property]* group");
		break;
	case USAGE_UNSHARE:
		ret = gettext(
		    "unshare [-F fstype] [-p] [-o optionlist] sharepath");
		break;
	}
	return (ret);
}

/*
 * sa_lookup(cmd, proto)
 *
 * Lookup the sub-command. proto isn't currently used, but it may
 * eventually provide a way to provide protocol specific sub-commands.
 */
sa_command_t *
sa_lookup(char *cmd, char *proto)
{
	int i;
	size_t len;
#ifdef lint
	proto = proto;
#endif

	len = strlen(cmd);
	for (i = 0; commands[i].cmdname != NULL; i++) {
		if (strncmp(cmd, commands[i].cmdname, len) == 0)
			return (&commands[i]);
	}
	return (NULL);
}

void
sub_command_help(char *proto)
{
	int i;
#ifdef lint
	proto = proto;
#endif

	(void) printf(gettext("\tsub-commands:\n"));
	for (i = 0; commands[i].cmdname != NULL; i++) {
		if (!(commands[i].flags & (CMD_ALIAS|CMD_NODISPLAY)))
			(void) printf("\t%s\n",
			    sa_get_usage((sa_usage_t)commands[i].cmdidx));
	}
}