dfs.cmds/sharemgr/commands.c

/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#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)) {
			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;

	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);
			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(