xref: /titanic_50/usr/src/cmd/dfs.cmds/sharemgr/commands.c (revision 330ef417fbd2286149a25e8033587edf7ae52ae5)
16185db85Sdougm /*
26185db85Sdougm  * CDDL HEADER START
36185db85Sdougm  *
46185db85Sdougm  * The contents of this file are subject to the terms of the
56185db85Sdougm  * Common Development and Distribution License (the "License").
66185db85Sdougm  * You may not use this file except in compliance with the License.
76185db85Sdougm  *
86185db85Sdougm  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
96185db85Sdougm  * or http://www.opensolaris.org/os/licensing.
106185db85Sdougm  * See the License for the specific language governing permissions
116185db85Sdougm  * and limitations under the License.
126185db85Sdougm  *
136185db85Sdougm  * When distributing Covered Code, include this CDDL HEADER in each
146185db85Sdougm  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
156185db85Sdougm  * If applicable, add the following below this CDDL HEADER, with the
166185db85Sdougm  * fields enclosed by brackets "[]" replaced with your own identifying
176185db85Sdougm  * information: Portions Copyright [yyyy] [name of copyright owner]
186185db85Sdougm  *
196185db85Sdougm  * CDDL HEADER END
206185db85Sdougm  */
216185db85Sdougm 
226185db85Sdougm /*
23f345c0beSdougm  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
246185db85Sdougm  * Use is subject to license terms.
256185db85Sdougm  */
266185db85Sdougm 
276185db85Sdougm #pragma ident	"%Z%%M%	%I%	%E% SMI"
286185db85Sdougm 
296185db85Sdougm #include <sys/types.h>
306185db85Sdougm #include <sys/stat.h>
316185db85Sdougm #include <fcntl.h>
326185db85Sdougm #include <stdlib.h>
336185db85Sdougm #include <stdio.h>
346185db85Sdougm #include <string.h>
356185db85Sdougm #include <ctype.h>
366185db85Sdougm #include <unistd.h>
376185db85Sdougm #include <getopt.h>
386185db85Sdougm #include <utmpx.h>
396185db85Sdougm #include <pwd.h>
406185db85Sdougm #include <auth_attr.h>
416185db85Sdougm #include <secdb.h>
426185db85Sdougm #include <sys/param.h>
436185db85Sdougm #include <sys/stat.h>
446185db85Sdougm #include <errno.h>
456185db85Sdougm 
466185db85Sdougm #include <libshare.h>
476185db85Sdougm #include "sharemgr.h"
486185db85Sdougm #include <libscf.h>
496185db85Sdougm #include <libxml/tree.h>
506185db85Sdougm #include <libintl.h>
516185db85Sdougm 
526185db85Sdougm static char *sa_get_usage(sa_usage_t);
536185db85Sdougm 
546185db85Sdougm /*
556185db85Sdougm  * Implementation of the common sub-commands supported by sharemgr.
566185db85Sdougm  * A number of helper functions are also included.
576185db85Sdougm  */
586185db85Sdougm 
596185db85Sdougm /*
606185db85Sdougm  * has_protocol(group, proto)
616185db85Sdougm  *	If the group has an optionset with the specified protocol,
626185db85Sdougm  *	return true (1) otherwise false (0).
636185db85Sdougm  */
646185db85Sdougm static int
656185db85Sdougm has_protocol(sa_group_t group, char *protocol)
666185db85Sdougm {
676185db85Sdougm 	sa_optionset_t optionset;
686185db85Sdougm 	int result = 0;
696185db85Sdougm 
706185db85Sdougm 	optionset = sa_get_optionset(group, protocol);
716185db85Sdougm 	if (optionset != NULL) {
726185db85Sdougm 	    result++;
736185db85Sdougm 	}
746185db85Sdougm 	return (result);
756185db85Sdougm }
766185db85Sdougm 
776185db85Sdougm /*
786185db85Sdougm  * add_list(list, item)
796185db85Sdougm  *	Adds a new list member that points to item to the list.
806185db85Sdougm  *	If list is NULL, it starts a new list.  The function returns
816185db85Sdougm  *	the first member of the list.
826185db85Sdougm  */
836185db85Sdougm struct list *
846185db85Sdougm add_list(struct list *listp, void *item, void *data)
856185db85Sdougm {
866185db85Sdougm 	struct list *new, *tmp;
876185db85Sdougm 
886185db85Sdougm 	new = malloc(sizeof (struct list));
896185db85Sdougm 	if (new != NULL) {
906185db85Sdougm 	    new->next = NULL;
916185db85Sdougm 	    new->item = item;
926185db85Sdougm 	    new->itemdata = data;
936185db85Sdougm 	} else {
946185db85Sdougm 	    return (listp);
956185db85Sdougm 	}
966185db85Sdougm 
976185db85Sdougm 	if (listp == NULL)
986185db85Sdougm 	    return (new);
996185db85Sdougm 
1006185db85Sdougm 	for (tmp = listp; tmp->next != NULL; tmp = tmp->next) {
1016185db85Sdougm 		/* get to end of list */
1026185db85Sdougm 	}
1036185db85Sdougm 	tmp->next = new;
1046185db85Sdougm 	return (listp);
1056185db85Sdougm }
1066185db85Sdougm 
1076185db85Sdougm /*
1086185db85Sdougm  * free_list(list)
1096185db85Sdougm  *	Given a list, free all the members of the list;
1106185db85Sdougm  */
1116185db85Sdougm static void
1126185db85Sdougm free_list(struct list *listp)
1136185db85Sdougm {
1146185db85Sdougm 	struct list *tmp;
1156185db85Sdougm 	while (listp != NULL) {
1166185db85Sdougm 	    tmp = listp;
1176185db85Sdougm 	    listp = listp->next;
1186185db85Sdougm 	    free(tmp);
1196185db85Sdougm 	}
1206185db85Sdougm }
1216185db85Sdougm 
1226185db85Sdougm /*
1236185db85Sdougm  * check_authorization(instname, which)
1246185db85Sdougm  *
1256185db85Sdougm  * Checks to see if the specific type of authorization in which is
1266185db85Sdougm  * enabled for the user in this SMF service instance.
1276185db85Sdougm  */
1286185db85Sdougm 
1296185db85Sdougm static int
1306185db85Sdougm check_authorization(char *instname, int which)
1316185db85Sdougm {
1326185db85Sdougm 	scf_handle_t *handle = NULL;
1336185db85Sdougm 	scf_simple_prop_t *prop = NULL;
1346185db85Sdougm 	char svcstring[SA_MAX_NAME_LEN + sizeof (SA_SVC_FMRI_BASE) + 1];
1356185db85Sdougm 	char *authstr = NULL;
1366185db85Sdougm 	ssize_t numauths;
1376185db85Sdougm 	int ret = 1;
1386185db85Sdougm 	uid_t uid;
1396185db85Sdougm 	struct passwd *pw = NULL;
1406185db85Sdougm 
1416185db85Sdougm 	uid = getuid();
1426185db85Sdougm 	pw = getpwuid(uid);
1436185db85Sdougm 	if (pw == NULL)
1446185db85Sdougm 	    ret = 0;
1456185db85Sdougm 
1466185db85Sdougm 	if (ret == 1) {
1476185db85Sdougm 	    /* since names  are restricted to SA_MAX_NAME_LEN won't overflow */
1486185db85Sdougm 	    (void) snprintf(svcstring, sizeof (svcstring),
1496185db85Sdougm 				"%s:%s", SA_SVC_FMRI_BASE, instname);
1506185db85Sdougm 	    handle = scf_handle_create(SCF_VERSION);
1516185db85Sdougm 	    if (handle != NULL) {
1526185db85Sdougm 		if (scf_handle_bind(handle) == 0) {
1536185db85Sdougm 		    switch (which) {
1546185db85Sdougm 		    case SVC_SET:
1556185db85Sdougm 			prop = scf_simple_prop_get(handle, svcstring,
1566185db85Sdougm 							"general",
1576185db85Sdougm 							SVC_AUTH_VALUE);
1586185db85Sdougm 			break;
1596185db85Sdougm 		    case SVC_ACTION:
1606185db85Sdougm 			prop = scf_simple_prop_get(handle, svcstring,
1616185db85Sdougm 							"general",
1626185db85Sdougm 							SVC_AUTH_ACTION);
1636185db85Sdougm 			break;
1646185db85Sdougm 		    }
1656185db85Sdougm 		}
1666185db85Sdougm 	    }
1676185db85Sdougm 	}
1686185db85Sdougm 	/* make sure we have an authorization string property */
1696185db85Sdougm 	if (prop != NULL) {
1706185db85Sdougm 	    int i;
1716185db85Sdougm 	    numauths = scf_simple_prop_numvalues(prop);
1726185db85Sdougm 	    for (ret = 0, i = 0; i < numauths; i++) {
1736185db85Sdougm 		authstr = scf_simple_prop_next_astring(prop);
1746185db85Sdougm 		if (authstr != NULL) {
1756185db85Sdougm 		    /* check if this user has one of the strings */
1766185db85Sdougm 		    if (chkauthattr(authstr, pw->pw_name)) {
1776185db85Sdougm 			ret = 1;
1786185db85Sdougm 			break;
1796185db85Sdougm 		    }
1806185db85Sdougm 		}
1816185db85Sdougm 	    }
1826185db85Sdougm 	    endauthattr();
1836185db85Sdougm 	    scf_simple_prop_free(prop);
1846185db85Sdougm 	} else {
1856185db85Sdougm 	    /* no authorization string defined */
1866185db85Sdougm 	    ret = 0;
1876185db85Sdougm 	}
1886185db85Sdougm 	if (handle != NULL)
1896185db85Sdougm 	    scf_handle_destroy(handle);
1906185db85Sdougm 	return (ret);
1916185db85Sdougm }
1926185db85Sdougm 
1936185db85Sdougm /*
1946185db85Sdougm  * check_authorizations(instname, flags)
1956185db85Sdougm  *
1966185db85Sdougm  * check all the needed authorizations for the user in this service
1976185db85Sdougm  * instance. Return value of 1(true) or 0(false) indicates whether
1986185db85Sdougm  * there are authorizations for the user or not.
1996185db85Sdougm  */
2006185db85Sdougm 
2016185db85Sdougm static int
2026185db85Sdougm check_authorizations(char *instname, int flags)
2036185db85Sdougm {
2046185db85Sdougm 	int ret1 = 0;
2056185db85Sdougm 	int ret2 = 0;
2066185db85Sdougm 	int ret;
2076185db85Sdougm 
2086185db85Sdougm 	if (flags & SVC_SET)
2096185db85Sdougm 	    ret1 = check_authorization(instname, SVC_SET);
2106185db85Sdougm 	if (flags & SVC_ACTION)
2116185db85Sdougm 	    ret2 = check_authorization(instname, SVC_ACTION);
2126185db85Sdougm 	switch (flags) {
2136185db85Sdougm 	case SVC_ACTION:
2146185db85Sdougm 	    ret = ret2;
2156185db85Sdougm 	    break;
2166185db85Sdougm 	case SVC_SET:
2176185db85Sdougm 	    ret = ret1;
2186185db85Sdougm 	    break;
2196185db85Sdougm 	case SVC_ACTION|SVC_SET:
2206185db85Sdougm 	    ret = ret1 & ret2;
2216185db85Sdougm 	    break;
2226185db85Sdougm 	default:
2236185db85Sdougm 	    /* if not flags set, we assume we don't need authorizations */
2246185db85Sdougm 	    ret = 1;
2256185db85Sdougm 	}
2266185db85Sdougm 	return (ret);
2276185db85Sdougm }
2286185db85Sdougm 
2296185db85Sdougm /*
2307d968cb8Sdougm  * enable_group(group, updateproto)
2317d968cb8Sdougm  *
2327d968cb8Sdougm  * enable all the shares in the specified group. This is a helper for
2337d968cb8Sdougm  * enable_all_groups in order to simplify regular and subgroup (zfs)
2347d968cb8Sdougm  * disabling. Group has already been checked for non-NULL.
2356185db85Sdougm  */
2367d968cb8Sdougm 
2377d968cb8Sdougm static void
2387d968cb8Sdougm enable_group(sa_group_t group, char *updateproto)
2396185db85Sdougm {
2406185db85Sdougm 	sa_share_t share;
2417d968cb8Sdougm 
2427d968cb8Sdougm 	for (share = sa_get_share(group, NULL);
2437d968cb8Sdougm 	    share != NULL;
2447d968cb8Sdougm 	    share = sa_get_next_share(share)) {
2457d968cb8Sdougm 	    if (updateproto != NULL)
2467d968cb8Sdougm 		(void) sa_update_legacy(share, updateproto);
2477d968cb8Sdougm 	    (void) sa_enable_share(share, NULL);
2487d968cb8Sdougm 	}
2497d968cb8Sdougm }
2507d968cb8Sdougm 
2517d968cb8Sdougm /*
252*330ef417Sdougm  * isenabled(group)
253*330ef417Sdougm  *
254*330ef417Sdougm  * Returns B_TRUE if the group is enabled or B_FALSE if it isn't.
255*330ef417Sdougm  * Moved to separate function to reduce clutter in the code.
256*330ef417Sdougm  */
257*330ef417Sdougm 
258*330ef417Sdougm static int
259*330ef417Sdougm isenabled(sa_group_t group)
260*330ef417Sdougm {
261*330ef417Sdougm 	char *state;
262*330ef417Sdougm 	int ret = B_FALSE;
263*330ef417Sdougm 
264*330ef417Sdougm 	if (group != NULL) {
265*330ef417Sdougm 	    state = sa_get_group_attr(group, "state");
266*330ef417Sdougm 	    if (state != NULL) {
267*330ef417Sdougm 		if (strcmp(state, "enabled") == 0)
268*330ef417Sdougm 		    ret = B_TRUE;
269*330ef417Sdougm 		sa_free_attr_string(state);
270*330ef417Sdougm 	    }
271*330ef417Sdougm 	}
272*330ef417Sdougm 	return (ret);
273*330ef417Sdougm }
274*330ef417Sdougm 
275*330ef417Sdougm /*
2767d968cb8Sdougm  * enable_all_groups(list, setstate, online, updateproto)
2777d968cb8Sdougm  *	Given a list of groups, enable each one found.  If updateproto
2787d968cb8Sdougm  *	is not NULL, then update all the shares for the protocol that
2797d968cb8Sdougm  *	was passed in.
2807d968cb8Sdougm  */
2817d968cb8Sdougm static int
282549ec3ffSdougm enable_all_groups(sa_handle_t handle, struct list *work, int setstate,
283549ec3ffSdougm 	int online, char *updateproto)
2847d968cb8Sdougm {
285*330ef417Sdougm 	int ret;
2866185db85Sdougm 	char instance[SA_MAX_NAME_LEN + sizeof (SA_SVC_FMRI_BASE) + 1];
2876185db85Sdougm 	char *state;
2886185db85Sdougm 	char *name;
2896185db85Sdougm 	char *zfs = NULL;
2906185db85Sdougm 	sa_group_t group;
2917d968cb8Sdougm 	sa_group_t subgroup;
2926185db85Sdougm 
293*330ef417Sdougm 	for (ret = SA_OK; work != NULL;	work = work->next) {
2946185db85Sdougm 	    group = (sa_group_t)work->item;
295*330ef417Sdougm 
296*330ef417Sdougm 		/*
297*330ef417Sdougm 		 * If setstate == TRUE, then make sure to set
298*330ef417Sdougm 		 * enabled. This needs to be done here in order for
299*330ef417Sdougm 		 * the isenabled check to succeed on a newly enabled
300*330ef417Sdougm 		 * group.
301*330ef417Sdougm 		 */
302*330ef417Sdougm 	    if (setstate == B_TRUE) {
303*330ef417Sdougm 		ret = sa_set_group_attr(group, "state",	"enabled");
304*330ef417Sdougm 		if (ret != SA_OK)
305*330ef417Sdougm 		    break;
306*330ef417Sdougm 	    }
307*330ef417Sdougm 
308*330ef417Sdougm 		/*
309*330ef417Sdougm 		 * Check to see if group is enabled. If it isn't, skip
310*330ef417Sdougm 		 * the rest.  We don't want shares starting if the
311*330ef417Sdougm 		 * group is disabled. The properties may have been
312*330ef417Sdougm 		 * updated, but there won't be a change until the
313*330ef417Sdougm 		 * group is enabled.
314*330ef417Sdougm 		 */
315*330ef417Sdougm 	    if (!isenabled(group))
316*330ef417Sdougm 		continue;
317*330ef417Sdougm 
3186185db85Sdougm 	    /* if itemdata != NULL then a single share */
3196185db85Sdougm 	    if (work->itemdata != NULL) {
3206185db85Sdougm 		ret = sa_enable_share((sa_share_t)work->itemdata, NULL);
3216185db85Sdougm 	    }
322*330ef417Sdougm 	    if (ret != SA_OK)
323*330ef417Sdougm 		break;
324*330ef417Sdougm 
3256185db85Sdougm 	    /* if itemdata == NULL then the whole group */
3266185db85Sdougm 	    if (work->itemdata == NULL) {
3277d968cb8Sdougm 		zfs = sa_get_group_attr(group, "zfs");
3287d968cb8Sdougm 		/*
3297d968cb8Sdougm 		 * if the share is managed by ZFS, don't
3307d968cb8Sdougm 		 * update any of the protocols since ZFS is
3317d968cb8Sdougm 		 * handling this.  updateproto will contain
3327d968cb8Sdougm 		 * the name of the protocol that we want to
3337d968cb8Sdougm 		 * update legacy files for.
3347d968cb8Sdougm 		 */
3357d968cb8Sdougm 		enable_group(group, zfs == NULL ? updateproto : NULL);
3367d968cb8Sdougm 		for (subgroup = sa_get_sub_group(group); subgroup != NULL;
3377d968cb8Sdougm 			subgroup = sa_get_next_group(subgroup)) {
3387d968cb8Sdougm 			/* never update legacy for ZFS subgroups */
3397d968cb8Sdougm 			enable_group(subgroup, NULL);
3406185db85Sdougm 		}
3416185db85Sdougm 	    }
3426185db85Sdougm 	    if (online) {
3436185db85Sdougm 		zfs = sa_get_group_attr(group, "zfs");
3447d968cb8Sdougm 		name = sa_get_group_attr(group, "name");
3456185db85Sdougm 		if (name != NULL) {
3466185db85Sdougm 			if (zfs == NULL) {
3476185db85Sdougm 			    (void) snprintf(instance, sizeof (instance),
3486185db85Sdougm 						"%s:%s",
3496185db85Sdougm 						SA_SVC_FMRI_BASE, name);
3506185db85Sdougm 			    state = smf_get_state(instance);
3516185db85Sdougm 			    if (state == NULL ||
3526185db85Sdougm 				strcmp(state, "online") != 0) {
3536185db85Sdougm 				(void) smf_enable_instance(instance, 0);
3546185db85Sdougm 				free(state);
3556185db85Sdougm 			    }
3566185db85Sdougm 			} else {
3576185db85Sdougm 			    sa_free_attr_string(zfs);
3586185db85Sdougm 			    zfs = NULL;
3596185db85Sdougm 			}
3606185db85Sdougm 			if (name != NULL)
3616185db85Sdougm 			    sa_free_attr_string(name);
3626185db85Sdougm 		}
3636185db85Sdougm 	    }
3646185db85Sdougm 	}
3656185db85Sdougm 	if (ret == SA_OK) {
366549ec3ffSdougm 	    ret = sa_update_config(handle);
3676185db85Sdougm 	}
3686185db85Sdougm 	return (ret);
3696185db85Sdougm }
3706185db85Sdougm 
3716185db85Sdougm /*
3726185db85Sdougm  * chk_opt(optlistp, security, proto)
3736185db85Sdougm  *
3746185db85Sdougm  * Do a sanity check on the optlist provided for the protocol.  This
3756185db85Sdougm  * is a syntax check and verification that the property is either a
3766185db85Sdougm  * general or specific to a names optionset.
3776185db85Sdougm  */
3786185db85Sdougm 
3796185db85Sdougm static int
3806185db85Sdougm chk_opt(struct options *optlistp, int security, char *proto)
3816185db85Sdougm {
3826185db85Sdougm 	struct options *optlist;
3836185db85Sdougm 	char *sep = "";
3846185db85Sdougm 	int notfirst = 0;
3856185db85Sdougm 	int ret;
3866185db85Sdougm 
3876185db85Sdougm 	for (optlist = optlistp; optlist != NULL; optlist = optlist->next) {
3886185db85Sdougm 	    char *optname;
3896185db85Sdougm 
3906185db85Sdougm 	    optname = optlist->optname;
3916185db85Sdougm 	    ret = OPT_ADD_OK;
3926185db85Sdougm 	    /* extract property/value pair */
3936185db85Sdougm 	    if (sa_is_security(optname, proto)) {
3946185db85Sdougm 		if (!security)
3956185db85Sdougm 		    ret = OPT_ADD_SECURITY;
3966185db85Sdougm 	    } else {
3976185db85Sdougm 		if (security)
3986185db85Sdougm 		    ret = OPT_ADD_PROPERTY;
3996185db85Sdougm 	    }
4006185db85Sdougm 	    if (ret != OPT_ADD_OK) {
4016185db85Sdougm 		if (notfirst == 0)
4026185db85Sdougm 		    (void) printf(gettext("Property syntax error: "));
4036185db85Sdougm 		switch (ret) {
4046185db85Sdougm 		case OPT_ADD_SYNTAX:
4056185db85Sdougm 		    (void) printf(gettext("%ssyntax error: %s"),
4066185db85Sdougm 				    sep, optname);
4076185db85Sdougm 		    sep = ", ";
4086185db85Sdougm 		    break;
4096185db85Sdougm 		case OPT_ADD_SECURITY:
4106185db85Sdougm 		    (void) printf(gettext("%s%s requires -S"),
4116185db85Sdougm 				    optname, sep);
4126185db85Sdougm 		    sep = ", ";
4136185db85Sdougm 		    break;
4146185db85Sdougm 		case OPT_ADD_PROPERTY:
4156185db85Sdougm 		    (void) printf(gettext("%s%s not supported with -S"),
4166185db85Sdougm 				    optname, sep);
4176185db85Sdougm 		    sep = ", ";
4186185db85Sdougm 		    break;
4196185db85Sdougm 		}
4206185db85Sdougm 		notfirst++;
4216185db85Sdougm 	    }
4226185db85Sdougm 	}
4236185db85Sdougm 	if (notfirst) {
4246185db85Sdougm 	    (void) printf("\n");
4256185db85Sdougm 	    ret = SA_SYNTAX_ERR;
4266185db85Sdougm 	}
4276185db85Sdougm 	return (ret);
4286185db85Sdougm }
4296185db85Sdougm 
4306185db85Sdougm /*
4316185db85Sdougm  * free_opt(optlist)
4326185db85Sdougm  *	Free the specified option list.
4336185db85Sdougm  */
4346185db85Sdougm static void
4356185db85Sdougm free_opt(struct options *optlist)
4366185db85Sdougm {
4376185db85Sdougm 	struct options *nextopt;
4386185db85Sdougm 	while (optlist != NULL) {
4396185db85Sdougm 		nextopt = optlist->next;
4406185db85Sdougm 		free(optlist);
4416185db85Sdougm 		optlist = nextopt;
4426185db85Sdougm 	}
4436185db85Sdougm }
4446185db85Sdougm 
4456185db85Sdougm /*
4466185db85Sdougm  * check property list for valid properties
4476185db85Sdougm  * A null value is a remove which is always valid.
4486185db85Sdougm  */
4496185db85Sdougm static int
4506185db85Sdougm valid_options(struct options *optlist, char *proto, void *object, char *sec)
4516185db85Sdougm {
4526185db85Sdougm 	int ret = SA_OK;
4536185db85Sdougm 	struct options *cur;
4546185db85Sdougm 	sa_property_t prop;
4556185db85Sdougm 	sa_optionset_t parent = NULL;
4566185db85Sdougm 
4576185db85Sdougm 	if (object != NULL) {
4586185db85Sdougm 	    if (sec == NULL)
4596185db85Sdougm 		parent = sa_get_optionset(object, proto);
4606185db85Sdougm 	    else
4616185db85Sdougm 		parent = sa_get_security(object, sec, proto);
4626185db85Sdougm 	}
4636185db85Sdougm 
4646185db85Sdougm 	for (cur = optlist; cur != NULL; cur = cur->next) {
4656185db85Sdougm 	    if (cur->optvalue != NULL) {
4666185db85Sdougm 		prop = sa_create_property(cur->optname, cur->optvalue);
4676185db85Sdougm 		if (prop == NULL)
4686185db85Sdougm 		    ret = SA_NO_MEMORY;
4696185db85Sdougm 		if (ret != SA_OK ||
4706185db85Sdougm 		    (ret = sa_valid_property(parent, proto, prop)) != SA_OK) {
4716185db85Sdougm 		    (void) printf(gettext("Could not add property %s: %s\n"),
4726185db85Sdougm 					cur->optname,
4736185db85Sdougm 					sa_errorstr(ret));
4746185db85Sdougm 		}
4756185db85Sdougm 		(void) sa_remove_property(prop);
4766185db85Sdougm 	    }
4776185db85Sdougm 	}
4786185db85Sdougm 	return (ret);
4796185db85Sdougm }
4806185db85Sdougm 
4816185db85Sdougm /*
4826185db85Sdougm  * add_optionset(group, optlist, protocol, *err)
4836185db85Sdougm  *	Add the options in optlist to an optionset and then add the optionset
4846185db85Sdougm  *	to the group.
4856185db85Sdougm  *
4866185db85Sdougm  *	The return value indicates if there was a "change" while errors are
4876185db85Sdougm  *	returned via the *err parameters.
4886185db85Sdougm  */
4896185db85Sdougm static int
4906185db85Sdougm add_optionset(sa_group_t group, struct options *optlist, char *proto, int *err)
4916185db85Sdougm {
4926185db85Sdougm 	sa_optionset_t optionset;
4936185db85Sdougm 	int ret = SA_OK;
4946185db85Sdougm 	int result = 0;
4956185db85Sdougm 
4966185db85Sdougm 	optionset = sa_get_optionset(group, proto);
4976185db85Sdougm 	if (optionset == NULL) {
4986185db85Sdougm 	    optionset = sa_create_optionset(group, proto);
4996185db85Sdougm 	    result = 1; /* adding a protocol is a change */
5006185db85Sdougm 	}
5016185db85Sdougm 	if (optionset != NULL) {
5026185db85Sdougm 	    while (optlist != NULL) {
5036185db85Sdougm 		sa_property_t prop;
5046185db85Sdougm 		prop = sa_get_property(optionset, optlist->optname);
5056185db85Sdougm 		if (prop == NULL) {
5066185db85Sdougm 			/*
5076185db85Sdougm 			 * add the property, but only if it is
5086185db85Sdougm 			 * a non-NULL or non-zero length value
5096185db85Sdougm 			 */
5106185db85Sdougm 		    if (optlist->optvalue != NULL) {
5116185db85Sdougm 			prop = sa_create_property(optlist->optname,
5126185db85Sdougm 						    optlist->optvalue);
5136185db85Sdougm 			if (prop != NULL) {
5146185db85Sdougm 			    ret = sa_valid_property(optionset, proto, prop);
5156185db85Sdougm 			    if (ret != SA_OK) {
5166185db85Sdougm 				(void) sa_remove_property(prop);
5176185db85Sdougm 				(void) printf(gettext("Could not add property "
5186185db85Sdougm 							"%s: %s\n"),
5196185db85Sdougm 						optlist->optname,
5206185db85Sdougm 						sa_errorstr(ret));
5216185db85Sdougm 			    }
5226185db85Sdougm 			}
5236185db85Sdougm 			if (ret == SA_OK) {
5246185db85Sdougm 			    ret = sa_add_property(optionset, prop);
5256185db85Sdougm 			    if (ret != SA_OK) {
5266185db85Sdougm 				(void) printf(gettext("Could not add property"
5276185db85Sdougm 							" %s: %s\n"),
5286185db85Sdougm 						optlist->optname,
5296185db85Sdougm 						sa_errorstr(ret));
5306185db85Sdougm 			    } else {
5316185db85Sdougm 				/* there was a change */
5326185db85Sdougm 				result = 1;
5336185db85Sdougm 			    }
5346185db85Sdougm 			}
5356185db85Sdougm 		    }
5366185db85Sdougm 		} else {
5376185db85Sdougm 		    ret = sa_update_property(prop, optlist->optvalue);
5386185db85Sdougm 		    /* should check to see if value changed */
5396185db85Sdougm 		    if (ret != SA_OK) {
5406185db85Sdougm 			(void) printf(gettext("Could not update "
5416185db85Sdougm 						"property %s: %s\n"),
5426185db85Sdougm 					optlist->optname,
5436185db85Sdougm 					sa_errorstr(ret));
5446185db85Sdougm 		    } else {
5456185db85Sdougm 			result = 1;
5466185db85Sdougm 		    }
5476185db85Sdougm 		}
5486185db85Sdougm 		optlist = optlist->next;
5496185db85Sdougm 	    }
5506185db85Sdougm 	    ret = sa_commit_properties(optionset, 0);
5516185db85Sdougm 	}
5526185db85Sdougm 	if (err != NULL)
5536185db85Sdougm 	    *err = ret;
5546185db85Sdougm 	return (result);
5556185db85Sdougm }
5566185db85Sdougm 
5576185db85Sdougm /*
5586185db85Sdougm  * sa_create(flags, argc, argv)
5596185db85Sdougm  *	create a new group
5606185db85Sdougm  *	this may or may not have a protocol associated with it.
5616185db85Sdougm  *	No protocol means "all" protocols in this case.
5626185db85Sdougm  */
5636185db85Sdougm static int
564549ec3ffSdougm sa_create(sa_handle_t handle, int flags, int argc, char *argv[])
5656185db85Sdougm {
5666185db85Sdougm 	char *groupname;
5676185db85Sdougm 
5686185db85Sdougm 	sa_group_t group;
5696185db85Sdougm 	int verbose = 0;
5706185db85Sdougm 	int dryrun = 0;
5716185db85Sdougm 	int c;
5726185db85Sdougm 	char *protocol = NULL;
5736185db85Sdougm 	int ret = SA_OK;
5746185db85Sdougm 	struct options *optlist = NULL;
5756185db85Sdougm 	int err = 0;
5766185db85Sdougm 	int auth;
5776185db85Sdougm 
5786185db85Sdougm 	while ((c = getopt(argc, argv, "?hvnP:p:")) != EOF) {
5796185db85Sdougm 	    switch (c) {
5806185db85Sdougm 	    case 'v':
5816185db85Sdougm 		verbose++;
5826185db85Sdougm 		break;
5836185db85Sdougm 	    case 'n':
5846185db85Sdougm 		dryrun++;
5856185db85Sdougm 		break;
5866185db85Sdougm 	    case 'P':
5876185db85Sdougm 		protocol = optarg;
5886185db85Sdougm 		if (!sa_valid_protocol(protocol)) {
5896185db85Sdougm 		    (void) printf(gettext("Invalid protocol specified: %s\n"),
5906185db85Sdougm 					protocol);
5916185db85Sdougm 		    return (SA_INVALID_PROTOCOL);
5926185db85Sdougm 		}
5936185db85Sdougm 		break;
5946185db85Sdougm 	    case 'p':
5956185db85Sdougm 		ret = add_opt(&optlist, optarg, 0);
5966185db85Sdougm 		switch (ret) {
5976185db85Sdougm 		case OPT_ADD_SYNTAX:
5986185db85Sdougm 		    (void) printf(gettext("Property syntax error for "
5996185db85Sdougm 						"property: %s\n"),
6006185db85Sdougm 				    optarg);
6016185db85Sdougm 		    return (SA_SYNTAX_ERR);
6026185db85Sdougm 		case OPT_ADD_SECURITY:
6036185db85Sdougm 		    (void) printf(gettext("Security properties need "
6046185db85Sdougm 					"to be set with set-security: %s\n"),
6056185db85Sdougm 				    optarg);
6066185db85Sdougm 		    return (SA_SYNTAX_ERR);
6076185db85Sdougm 		default:
6086185db85Sdougm 		    break;
6096185db85Sdougm 		}
6106185db85Sdougm 
6116185db85Sdougm 		break;
6126185db85Sdougm 	    default:
6136185db85Sdougm 	    case 'h':
6146185db85Sdougm 	    case '?':
6156185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
6166185db85Sdougm 				sa_get_usage(USAGE_CREATE));
6176185db85Sdougm 		return (0);
6186185db85Sdougm 	    }
6196185db85Sdougm 	}
6206185db85Sdougm 
6216185db85Sdougm 	if (optind >= argc) {
6226185db85Sdougm 	    (void) printf(gettext("usage: %s\n"), sa_get_usage(USAGE_CREATE));
6236185db85Sdougm 	    (void) printf(gettext("\tgroup must be specified.\n"));
6246185db85Sdougm 	    return (SA_BAD_PATH);
6256185db85Sdougm 	}
6266185db85Sdougm 
6276185db85Sdougm 	if ((optind + 1) < argc) {
6286185db85Sdougm 	    (void) printf(gettext("usage: %s\n"), sa_get_usage(USAGE_CREATE));
6296185db85Sdougm 	    (void) printf(gettext("\textraneous group(s) at end\n"));
6306185db85Sdougm 	    return (SA_SYNTAX_ERR);
6316185db85Sdougm 	}
6326185db85Sdougm 
6336185db85Sdougm 	if (protocol == NULL && optlist != NULL) {
6346185db85Sdougm 	    /* lookup default protocol */
6356185db85Sdougm 	    (void) printf(gettext("usage: %s\n"), sa_get_usage(USAGE_CREATE));
6366185db85Sdougm 	    (void) printf(gettext("\tprotocol must be specified "
6376185db85Sdougm 				"with properties\n"));
6386185db85Sdougm 	    return (SA_INVALID_PROTOCOL);
6396185db85Sdougm 	}
6406185db85Sdougm 
6416185db85Sdougm 	if (optlist != NULL)
6426185db85Sdougm 	    ret = chk_opt(optlist, 0, protocol);
6436185db85Sdougm 	if (ret == OPT_ADD_SECURITY) {
6446185db85Sdougm 	    (void) printf(gettext("Security properties not "
6456185db85Sdougm 				"supported with create\n"));
6466185db85Sdougm 	    return (SA_SYNTAX_ERR);
6476185db85Sdougm 	}
6486185db85Sdougm 
6496185db85Sdougm 	/*
6506185db85Sdougm 	 * if a group already exists, we can only add a new protocol
6516185db85Sdougm 	 * to it and not create a new one or add the same protocol
6526185db85Sdougm 	 * again.
6536185db85Sdougm 	 */
6546185db85Sdougm 
6556185db85Sdougm 	groupname = argv[optind];
6566185db85Sdougm 
6576185db85Sdougm 	auth = check_authorizations(groupname, flags);
6586185db85Sdougm 
659549ec3ffSdougm 	group = sa_get_group(handle, groupname);
6606185db85Sdougm 	if (group != NULL) {
6616185db85Sdougm 	    /* group exists so must be a protocol add */
6626185db85Sdougm 	    if (protocol != NULL) {
6636185db85Sdougm 		if (has_protocol(group, protocol)) {
6646185db85Sdougm 		    (void) printf(gettext("Group \"%s\" already exists"
6656185db85Sdougm 						" with protocol %s\n"),
6666185db85Sdougm 					groupname, protocol);
6676185db85Sdougm 		    ret = SA_DUPLICATE_NAME;
6686185db85Sdougm 		}
6696185db85Sdougm 	    } else {
6706185db85Sdougm 		/* must add new protocol */
6716185db85Sdougm 		(void) printf(gettext("Group already exists and no protocol"
6726185db85Sdougm 					" specified.\n"));
6736185db85Sdougm 		ret = SA_DUPLICATE_NAME;
6746185db85Sdougm 	    }
6756185db85Sdougm 	} else {
6766185db85Sdougm 		/*
6776185db85Sdougm 		 * is it a valid name? Must comply with SMF instance
6786185db85Sdougm 		 * name restrictions.
6796185db85Sdougm 		 */
6806185db85Sdougm 	    if (!sa_valid_group_name(groupname)) {
6816185db85Sdougm 		ret = SA_INVALID_NAME;
6826185db85Sdougm 		(void) printf(gettext("Invalid group name: %s\n"), groupname);
6836185db85Sdougm 	    }
6846185db85Sdougm 	}
6856185db85Sdougm 	if (ret == SA_OK) {
6866185db85Sdougm 	    /* check protocol vs optlist */
6876185db85Sdougm 	    if (optlist != NULL) {
6886185db85Sdougm 		/* check options, if any, for validity */
6896185db85Sdougm 		ret = valid_options(optlist, protocol, group, NULL);
6906185db85Sdougm 	    }
6916185db85Sdougm 	}
6926185db85Sdougm 	if (ret == SA_OK && !dryrun) {
6936185db85Sdougm 	    if (group == NULL) {
694549ec3ffSdougm 		group = sa_create_group(handle, (char *)groupname, &err);
6956185db85Sdougm 	    }
6966185db85Sdougm 	    if (group != NULL) {
6976185db85Sdougm 		sa_optionset_t optionset;
6986185db85Sdougm 		if (optlist != NULL) {
6996185db85Sdougm 		    (void) add_optionset(group, optlist, protocol, &ret);
7006185db85Sdougm 		} else if (protocol != NULL) {
7016185db85Sdougm 		    optionset = sa_create_optionset(group, protocol);
7026185db85Sdougm 		    if (optionset == NULL)
7036185db85Sdougm 			ret = SA_NO_MEMORY;
7046185db85Sdougm 		} else if (protocol == NULL) {
7056185db85Sdougm 		    char **protolist;
7066185db85Sdougm 		    int numprotos, i;
7076185db85Sdougm 		    numprotos = sa_get_protocols(&protolist);
7086185db85Sdougm 		    for (i = 0; i < numprotos; i++) {
7096185db85Sdougm 			optionset = sa_create_optionset(group, protolist[i]);
7106185db85Sdougm 		    }
7116185db85Sdougm 		    if (protolist != NULL)
7126185db85Sdougm 			free(protolist);
7136185db85Sdougm 		}
7146185db85Sdougm 		/*
7156185db85Sdougm 		 * we have a group and legal additions
7166185db85Sdougm 		 */
7176185db85Sdougm 		if (ret == SA_OK) {
7186185db85Sdougm 			/*
7196185db85Sdougm 			 * commit to configuration for protocols that
7206185db85Sdougm 			 * need to do block updates. For NFS, this
7216185db85Sdougm 			 * doesn't do anything but it will be run for
7226185db85Sdougm 			 * all protocols that implement the
7236185db85Sdougm 			 * appropriate plugin.
7246185db85Sdougm 			 */
725549ec3ffSdougm 		    ret = sa_update_config(handle);
7266185db85Sdougm 		} else {
7276185db85Sdougm 		    if (group != NULL)
7286185db85Sdougm 			(void) sa_remove_group(group);
7296185db85Sdougm 		}
7306185db85Sdougm 	    } else {
7316185db85Sdougm 		ret = err;
7326185db85Sdougm 		(void) printf(gettext("Could not create group: %s\n"),
7336185db85Sdougm 			sa_errorstr(ret));
7346185db85Sdougm 	    }
7356185db85Sdougm 	}
7366185db85Sdougm 	if (dryrun && ret == SA_OK && !auth && verbose) {
7376185db85Sdougm 	    (void) printf(gettext("Command would fail: %s\n"),
7386185db85Sdougm 			sa_errorstr(SA_NO_PERMISSION));
7396185db85Sdougm 	    ret = SA_NO_PERMISSION;
7406185db85Sdougm 	}
7416185db85Sdougm 	free_opt(optlist);
7426185db85Sdougm 	return (ret);
7436185db85Sdougm }
7446185db85Sdougm 
7456185db85Sdougm /*
7466185db85Sdougm  * group_status(group)
7476185db85Sdougm  *
7486185db85Sdougm  * return the current status (enabled/disabled) of the group.
7496185db85Sdougm  */
7506185db85Sdougm 
7516185db85Sdougm static char *
7526185db85Sdougm group_status(sa_group_t group)
7536185db85Sdougm {
7546185db85Sdougm 	char *state;
7556185db85Sdougm 	int enabled = 0;
7566185db85Sdougm 
7576185db85Sdougm 	state = sa_get_group_attr(group, "state");
7586185db85Sdougm 	if (state != NULL) {
7596185db85Sdougm 	    if (strcmp(state, "enabled") == 0) {
7606185db85Sdougm 		enabled = 1;
7616185db85Sdougm 	    }
7626185db85Sdougm 	    sa_free_attr_string(state);
7636185db85Sdougm 	}
7646185db85Sdougm 	return (enabled ? gettext("enabled") : gettext("disabled"));
7656185db85Sdougm }
7666185db85Sdougm 
7676185db85Sdougm /*
7686185db85Sdougm  * sa_delete(flags, argc, argv)
7696185db85Sdougm  *
7706185db85Sdougm  *	Delete a group.
7716185db85Sdougm  */
7726185db85Sdougm 
7736185db85Sdougm static int
774549ec3ffSdougm sa_delete(sa_handle_t handle, int flags, int argc, char *argv[])
7756185db85Sdougm {
7766185db85Sdougm 	char *groupname;
7776185db85Sdougm 	sa_group_t group;
7786185db85Sdougm 	sa_share_t share;
7796185db85Sdougm 	int verbose = 0;
7806185db85Sdougm 	int dryrun = 0;
7816185db85Sdougm 	int force = 0;
7826185db85Sdougm 	int c;
7836185db85Sdougm 	char *protocol = NULL;
7846185db85Sdougm 	char *sectype = NULL;
7856185db85Sdougm 	int ret = SA_OK;
7866185db85Sdougm 	int auth;
7876185db85Sdougm 
7886185db85Sdougm 	while ((c = getopt(argc, argv, "?hvnP:fS:")) != EOF) {
7896185db85Sdougm 	    switch (c) {
7906185db85Sdougm 	    case 'v':
7916185db85Sdougm 		verbose++;
7926185db85Sdougm 		break;
7936185db85Sdougm 	    case 'n':
7946185db85Sdougm 		dryrun++;
7956185db85Sdougm 		break;
7966185db85Sdougm 	    case 'P':
7976185db85Sdougm 		protocol = optarg;
7986185db85Sdougm 		if (!sa_valid_protocol(protocol)) {
7996185db85Sdougm 		    (void) printf(gettext("Invalid protocol specified: %s\n"),
8006185db85Sdougm 				    protocol);
8016185db85Sdougm 		    return (SA_INVALID_PROTOCOL);
8026185db85Sdougm 		}
8036185db85Sdougm 		break;
8046185db85Sdougm 	    case 'S':
8056185db85Sdougm 		sectype = optarg;
8066185db85Sdougm 		break;
8076185db85Sdougm 	    case 'f':
8086185db85Sdougm 		force++;
8096185db85Sdougm 		break;
8106185db85Sdougm 	    default:
8116185db85Sdougm 	    case 'h':
8126185db85Sdougm 	    case '?':
8136185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
8146185db85Sdougm 				sa_get_usage(USAGE_DELETE));
8156185db85Sdougm 		return (0);
8166185db85Sdougm 	    }
8176185db85Sdougm 	}
8186185db85Sdougm 
8196185db85Sdougm 	if (optind >= argc) {
8206185db85Sdougm 	    (void) printf(gettext("usage: %s\n"), sa_get_usage(USAGE_DELETE));
8216185db85Sdougm 	    (void) printf(gettext("\tgroup must be specified.\n"));
8226185db85Sdougm 	    return (SA_SYNTAX_ERR);
8236185db85Sdougm 	}
8246185db85Sdougm 
8256185db85Sdougm 	if ((optind + 1) < argc) {
8266185db85Sdougm 	    (void) printf(gettext("usage: %s\n"), sa_get_usage(USAGE_DELETE));
8276185db85Sdougm 	    (void) printf(gettext("\textraneous group(s) at end\n"));
8286185db85Sdougm 	    return (SA_SYNTAX_ERR);
8296185db85Sdougm 	}
8306185db85Sdougm 
8316185db85Sdougm 	if (sectype != NULL && protocol == NULL) {
8326185db85Sdougm 	    (void) printf(gettext("usage: %s\n"), sa_get_usage(USAGE_DELETE));
8336185db85Sdougm 	    (void) printf(gettext("\tsecurity requires protocol to be "
8346185db85Sdougm 					"specified.\n"));
8356185db85Sdougm 	    return (SA_SYNTAX_ERR);
8366185db85Sdougm 	}
8376185db85Sdougm 
8386185db85Sdougm 	/*
8396185db85Sdougm 	 * Determine if the group already exists since it must in
8406185db85Sdougm 	 * order to be removed.
8416185db85Sdougm 	 *
8426185db85Sdougm 	 * We can delete when:
8436185db85Sdougm 	 *
8446185db85Sdougm 	 *	- group is empty
8456185db85Sdougm 	 *	- force flag is set
8466185db85Sdougm 	 *	- if protocol specified, only delete the protocol
8476185db85Sdougm 	 */
8486185db85Sdougm 
8496185db85Sdougm 	groupname = argv[optind];
850549ec3ffSdougm 	group = sa_get_group(handle, groupname);
8516185db85Sdougm 	if (group == NULL) {
8526185db85Sdougm 		ret = SA_NO_SUCH_GROUP;
8536185db85Sdougm 	} else {
8546185db85Sdougm 	    auth = check_authorizations(groupname, flags);
8556185db85Sdougm 	    if (protocol == NULL) {
8566185db85Sdougm 		share = sa_get_share(group, NULL);
8576185db85Sdougm 		if (share != NULL)
8586185db85Sdougm 		    ret = SA_BUSY;
8596185db85Sdougm 		if (share == NULL || (share != NULL && force == 1)) {
8606185db85Sdougm 		    ret = SA_OK;
8616185db85Sdougm 		    if (!dryrun) {
8626185db85Sdougm 			while (share != NULL) {
8636185db85Sdougm 			    sa_share_t next_share;
8646185db85Sdougm 			    next_share = sa_get_next_share(share);
8656185db85Sdougm 				/*
8666185db85Sdougm 				 * need to do the disable of each
8676185db85Sdougm 				 * share, but don't actually do
8686185db85Sdougm 				 * anything on a dryrun.
8696185db85Sdougm 				 */
8706185db85Sdougm 			    ret = sa_disable_share(share, NULL);
8716185db85Sdougm 			    ret = sa_remove_share(share);
8726185db85Sdougm 			    share = next_share;
8736185db85Sdougm 			}
8746185db85Sdougm 			ret = sa_remove_group(group);
8756185db85Sdougm 		    }
8766185db85Sdougm 		}
8776185db85Sdougm 		/* commit to configuration if not a dryrun */
8786185db85Sdougm 		if (!dryrun && ret == SA_OK) {
879549ec3ffSdougm 		    ret = sa_update_config(handle);
8806185db85Sdougm 		}
8816185db85Sdougm 	    } else {
8826185db85Sdougm 		/* a protocol delete */
8836185db85Sdougm 		sa_optionset_t optionset;
8846185db85Sdougm 		sa_security_t security;
8856185db85Sdougm 		if (sectype != NULL) {
8866185db85Sdougm 		    /* only delete specified security */
8876185db85Sdougm 		    security = sa_get_security(group, sectype, protocol);
8886185db85Sdougm 		    if (security != NULL && !dryrun) {
8896185db85Sdougm 			ret = sa_destroy_security(security);
8906185db85Sdougm 		    } else {
8916185db85Sdougm 			ret = SA_INVALID_PROTOCOL;
8926185db85Sdougm 		    }
8936185db85Sdougm 		} else {
8946185db85Sdougm 		    optionset = sa_get_optionset(group, protocol);
8956185db85Sdougm 		    if (optionset != NULL && !dryrun) {
8966185db85Sdougm 			/* have an optionset with protocol to delete */
8976185db85Sdougm 			ret = sa_destroy_optionset(optionset);
8986185db85Sdougm 			/*
8996185db85Sdougm 			 * now find all security sets for the protocol
9006185db85Sdougm 			 * and remove them. Don't remove other
9016185db85Sdougm 			 * protocols.
9026185db85Sdougm 			 */
9036185db85Sdougm 			for (security = sa_get_security(group, NULL, NULL);
9046185db85Sdougm 			    ret == SA_OK && security != NULL;
9056185db85Sdougm 			    security = sa_get_next_security(security)) {
9066185db85Sdougm 			    char *secprot;
9076185db85Sdougm 
9086185db85Sdougm 			    secprot = sa_get_security_attr(security, "type");
9096185db85Sdougm 			    if (secprot != NULL &&
9106185db85Sdougm 				strcmp(secprot, protocol) == 0)
9116185db85Sdougm 				ret = sa_destroy_security(security);
9126185db85Sdougm 			    if (secprot != NULL)
9136185db85Sdougm 				sa_free_attr_string(secprot);
9146185db85Sdougm 			}
9156185db85Sdougm 		    } else {
9166185db85Sdougm 			if (!dryrun)
9176185db85Sdougm 			    ret = SA_INVALID_PROTOCOL;
9186185db85Sdougm 		    }
9196185db85Sdougm 		}
9206185db85Sdougm 	    }
9216185db85Sdougm 	}
9226185db85Sdougm 	if (ret != SA_OK) {
9236185db85Sdougm 	    (void) printf(gettext("Could not delete group: %s\n"),
9246185db85Sdougm 				sa_errorstr(ret));
9256185db85Sdougm 	} else if (dryrun && !auth && verbose) {
9266185db85Sdougm 	    (void) printf(gettext("Command would fail: %s\n"),
9276185db85Sdougm 			sa_errorstr(SA_NO_PERMISSION));
9286185db85Sdougm 	}
9296185db85Sdougm 	return (ret);
9306185db85Sdougm }
9316185db85Sdougm 
9326185db85Sdougm /*
9336185db85Sdougm  * strndupr(*buff, str, buffsize)
9346185db85Sdougm  *
9356185db85Sdougm  * used with small strings to duplicate and possibly increase the
9366185db85Sdougm  * buffer size of a string.
9376185db85Sdougm  */
9386185db85Sdougm static char *
9396185db85Sdougm strndupr(char *buff, char *str, int *buffsize)
9406185db85Sdougm {
9416185db85Sdougm 	int limit;
9426185db85Sdougm 	char *orig_buff = buff;
9436185db85Sdougm 
9446185db85Sdougm 	if (buff == NULL) {
9456185db85Sdougm 	    buff = (char *)malloc(64);
9466185db85Sdougm 	    if (buff == NULL)
9476185db85Sdougm 		return (NULL);
9486185db85Sdougm 	    *buffsize = 64;
9496185db85Sdougm 	    buff[0] = '\0';
9506185db85Sdougm 	}
9516185db85Sdougm 	limit = strlen(buff) + strlen(str) + 1;
9526185db85Sdougm 	if (limit > *buffsize) {
9536185db85Sdougm 	    limit = *buffsize = *buffsize + ((limit / 64) + 64);
9546185db85Sdougm 	    buff = realloc(buff, limit);
9556185db85Sdougm 	}
9566185db85Sdougm 	if (buff != NULL) {
9576185db85Sdougm 	    (void) strcat(buff, str);
9586185db85Sdougm 	} else {
9596185db85Sdougm 	    /* if it fails, fail it hard */
9606185db85Sdougm 	    if (orig_buff != NULL)
9616185db85Sdougm 		free(orig_buff);
9626185db85Sdougm 	}
9636185db85Sdougm 	return (buff);
9646185db85Sdougm }
9656185db85Sdougm 
9666185db85Sdougm /*
9676185db85Sdougm  * group_proto(group)
9686185db85Sdougm  *
9696185db85Sdougm  * return a string of all the protocols (space separated) associated
9706185db85Sdougm  * with this group.
9716185db85Sdougm  */
9726185db85Sdougm 
9736185db85Sdougm static char *
9746185db85Sdougm group_proto(sa_group_t group)
9756185db85Sdougm {
9766185db85Sdougm 	sa_optionset_t optionset;
9776185db85Sdougm 	char *proto;
9786185db85Sdougm 	char *buff = NULL;
9796185db85Sdougm 	int buffsize = 0;
9806185db85Sdougm 	int addspace = 0;
9816185db85Sdougm 	/*
9826185db85Sdougm 	 * get the protocol list by finding the optionsets on this
9836185db85Sdougm 	 * group and extracting the type value. The initial call to
9846185db85Sdougm 	 * strndupr() initailizes buff.
9856185db85Sdougm 	 */
9866185db85Sdougm 	buff = strndupr(buff, "", &buffsize);
9876185db85Sdougm 	if (buff != NULL) {
9886185db85Sdougm 	    for (optionset = sa_get_optionset(group, NULL);
9896185db85Sdougm 		optionset != NULL && buff != NULL;
9906185db85Sdougm 		optionset = sa_get_next_optionset(optionset)) {
9916185db85Sdougm 		/*
9926185db85Sdougm 		 * extract out the protocol type from this optionset
9936185db85Sdougm 		 * and append it to the buffer "buff". strndupr() will
9946185db85Sdougm 		 * reallocate space as necessay.
9956185db85Sdougm 		 */
9966185db85Sdougm 		proto = sa_get_optionset_attr(optionset, "type");
9976185db85Sdougm 		if (proto != NULL) {
9986185db85Sdougm 		    if (addspace++)
9996185db85Sdougm 			buff = strndupr(buff, " ", &buffsize);
10006185db85Sdougm 		    buff = strndupr(buff, proto, &buffsize);
10016185db85Sdougm 		    sa_free_attr_string(proto);
10026185db85Sdougm 		}
10036185db85Sdougm 	    }
10046185db85Sdougm 	}
10056185db85Sdougm 	return (buff);
10066185db85Sdougm }
10076185db85Sdougm 
10086185db85Sdougm /*
10096185db85Sdougm  * sa_list(flags, argc, argv)
10106185db85Sdougm  *
10116185db85Sdougm  * implements the "list" subcommand to list groups and optionally
10126185db85Sdougm  * their state and protocols.
10136185db85Sdougm  */
10146185db85Sdougm 
10156185db85Sdougm static int
1016549ec3ffSdougm sa_list(sa_handle_t handle, int flags, int argc, char *argv[])
10176185db85Sdougm {
10186185db85Sdougm 	sa_group_t group;
10196185db85Sdougm 	int verbose = 0;
10206185db85Sdougm 	int c;
10216185db85Sdougm 	char *protocol = NULL;
10226185db85Sdougm #ifdef lint
10236185db85Sdougm 	flags = flags;
10246185db85Sdougm #endif
10256185db85Sdougm 
10266185db85Sdougm 	while ((c = getopt(argc, argv, "?hvP:")) != EOF) {
10276185db85Sdougm 	    switch (c) {
10286185db85Sdougm 	    case 'v':
10296185db85Sdougm 		verbose++;
10306185db85Sdougm 		break;
10316185db85Sdougm 	    case 'P':
10326185db85Sdougm 		protocol = optarg;
10336185db85Sdougm 		if (!sa_valid_protocol(protocol)) {
10346185db85Sdougm 		    (void) printf(gettext("Invalid protocol specified:"
10356185db85Sdougm 					    "%s\n"),
10366185db85Sdougm 					protocol);
10376185db85Sdougm 		    return (SA_INVALID_PROTOCOL);
10386185db85Sdougm 		}
10396185db85Sdougm 		break;
10406185db85Sdougm 	    default:
10416185db85Sdougm 	    case 'h':
10426185db85Sdougm 	    case '?':
10436185db85Sdougm 		(void) printf(gettext("usage: %s\n"), sa_get_usage(USAGE_LIST));
10446185db85Sdougm 		return (0);
10456185db85Sdougm 	    }
10466185db85Sdougm 	}
10476185db85Sdougm 
1048549ec3ffSdougm 	for (group = sa_get_group(handle, NULL); group != NULL;
10496185db85Sdougm 	    group = sa_get_next_group(group)) {
10506185db85Sdougm 	    char *name;
10516185db85Sdougm 	    char *proto;
10526185db85Sdougm 	    if (protocol == NULL || has_protocol(group, protocol)) {
10536185db85Sdougm 		name = sa_get_group_attr(group, "name");
10546185db85Sdougm 		if (name != NULL && (verbose > 1 || name[0] != '#')) {
10556185db85Sdougm 		    (void) printf("%s", (char *)name);
10566185db85Sdougm 		    if (verbose) {
10576185db85Sdougm 			/*
10586185db85Sdougm 			 * need the list of protocols
10596185db85Sdougm 			 * and current status once
10606185db85Sdougm 			 * available.
10616185db85Sdougm 			 */
10626185db85Sdougm 			(void) printf("\t%s", group_status(group));
10636185db85Sdougm 			proto = group_proto(group);
10646185db85Sdougm 			if (proto != NULL) {
10656185db85Sdougm 			    (void) printf("\t%s", (char *)proto);
10666185db85Sdougm 			    free(proto);
10676185db85Sdougm 			}
10686185db85Sdougm 		    }
10696185db85Sdougm 		    (void) printf("\n");
10706185db85Sdougm 		}
10716185db85Sdougm 		if (name != NULL)
10726185db85Sdougm 		    sa_free_attr_string(name);
10736185db85Sdougm 	    }
10746185db85Sdougm 	}
10756185db85Sdougm 	return (0);
10766185db85Sdougm }
10776185db85Sdougm 
10786185db85Sdougm /*
10796185db85Sdougm  * out_properties(optionset, proto, sec)
10806185db85Sdougm  *
10816185db85Sdougm  * Format the properties and encode the protocol and optional named
10826185db85Sdougm  * optionset into the string.
10836185db85Sdougm  *
10846185db85Sdougm  * format is protocol[:name]=(property-list)
10856185db85Sdougm  */
10866185db85Sdougm 
10876185db85Sdougm static void
10886185db85Sdougm out_properties(sa_optionset_t optionset, char *proto, char *sec)
10896185db85Sdougm {
10906185db85Sdougm 	char *type;
10916185db85Sdougm 	char *value;
10926185db85Sdougm 	int spacer;
10936185db85Sdougm 	sa_property_t prop;
10946185db85Sdougm 
10956185db85Sdougm 	if (sec == NULL) {
10966185db85Sdougm 	    (void) printf(" %s=(", proto ? proto : gettext("all"));
10976185db85Sdougm 	} else {
10986185db85Sdougm 	    (void) printf(" %s:%s=(", proto ? proto : gettext("all"), sec);
10996185db85Sdougm 	}
11006185db85Sdougm 
11016185db85Sdougm 	for (spacer = 0, prop = sa_get_property(optionset, NULL);
11026185db85Sdougm 	    prop != NULL; prop = sa_get_next_property(prop)) {
11036185db85Sdougm 
11046185db85Sdougm 		/*
11056185db85Sdougm 		 * extract the property name/value and output with
11066185db85Sdougm 		 * appropriate spacing. I.e. no prefixed space the
11076185db85Sdougm 		 * first time through but a space on subsequent
11086185db85Sdougm 		 * properties.
11096185db85Sdougm 		 */
11106185db85Sdougm 	    type = sa_get_property_attr(prop, "type");
11116185db85Sdougm 	    value = sa_get_property_attr(prop, "value");
11126185db85Sdougm 	    if (type != NULL) {
11136185db85Sdougm 		(void) printf("%s%s=", spacer ? " " : "",	type);
11146185db85Sdougm 		spacer = 1;
11156185db85Sdougm 		if (value != NULL)
11166185db85Sdougm 		    (void) printf("\"%s\"", value);
11176185db85Sdougm 		else
11186185db85Sdougm 		    (void) printf("\"\"");
11196185db85Sdougm 	    }
11206185db85Sdougm 	    if (type != NULL)
11216185db85Sdougm 		sa_free_attr_string(type);
11226185db85Sdougm 	    if (value != NULL)
11236185db85Sdougm 		sa_free_attr_string(value);
11246185db85Sdougm 	}
11256185db85Sdougm 	(void) printf(")");
11266185db85Sdougm }
11276185db85Sdougm 
11286185db85Sdougm /*
11296185db85Sdougm  * show_properties(group, protocol, prefix)
11306185db85Sdougm  *
11316185db85Sdougm  * print the properties for a group. If protocol is NULL, do all
11326185db85Sdougm  * protocols otherwise only the specified protocol. All security
11336185db85Sdougm  * (named groups specific to the protocol) are included.
11346185db85Sdougm  *
11356185db85Sdougm  * The "prefix" is always applied. The caller knows whether it wants
11366185db85Sdougm  * some type of prefix string (white space) or not.  Once the prefix
11376185db85Sdougm  * has been output, it is reduced to the zero length string for the
11386185db85Sdougm  * remainder of the property output.
11396185db85Sdougm  */
11406185db85Sdougm 
11416185db85Sdougm static void
11426185db85Sdougm show_properties(sa_group_t group, char *protocol, char *prefix)
11436185db85Sdougm {
11446185db85Sdougm 	sa_optionset_t optionset;
11456185db85Sdougm 	sa_security_t security;
11466185db85Sdougm 	char *value;
11476185db85Sdougm 	char *secvalue;
11486185db85Sdougm 
11496185db85Sdougm 	if (protocol != NULL) {
11506185db85Sdougm 	    optionset = sa_get_optionset(group, protocol);
11516185db85Sdougm 	    if (optionset != NULL) {
11526185db85Sdougm 		(void) printf("%s", prefix);
11536185db85Sdougm 		prefix = "";
11546185db85Sdougm 		out_properties(optionset, protocol, NULL);
11556185db85Sdougm 	    }
11566185db85Sdougm 	    security = sa_get_security(group, protocol, NULL);
11576185db85Sdougm 	    if (security != NULL) {
11586185db85Sdougm 		(void) printf("%s", prefix);
11596185db85Sdougm 		prefix = "";
11606185db85Sdougm 		out_properties(security, protocol, NULL);
11616185db85Sdougm 	    }
11626185db85Sdougm 	} else {
11636185db85Sdougm 	    for (optionset = sa_get_optionset(group, protocol);
11646185db85Sdougm 		optionset != NULL;
11656185db85Sdougm 		optionset = sa_get_next_optionset(optionset)) {
11666185db85Sdougm 
11676185db85Sdougm 		value = sa_get_optionset_attr(optionset, "type");
11686185db85Sdougm 		(void) printf("%s", prefix);
11696185db85Sdougm 		prefix = "";
11706185db85Sdougm 		out_properties(optionset, value, 0);
11716185db85Sdougm 		if (value != NULL)
11726185db85Sdougm 		    sa_free_attr_string(value);
11736185db85Sdougm 	    }
11746185db85Sdougm 	    for (security = sa_get_security(group, NULL, protocol);
11756185db85Sdougm 		security != NULL;
11766185db85Sdougm 		security = sa_get_next_security(security)) {
11776185db85Sdougm 
11786185db85Sdougm 		value = sa_get_security_attr(security, "type");
11796185db85Sdougm 		secvalue = sa_get_security_attr(security, "sectype");
11806185db85Sdougm 		(void) printf("%s", prefix);
11816185db85Sdougm 		prefix = "";
11826185db85Sdougm 		out_properties(security, value, secvalue);
11836185db85Sdougm 		if (value != NULL)
11846185db85Sdougm 		    sa_free_attr_string(value);
11856185db85Sdougm 		if (secvalue != NULL)
11866185db85Sdougm 		    sa_free_attr_string(secvalue);
11876185db85Sdougm 	    }
11886185db85Sdougm 	}
11896185db85Sdougm }
11906185db85Sdougm 
11916185db85Sdougm /*
11926185db85Sdougm  * show_group(group, verbose, properties, proto, subgroup)
11936185db85Sdougm  *
11946185db85Sdougm  * helper function to show the contents of a group.
11956185db85Sdougm  */
11966185db85Sdougm 
11976185db85Sdougm static void
11986185db85Sdougm show_group(sa_group_t group, int verbose, int properties, char *proto,
11996185db85Sdougm 		char *subgroup)
12006185db85Sdougm {
12016185db85Sdougm 	sa_share_t share;
12026185db85Sdougm 	char *groupname;
12036185db85Sdougm 	char *sharepath;
12046185db85Sdougm 	char *resource;
12056185db85Sdougm 	char *description;
12066185db85Sdougm 	char *type;
12076185db85Sdougm 	char *zfs = NULL;
12086185db85Sdougm 	int iszfs = 0;
12096185db85Sdougm 
12106185db85Sdougm 	groupname = sa_get_group_attr(group, "name");
12116185db85Sdougm 	if (groupname != NULL) {
12126185db85Sdougm 	    if (proto != NULL && !has_protocol(group, proto)) {
12136185db85Sdougm 		sa_free_attr_string(groupname);
12146185db85Sdougm 		return;
12156185db85Sdougm 	    }
12166185db85Sdougm 		/*
12176185db85Sdougm 		 * check to see if the group is managed by ZFS. If
12186185db85Sdougm 		 * there is an attribute, then it is. A non-NULL zfs
12196185db85Sdougm 		 * variable will trigger the different way to display
12206185db85Sdougm 		 * and will remove the transient property indicator
12216185db85Sdougm 		 * from the output.
12226185db85Sdougm 		 */
12236185db85Sdougm 	    zfs = sa_get_group_attr(group, "zfs");
12246185db85Sdougm 	    if (zfs != NULL) {
12256185db85Sdougm 		iszfs = 1;
12266185db85Sdougm 		sa_free_attr_string(zfs);
12276185db85Sdougm 	    }
12286185db85Sdougm 	    share = sa_get_share(group, NULL);
12296185db85Sdougm 	    if (subgroup == NULL)
12306185db85Sdougm 		(void) printf("%s", groupname);
12316185db85Sdougm 	    else
12326185db85Sdougm 		(void) printf("    %s/%s", subgroup, groupname);
12336185db85Sdougm 	    if (properties) {
12346185db85Sdougm 		show_properties(group, proto, "");
12356185db85Sdougm 	    }
12366185db85Sdougm 	    (void) printf("\n");
12376185db85Sdougm 	    if (strcmp(groupname, "zfs") == 0) {
12386185db85Sdougm 		sa_group_t zgroup;
12396185db85Sdougm 
12406185db85Sdougm 		for (zgroup = sa_get_sub_group(group); zgroup != NULL;
12416185db85Sdougm 		    zgroup = sa_get_next_group(zgroup)) {
12426185db85Sdougm 		    show_group(zgroup, verbose, properties, proto, "zfs");
12436185db85Sdougm 		}
12446185db85Sdougm 		sa_free_attr_string(groupname);
12456185db85Sdougm 		return;
12466185db85Sdougm 	    }
12476185db85Sdougm 		/*
12486185db85Sdougm 		 * have a group, so list the contents. Resource and
12496185db85Sdougm 		 * description are only listed if verbose is set.
12506185db85Sdougm 		 */
12516185db85Sdougm 	    for (share = sa_get_share(group, NULL); share != NULL;
12526185db85Sdougm 		share = sa_get_next_share(share)) {
12536185db85Sdougm 		sharepath = sa_get_share_attr(share, "path");
12546185db85Sdougm 		if (sharepath != NULL) {
12556185db85Sdougm 		    if (verbose) {
12566185db85Sdougm 			resource = sa_get_share_attr(share, "resource");
12576185db85Sdougm 			description = sa_get_share_description(share);
12586185db85Sdougm 			type = sa_get_share_attr(share, "type");
12596185db85Sdougm 			if (type != NULL && !iszfs &&
12606185db85Sdougm 				strcmp(type, "transient") == 0)
12616185db85Sdougm 			    (void) printf("\t* ");
12626185db85Sdougm 			else
12636185db85Sdougm 			    (void) printf("\t  ");
12646185db85Sdougm 			if (resource != NULL && strlen(resource) > 0) {
12656185db85Sdougm 			    (void) printf("%s=%s", resource, sharepath);
12666185db85Sdougm 			} else {
12676185db85Sdougm 			    (void) printf("%s", sharepath);
12686185db85Sdougm 			}
12696185db85Sdougm 			if (resource != NULL)
12706185db85Sdougm 			    sa_free_attr_string(resource);
12716185db85Sdougm 			if (properties)
12726185db85Sdougm 			    show_properties(share, NULL, "\t");
12736185db85Sdougm 			if (description != NULL) {
12746185db85Sdougm 			    if (strlen(description) > 0) {
12756185db85Sdougm 				(void) printf("\t\"%s\"", description);
12766185db85Sdougm 			    }
12776185db85Sdougm 			    sa_free_share_description(description);
12786185db85Sdougm 			}
12796185db85Sdougm 			if (type != NULL)
12806185db85Sdougm 			    sa_free_attr_string(type);
12816185db85Sdougm 		    } else {
12826185db85Sdougm 			(void) printf("\t%s", sharepath);
12836185db85Sdougm 			if (properties)
12846185db85Sdougm 			    show_properties(share, NULL, "\t");
12856185db85Sdougm 		    }
12866185db85Sdougm 		    (void) printf("\n");
12876185db85Sdougm 		    sa_free_attr_string(sharepath);
12886185db85Sdougm 		}
12896185db85Sdougm 	    }
12906185db85Sdougm 	}
12916185db85Sdougm 	if (groupname != NULL) {
12926185db85Sdougm 		sa_free_attr_string(groupname);
12936185db85Sdougm 	}
12946185db85Sdougm }
12956185db85Sdougm 
12966185db85Sdougm /*
12976185db85Sdougm  * show_group_xml_init()
12986185db85Sdougm  *
12996185db85Sdougm  * Create an XML document that will be used to display config info via
13006185db85Sdougm  * XML format.
13016185db85Sdougm  */
13026185db85Sdougm 
13036185db85Sdougm xmlDocPtr
13046185db85Sdougm show_group_xml_init()
13056185db85Sdougm {
13066185db85Sdougm 	xmlDocPtr doc;
13076185db85Sdougm 	xmlNodePtr root;
13086185db85Sdougm 
13096185db85Sdougm 	doc = xmlNewDoc((xmlChar *)"1.0");
13106185db85Sdougm 	if (doc != NULL) {
13116185db85Sdougm 	    root = xmlNewNode(NULL, (xmlChar *)"sharecfg");
13126185db85Sdougm 	    if (root != NULL)
13136185db85Sdougm 		xmlDocSetRootElement(doc, root);
13146185db85Sdougm 	}
13156185db85Sdougm 	return (doc);
13166185db85Sdougm }
13176185db85Sdougm 
13186185db85Sdougm /*
13196185db85Sdougm  * show_group_xml(doc, group)
13206185db85Sdougm  *
13216185db85Sdougm  * Copy the group info into the XML doc.
13226185db85Sdougm  */
13236185db85Sdougm 
13246185db85Sdougm static void
13256185db85Sdougm show_group_xml(xmlDocPtr doc, sa_group_t group)
13266185db85Sdougm {
13276185db85Sdougm 	xmlNodePtr node;
13286185db85Sdougm 	xmlNodePtr root;
13296185db85Sdougm 
13306185db85Sdougm 	root = xmlDocGetRootElement(doc);
13316185db85Sdougm 	node = xmlCopyNode((xmlNodePtr)group, 1);
13326185db85Sdougm 	if (node != NULL && root != NULL) {
13336185db85Sdougm 	    xmlAddChild(root, node);
13346185db85Sdougm 		/*
13356185db85Sdougm 		 * In the future, we may have interally used tags that
13366185db85Sdougm 		 * should not appear in the XML output. Remove
13376185db85Sdougm 		 * anything we don't want to show here.
13386185db85Sdougm 		 */
13396185db85Sdougm 	}
13406185db85Sdougm }
13416185db85Sdougm 
13426185db85Sdougm /*
13436185db85Sdougm  * sa_show(flags, argc, argv)
13446185db85Sdougm  *
13456185db85Sdougm  * Implements the show subcommand.
13466185db85Sdougm  */
13476185db85Sdougm 
13486185db85Sdougm int
1349549ec3ffSdougm sa_show(sa_handle_t handle, int flags, int argc, char *argv[])
13506185db85Sdougm {
13516185db85Sdougm 	sa_group_t group;
13526185db85Sdougm 	int verbose = 0;
13536185db85Sdougm 	int properties = 0;
13546185db85Sdougm 	int c;
13556185db85Sdougm 	int ret = SA_OK;
13566185db85Sdougm 	char *protocol = NULL;
13576185db85Sdougm 	int xml = 0;
13586185db85Sdougm 	xmlDocPtr doc;
13596185db85Sdougm #ifdef lint
13606185db85Sdougm 	flags = flags;
13616185db85Sdougm #endif
13626185db85Sdougm 
13636185db85Sdougm 	while ((c = getopt(argc, argv, "?hvP:px")) !=	EOF) {
13646185db85Sdougm 	    switch (c) {
13656185db85Sdougm 	    case 'v':
13666185db85Sdougm 		verbose++;
13676185db85Sdougm 		break;
13686185db85Sdougm 	    case 'p':
13696185db85Sdougm 		properties++;
13706185db85Sdougm 		break;
13716185db85Sdougm 	    case 'P':
13726185db85Sdougm 		protocol = optarg;
13736185db85Sdougm 		if (!sa_valid_protocol(protocol)) {
13746185db85Sdougm 		    (void) printf(gettext("Invalid protocol specified: %s\n"),
13756185db85Sdougm 					protocol);
13766185db85Sdougm 		    return (SA_INVALID_PROTOCOL);
13776185db85Sdougm 		}
13786185db85Sdougm 		break;
13796185db85Sdougm 	    case 'x':
13806185db85Sdougm 		xml++;
13816185db85Sdougm 		break;
13826185db85Sdougm 	    default:
13836185db85Sdougm 	    case 'h':
13846185db85Sdougm 	    case '?':
13856185db85Sdougm 		(void) printf(gettext("usage: %s\n"), sa_get_usage(USAGE_SHOW));
13866185db85Sdougm 		return (0);
13876185db85Sdougm 	    }
13886185db85Sdougm 	}
13896185db85Sdougm 
13906185db85Sdougm 	if (xml) {
13916185db85Sdougm 	    doc = show_group_xml_init();
13926185db85Sdougm 	    if (doc == NULL)
13936185db85Sdougm 		ret = SA_NO_MEMORY;
13946185db85Sdougm 	}
13956185db85Sdougm 
13966185db85Sdougm 	if (optind == argc) {
13976185db85Sdougm 	    /* no group specified so go through them all */
1398549ec3ffSdougm 	    for (group = sa_get_group(handle, NULL); group != NULL;
13996185db85Sdougm 		group = sa_get_next_group(group)) {
14006185db85Sdougm 		/*
14016185db85Sdougm 		 * have a group so check if one we want and then list
14026185db85Sdougm 		 * contents with appropriate options.
14036185db85Sdougm 		 */
14046185db85Sdougm 		if (xml)
14056185db85Sdougm 		    show_group_xml(doc, group);
14066185db85Sdougm 		else
14076185db85Sdougm 		    show_group(group, verbose, properties, protocol, NULL);
14086185db85Sdougm 	    }
14096185db85Sdougm 	} else {
14106185db85Sdougm 	    /* have a specified list of groups */
14116185db85Sdougm 	    for (; optind < argc; optind++) {
1412549ec3ffSdougm 		group = sa_get_group(handle, argv[optind]);
14136185db85Sdougm 		if (group != NULL) {
14146185db85Sdougm 		    if (xml)
14156185db85Sdougm 			show_group_xml(doc, group);
14166185db85Sdougm 		    else
14176185db85Sdougm 			show_group(group, verbose, properties, protocol, NULL);
14186185db85Sdougm 		} else {
14196185db85Sdougm 		    (void) printf(gettext("%s: not found\n"), argv[optind]);
14206185db85Sdougm 		    ret = SA_NO_SUCH_GROUP;
14216185db85Sdougm 		}
14226185db85Sdougm 	    }
14236185db85Sdougm 	}
14246185db85Sdougm 	if (xml && ret == SA_OK) {
14256185db85Sdougm 	    xmlDocFormatDump(stdout, doc, 1);
14266185db85Sdougm 	    xmlFreeDoc(doc);
14276185db85Sdougm 	}
14286185db85Sdougm 	return (ret);
14296185db85Sdougm 
14306185db85Sdougm }
14316185db85Sdougm 
14326185db85Sdougm /*
14336185db85Sdougm  * enable_share(group, share, update_legacy)
14346185db85Sdougm  *
14356185db85Sdougm  * helper function to enable a share if the group is enabled.
14366185db85Sdougm  */
14376185db85Sdougm 
14386185db85Sdougm static int
1439549ec3ffSdougm enable_share(sa_handle_t handle, sa_group_t group, sa_share_t share,
1440549ec3ffSdougm 		int update_legacy)
14416185db85Sdougm {
14426185db85Sdougm 	char *value;
14436185db85Sdougm 	int enabled;
14446185db85Sdougm 	sa_optionset_t optionset;
14456185db85Sdougm 	int ret = SA_OK;
14466185db85Sdougm 	char *zfs = NULL;
14476185db85Sdougm 	int iszfs = 0;
14486185db85Sdougm 
14496185db85Sdougm 	/*
14506185db85Sdougm 	 * need to enable this share if the group is enabled but not
14516185db85Sdougm 	 * otherwise. The enable is also done on each protocol
14526185db85Sdougm 	 * represented in the group.
14536185db85Sdougm 	 */
14546185db85Sdougm 	value = sa_get_group_attr(group, "state");
14556185db85Sdougm 	enabled = value != NULL && strcmp(value, "enabled") == 0;
14566185db85Sdougm 	if (value != NULL)
14576185db85Sdougm 	    sa_free_attr_string(value);
14586185db85Sdougm 	/* remove legacy config if necessary */
14596185db85Sdougm 	if (update_legacy)
14606185db85Sdougm 	    ret = sa_delete_legacy(share);
14616185db85Sdougm 	zfs = sa_get_group_attr(group, "zfs");
14626185db85Sdougm 	if (zfs != NULL) {
14636185db85Sdougm 	    iszfs++;
14646185db85Sdougm 	    sa_free_attr_string(zfs);
14656185db85Sdougm 	}
14666185db85Sdougm 
14676185db85Sdougm 	/*
14686185db85Sdougm 	 * Step through each optionset at the group level and
14696185db85Sdougm 	 * enable the share based on the protocol type. This
14706185db85Sdougm 	 * works because protocols must be set on the group
14716185db85Sdougm 	 * for the protocol to be enabled.
14726185db85Sdougm 	 */
14736185db85Sdougm 	for (optionset = sa_get_optionset(group, NULL);
14746185db85Sdougm 	    optionset != NULL && ret == SA_OK;
14756185db85Sdougm 	    optionset = sa_get_next_optionset(optionset)) {
14766185db85Sdougm 	    value = sa_get_optionset_attr(optionset, "type");
14776185db85Sdougm 	    if (value != NULL) {
14786185db85Sdougm 		if (enabled)
14796185db85Sdougm 		    ret = sa_enable_share(share, value);
14806185db85Sdougm 		if (update_legacy && !iszfs)
14816185db85Sdougm 		    (void) sa_update_legacy(share, value);
14826185db85Sdougm 		sa_free_attr_string(value);
14836185db85Sdougm 	    }
14846185db85Sdougm 	}
14856185db85Sdougm 	if (ret == SA_OK)
1486549ec3ffSdougm 	    (void) sa_update_config(handle);
14876185db85Sdougm 	return (ret);
14886185db85Sdougm }
14896185db85Sdougm 
14906185db85Sdougm /*
14916185db85Sdougm  * sa_addshare(flags, argc, argv)
14926185db85Sdougm  *
14936185db85Sdougm  * implements add-share subcommand.
14946185db85Sdougm  */
14956185db85Sdougm 
14966185db85Sdougm int
1497549ec3ffSdougm sa_addshare(sa_handle_t handle, int flags, int argc, char *argv[])
14986185db85Sdougm {
14996185db85Sdougm 	int verbose = 0;
15006185db85Sdougm 	int dryrun = 0;
15016185db85Sdougm 	int c;
15026185db85Sdougm 	int ret = SA_OK;
15036185db85Sdougm 	sa_group_t group;
15046185db85Sdougm 	sa_share_t share;
15056185db85Sdougm 	char *sharepath = NULL;
15066185db85Sdougm 	char *description = NULL;
15076185db85Sdougm 	char *resource = NULL;
15086185db85Sdougm 	int persist = SA_SHARE_PERMANENT; /* default to persist */
15096185db85Sdougm 	int auth;
15106185db85Sdougm 	char dir[MAXPATHLEN];
15116185db85Sdougm 
15126185db85Sdougm 	while ((c = getopt(argc, argv, "?hvns:d:r:t")) != EOF) {
15136185db85Sdougm 	    switch (c) {
15146185db85Sdougm 	    case 'n':
15156185db85Sdougm 		dryrun++;
15166185db85Sdougm 		break;
15176185db85Sdougm 	    case 'v':
15186185db85Sdougm 		verbose++;
15196185db85Sdougm 		break;
15206185db85Sdougm 	    case 'd':
15216185db85Sdougm 		description = optarg;
15226185db85Sdougm 		break;
15236185db85Sdougm 	    case 'r':
15246185db85Sdougm 		resource = optarg;
15256185db85Sdougm 		break;
15266185db85Sdougm 	    case 's':
15276185db85Sdougm 		/*
15286185db85Sdougm 		 * save share path into group. Currently limit
15296185db85Sdougm 		 * to one share per command.
15306185db85Sdougm 		 */
15316185db85Sdougm 		if (sharepath != NULL) {
15326185db85Sdougm 		    (void) printf(gettext("Adding multiple shares not"
15336185db85Sdougm 				    "supported\n"));
15346185db85Sdougm 		    return (1);
15356185db85Sdougm 		}
15366185db85Sdougm 		sharepath = optarg;
15376185db85Sdougm 		break;
15386185db85Sdougm 	    case 't':
15396185db85Sdougm 		persist = SA_SHARE_TRANSIENT;
15406185db85Sdougm 		break;
15416185db85Sdougm 	    default:
15426185db85Sdougm 	    case 'h':
15436185db85Sdougm 	    case '?':
15446185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
15456185db85Sdougm 				sa_get_usage(USAGE_ADD_SHARE));
15466185db85Sdougm 		return (0);
15476185db85Sdougm 	    }
15486185db85Sdougm 	}
15496185db85Sdougm 
15506185db85Sdougm 	if (optind >= argc) {
15516185db85Sdougm 	    (void) printf(gettext("usage: %s\n"),
15526185db85Sdougm 				sa_get_usage(USAGE_ADD_SHARE));
15536185db85Sdougm 	    if (dryrun || sharepath != NULL || description != NULL ||
15546185db85Sdougm 		resource != NULL || verbose || persist) {
15556185db85Sdougm 		(void) printf(gettext("\tgroup must be specified\n"));
15566185db85Sdougm 		ret = SA_NO_SUCH_GROUP;
15576185db85Sdougm 	    } else {
15586185db85Sdougm 		ret = SA_OK;
15596185db85Sdougm 	    }
15606185db85Sdougm 	} else {
15616185db85Sdougm 	    if (sharepath == NULL) {
15626185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
15636185db85Sdougm 				sa_get_usage(USAGE_ADD_SHARE));
15646185db85Sdougm 		(void) printf(gettext("\t-s sharepath must be specified\n"));
15656185db85Sdougm 		ret = SA_BAD_PATH;
15666185db85Sdougm 	    }
15676185db85Sdougm 	    if (ret == SA_OK) {
15686185db85Sdougm 		if (realpath(sharepath, dir) == NULL) {
15696185db85Sdougm 		    ret = SA_BAD_PATH;
15706185db85Sdougm 		    (void) printf(gettext("Path is not valid: %s\n"),
15716185db85Sdougm 					sharepath);
15726185db85Sdougm 		} else {
15736185db85Sdougm 		    sharepath = dir;
15746185db85Sdougm 		}
15756185db85Sdougm 	    }
15766185db85Sdougm 	    if (ret == SA_OK && resource != NULL) {
15776185db85Sdougm 		/* check for valid syntax */
15786185db85Sdougm 		if (strpbrk(resource, " \t/") != NULL) {
15796185db85Sdougm 		    (void) printf(gettext("usage: %s\n"),
15806185db85Sdougm 				sa_get_usage(USAGE_ADD_SHARE));
15816185db85Sdougm 		    (void) printf(gettext("\tresource must not contain white"
15826185db85Sdougm 				    "space or '/' characters\n"));
15836185db85Sdougm 		    ret = SA_BAD_PATH;
15846185db85Sdougm 		}
15856185db85Sdougm 	    }
15866185db85Sdougm 	    if (ret == SA_OK) {
1587549ec3ffSdougm 		group = sa_get_group(handle, argv[optind]);
15886185db85Sdougm 		if (group != NULL) {
15896185db85Sdougm 		    auth = check_authorizations(argv[optind], flags);
1590549ec3ffSdougm 		    share = sa_find_share(handle, sharepath);
15916185db85Sdougm 		    if (share != NULL) {
15926185db85Sdougm 			group = sa_get_parent_group(share);
15936185db85Sdougm 			if (group != NULL) {
15946185db85Sdougm 			    char *groupname;
15956185db85Sdougm 			    groupname = sa_get_group_attr(group, "name");
15966185db85Sdougm 			    if (groupname != NULL) {
15976185db85Sdougm 				(void) printf(gettext("Share path already "
15986185db85Sdougm 							"shared in group "
15996185db85Sdougm 							"\"%s\": %s\n"),
16006185db85Sdougm 						groupname, sharepath);
16016185db85Sdougm 				sa_free_attr_string(groupname);
16026185db85Sdougm 			    } else {
16036185db85Sdougm 				(void) printf(gettext("Share path already"
16046185db85Sdougm 							"shared: %s\n"),
16056185db85Sdougm 						groupname, sharepath);
16066185db85Sdougm 			    }
16076185db85Sdougm 			} else {
16086185db85Sdougm 			    (void) printf(gettext("Share path %s already "
16096185db85Sdougm 							"shared\n"),
16106185db85Sdougm 				    sharepath);
16116185db85Sdougm 			}
16126185db85Sdougm 			ret = SA_DUPLICATE_NAME;
16136185db85Sdougm 		    } else {
16146185db85Sdougm 			/*
16156185db85Sdougm 			 * need to check that resource name is unique
1616f345c0beSdougm 			 * at some point. Path checking should use the
1617f345c0beSdougm 			 * "normal" rules which don't check the repository.
16186185db85Sdougm 			 */
16196185db85Sdougm 			if (dryrun)
1620f345c0beSdougm 			    ret = sa_check_path(group, sharepath,
1621f345c0beSdougm 						SA_CHECK_NORMAL);
16226185db85Sdougm 			else
16236185db85Sdougm 			    share = sa_add_share(group, sharepath,
16246185db85Sdougm 							persist, &ret);
16256185db85Sdougm 			if (!dryrun && share == NULL) {
16266185db85Sdougm 				(void) printf(gettext("Could not add share: "
16276185db85Sdougm 							"%s\n"),
16286185db85Sdougm 					sa_errorstr(ret));
16296185db85Sdougm 			} else {
16306185db85Sdougm 			    if (!dryrun && ret == SA_OK) {
16316185db85Sdougm 				if (resource != NULL) {
16326185db85Sdougm 				    if (strpbrk(resource, " \t/") == NULL) {
16336185db85Sdougm 					ret = sa_set_share_attr(share,
16346185db85Sdougm 								"resource",
16356185db85Sdougm 								resource);
16366185db85Sdougm 				    }
16376185db85Sdougm 				}
16386185db85Sdougm 				if (ret == SA_OK && description != NULL) {
16396185db85Sdougm 				    ret = sa_set_share_description(share,
16406185db85Sdougm 							    description);
16416185db85Sdougm 				}
16426185db85Sdougm 				if (ret == SA_OK) {
16436185db85Sdougm 				    /* now enable the share(s) */
1644549ec3ffSdougm 				    ret = enable_share(handle, group, share, 1);
1645549ec3ffSdougm 				    ret = sa_update_config(handle);
16466185db85Sdougm 				}
16476185db85Sdougm 				switch (ret) {
16486185db85Sdougm 				case SA_DUPLICATE_NAME:
16496185db85Sdougm 				    (void) printf(gettext("Resource name in"
16506185db85Sdougm 						    "use: %s\n"),
16516185db85Sdougm 					    resource);
16526185db85Sdougm 				    break;
16536185db85Sdougm 				default:
16546185db85Sdougm 				    (void) printf(gettext("Could not set "
16556185db85Sdougm 						    "attribute: %s\n"),
16566185db85Sdougm 					    sa_errorstr(ret));
16576185db85Sdougm 				    break;
16586185db85Sdougm 				case SA_OK:
16596185db85Sdougm 				    break;
16606185db85Sdougm 				}
16616185db85Sdougm 			    } else if (dryrun && ret == SA_OK &&
16626185db85Sdougm 					!auth && verbose) {
16636185db85Sdougm 				(void) printf(gettext("Command would fail: "
16646185db85Sdougm 							"%s\n"),
16656185db85Sdougm 					sa_errorstr(SA_NO_PERMISSION));
16666185db85Sdougm 				ret = SA_NO_PERMISSION;
16676185db85Sdougm 			    }
16686185db85Sdougm 			}
16696185db85Sdougm 		    }
16706185db85Sdougm 		} else {
16716185db85Sdougm 		    (void) printf(gettext("Group \"%s\" not found\n"),
16726185db85Sdougm 					argv[optind]);
16736185db85Sdougm 		    ret = SA_NO_SUCH_GROUP;
16746185db85Sdougm 		}
16756185db85Sdougm 	    }
16766185db85Sdougm 	}
16776185db85Sdougm 	return (ret);
16786185db85Sdougm }
16796185db85Sdougm 
16806185db85Sdougm /*
16816185db85Sdougm  * sa_moveshare(flags, argc, argv)
16826185db85Sdougm  *
16836185db85Sdougm  * implements move-share subcommand.
16846185db85Sdougm  */
16856185db85Sdougm 
16866185db85Sdougm int
1687549ec3ffSdougm sa_moveshare(sa_handle_t handle, int flags, int argc, char *argv[])
16886185db85Sdougm {
16896185db85Sdougm 	int verbose = 0;
16906185db85Sdougm 	int dryrun = 0;
16916185db85Sdougm 	int c;
16926185db85Sdougm 	int ret = SA_OK;
16936185db85Sdougm 	sa_group_t group;
16946185db85Sdougm 	sa_share_t share;
16956185db85Sdougm 	char *sharepath = NULL;
16966185db85Sdougm 	int authsrc = 0, authdst = 0;
16976185db85Sdougm 
16986185db85Sdougm 	while ((c = getopt(argc, argv, "?hvns:")) != EOF) {
16996185db85Sdougm 	    switch (c) {
17006185db85Sdougm 	    case 'n':
17016185db85Sdougm 		dryrun++;
17026185db85Sdougm 		break;
17036185db85Sdougm 	    case 'v':
17046185db85Sdougm 		verbose++;
17056185db85Sdougm 		break;
17066185db85Sdougm 	    case 's':
17076185db85Sdougm 		/*
17086185db85Sdougm 		 * remove share path from group. Currently limit
17096185db85Sdougm 		 * to one share per command.
17106185db85Sdougm 		 */
17116185db85Sdougm 		if (sharepath != NULL) {
17126185db85Sdougm 		    (void) printf(gettext("Moving multiple shares not"
17136185db85Sdougm 				    "supported\n"));
17146185db85Sdougm 		    return (SA_BAD_PATH);
17156185db85Sdougm 		}
17166185db85Sdougm 		sharepath = optarg;
17176185db85Sdougm 		break;
17186185db85Sdougm 	    default:
17196185db85Sdougm 	    case 'h':
17206185db85Sdougm 	    case '?':
17216185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
17226185db85Sdougm 				sa_get_usage(USAGE_MOVE_SHARE));
17236185db85Sdougm 		return (0);
17246185db85Sdougm 	    }
17256185db85Sdougm 	}
17266185db85Sdougm 
17276185db85Sdougm 	if (optind >= argc || sharepath == NULL) {
17286185db85Sdougm 			(void) printf(gettext("usage: %s\n"),
17296185db85Sdougm 				sa_get_usage(USAGE_MOVE_SHARE));
17306185db85Sdougm 	    if (dryrun || verbose || sharepath != NULL) {
17316185db85Sdougm 		(void) printf(gettext("\tgroup must be specified\n"));
17326185db85Sdougm 		ret = SA_NO_SUCH_GROUP;
17336185db85Sdougm 	    } else {
17346185db85Sdougm 		if (sharepath == NULL) {
17356185db85Sdougm 		    ret = SA_SYNTAX_ERR;
17366185db85Sdougm 		    (void) printf(gettext("\tsharepath must be specified\n"));
17376185db85Sdougm 		} else
17386185db85Sdougm 		    ret = SA_OK;
17396185db85Sdougm 	    }
17406185db85Sdougm 	} else {
17416185db85Sdougm 	    if (sharepath == NULL) {
17426185db85Sdougm 		(void) printf(gettext("sharepath must be specified with "
17436185db85Sdougm 				"the -s option\n"));
17446185db85Sdougm 		ret = SA_BAD_PATH;
17456185db85Sdougm 	    } else {
1746549ec3ffSdougm 		group = sa_get_group(handle, argv[optind]);
17476185db85Sdougm 		if (group != NULL) {
1748549ec3ffSdougm 		    share = sa_find_share(handle, sharepath);
17496185db85Sdougm 		    authdst = check_authorizations(argv[optind], flags);
17506185db85Sdougm 		    if (share == NULL) {
17516185db85Sdougm 			(void) printf(gettext("Share not found: %s\n"),
17526185db85Sdougm 					sharepath);
17536185db85Sdougm 			ret = SA_NO_SUCH_PATH;
17546185db85Sdougm 		    } else {
17556185db85Sdougm 			sa_group_t parent;
17566185db85Sdougm 			char *zfsold;
17576185db85Sdougm 			char *zfsnew;
17586185db85Sdougm 
17596185db85Sdougm 			parent = sa_get_parent_group(share);
17606185db85Sdougm 			if (parent != NULL) {
17616185db85Sdougm 			    char *pname;
17626185db85Sdougm 			    pname = sa_get_group_attr(parent, "name");
17636185db85Sdougm 			    if (pname != NULL) {
17646185db85Sdougm 				authsrc = check_authorizations(pname, flags);
17656185db85Sdougm 				sa_free_attr_string(pname);
17666185db85Sdougm 			    }
17676185db85Sdougm 			    zfsold = sa_get_group_attr(parent, "zfs");
17686185db85Sdougm 			    zfsnew = sa_get_group_attr(group, "zfs");
17696185db85Sdougm 			    if ((zfsold != NULL && zfsnew == NULL) ||
17706185db85Sdougm 				(zfsold == NULL && zfsnew != NULL)) {
17716185db85Sdougm 				ret = SA_NOT_ALLOWED;
17726185db85Sdougm 			    }
17736185db85Sdougm 			    if (zfsold != NULL)
17746185db85Sdougm 				sa_free_attr_string(zfsold);
17756185db85Sdougm 			    if (zfsnew != NULL)
17766185db85Sdougm 				sa_free_attr_string(zfsnew);
17776185db85Sdougm 			}
17786185db85Sdougm 			if (!dryrun && ret == SA_OK) {
17796185db85Sdougm 			    ret = sa_move_share(group, share);
17806185db85Sdougm 			}
17816185db85Sdougm 			if (ret == SA_OK && parent != group && !dryrun) {
17826185db85Sdougm 			    char *oldstate;
1783549ec3ffSdougm 			    ret = sa_update_config(handle);
17846185db85Sdougm 				/*
17856185db85Sdougm 				 * note that the share may need to be
17866185db85Sdougm 				 * "unshared" if the new group is
17876185db85Sdougm 				 * disabled and the old was enabled or
17886185db85Sdougm 				 * it may need to be share to update
17896185db85Sdougm 				 * if the new group is enabled.
17906185db85Sdougm 				 */
17916185db85Sdougm 			    oldstate = sa_get_group_attr(parent, "state");
17926185db85Sdougm 			    /* enable_share determines what to do */
17936185db85Sdougm 			    if (strcmp(oldstate, "enabled") == 0) {
17946185db85Sdougm 				(void) sa_disable_share(share, NULL);
17956185db85Sdougm 			    }
1796549ec3ffSdougm 			    (void) enable_share(handle, group, share, 1);
17976185db85Sdougm 			    if (oldstate != NULL)
17986185db85Sdougm 				sa_free_attr_string(oldstate);
17996185db85Sdougm 			}
18006185db85Sdougm 			if (ret != SA_OK) {
18016185db85Sdougm 			    (void) printf(gettext("Could not move share: %s\n"),
18026185db85Sdougm 				    sa_errorstr(ret));
18036185db85Sdougm 			}
18046185db85Sdougm 			if (dryrun && ret == SA_OK && !(authsrc & authdst) &&
18056185db85Sdougm 			    verbose) {
18066185db85Sdougm 			    (void) printf(gettext("Command would fail: %s\n"),
18076185db85Sdougm 					sa_errorstr(SA_NO_PERMISSION));
18086185db85Sdougm 			}
18096185db85Sdougm 		    }
18106185db85Sdougm 		} else {
18116185db85Sdougm 		    (void) printf(gettext("Group \"%s\" not found\n"),
18126185db85Sdougm 					argv[optind]);
18136185db85Sdougm 		    ret = SA_NO_SUCH_GROUP;
18146185db85Sdougm 		}
18156185db85Sdougm 	    }
18166185db85Sdougm 	}
18176185db85Sdougm 	return (ret);
18186185db85Sdougm }
18196185db85Sdougm 
18206185db85Sdougm /*
18216185db85Sdougm  * sa_removeshare(flags, argc, argv)
18226185db85Sdougm  *
18236185db85Sdougm  * implements remove-share subcommand.
18246185db85Sdougm  */
18256185db85Sdougm 
18266185db85Sdougm int
1827549ec3ffSdougm sa_removeshare(sa_handle_t handle, int flags, int argc, char *argv[])
18286185db85Sdougm {
18296185db85Sdougm 	int verbose = 0;
18306185db85Sdougm 	int dryrun = 0;
18316185db85Sdougm 	int force = 0;
18326185db85Sdougm 	int c;
18336185db85Sdougm 	int ret = SA_OK;
18346185db85Sdougm 	sa_group_t group;
18356185db85Sdougm 	sa_share_t share;
18366185db85Sdougm 	char *sharepath = NULL;
18376185db85Sdougm 	char dir[MAXPATHLEN];
18386185db85Sdougm 	int auth;
18396185db85Sdougm 
18406185db85Sdougm 	while ((c = getopt(argc, argv, "?hfns:v")) != EOF) {
18416185db85Sdougm 	    switch (c) {
18426185db85Sdougm 	    case 'n':
18436185db85Sdougm 		dryrun++;
18446185db85Sdougm 		break;
18456185db85Sdougm 	    case 'v':
18466185db85Sdougm 		verbose++;
18476185db85Sdougm 		break;
18486185db85Sdougm 	    case 'f':
18496185db85Sdougm 		force++;
18506185db85Sdougm 		break;
18516185db85Sdougm 	    case 's':
18526185db85Sdougm 		/*
18536185db85Sdougm 		 * remove share path from group. Currently limit
18546185db85Sdougm 		 * to one share per command.
18556185db85Sdougm 		 */
18566185db85Sdougm 		if (sharepath != NULL) {
18576185db85Sdougm 		    (void) printf(gettext("Removing multiple shares not"
18586185db85Sdougm 				    "supported\n"));
18596185db85Sdougm 		    return (SA_SYNTAX_ERR);
18606185db85Sdougm 		}
18616185db85Sdougm 		sharepath = optarg;
18626185db85Sdougm 		break;
18636185db85Sdougm 	    default:
18646185db85Sdougm 	    case 'h':
18656185db85Sdougm 	    case '?':
18666185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
18676185db85Sdougm 				sa_get_usage(USAGE_REMOVE_SHARE));
18686185db85Sdougm 		return (0);
18696185db85Sdougm 	    }
18706185db85Sdougm 	}
18716185db85Sdougm 
18726185db85Sdougm 	if (optind >= argc || sharepath == NULL) {
18736185db85Sdougm 	    if (sharepath == NULL) {
18746185db85Sdougm 			(void) printf(gettext("usage: %s\n"),
18756185db85Sdougm 				sa_get_usage(USAGE_REMOVE_SHARE));
18766185db85Sdougm 		(void) printf(gettext("\t-s sharepath must be specified\n"));
18776185db85Sdougm 		ret = SA_BAD_PATH;
18786185db85Sdougm 	    } else {
18796185db85Sdougm 		ret = SA_OK;
18806185db85Sdougm 	    }
18816185db85Sdougm 	}
18826185db85Sdougm 	if (ret == SA_OK) {
18836185db85Sdougm 	    if (optind < argc) {
18846185db85Sdougm 		if ((optind + 1) < argc) {
18856185db85Sdougm 		    (void) printf(gettext("Extraneous group(s) at end of "
18866185db85Sdougm 						"command\n"));
18876185db85Sdougm 		    ret = SA_SYNTAX_ERR;
18886185db85Sdougm 		} else {
1889549ec3ffSdougm 		    group = sa_get_group(handle, argv[optind]);
18906185db85Sdougm 		    if (group == NULL) {
18916185db85Sdougm 			(void) printf(gettext("Group \"%s\" not found\n"),
18926185db85Sdougm 					argv[optind]);
18936185db85Sdougm 			ret = SA_NO_SUCH_GROUP;
18946185db85Sdougm 		    }
18956185db85Sdougm 		}
18966185db85Sdougm 	    } else {
18976185db85Sdougm 		group = NULL;
18986185db85Sdougm 	    }
1899a99982a7Sdougm 
1900a99982a7Sdougm 		/*
1901a99982a7Sdougm 		 * Lookup the path in the internal configuration. Care
1902a99982a7Sdougm 		 * must be taken to handle the case where the
1903a99982a7Sdougm 		 * underlying path has been removed since we need to
1904a99982a7Sdougm 		 * be able to deal with that as well.
1905a99982a7Sdougm 		 */
19066185db85Sdougm 	    if (ret == SA_OK) {
19076185db85Sdougm 		if (group != NULL)
19086185db85Sdougm 		    share = sa_get_share(group, sharepath);
19096185db85Sdougm 		else
1910549ec3ffSdougm 		    share = sa_find_share(handle, sharepath);
1911a99982a7Sdougm 		/*
1912a99982a7Sdougm 		 * If we didn't find the share with the provided path,
1913a99982a7Sdougm 		 * it may be a symlink so attempt to resolve it using
1914a99982a7Sdougm 		 * realpath and try again. Realpath will resolve any
1915a99982a7Sdougm 		 * symlinks and place them in "dir". Note that
1916a99982a7Sdougm 		 * sharepath is only used for the lookup the first
1917a99982a7Sdougm 		 * time and later for error messages. dir will be used
1918a99982a7Sdougm 		 * on the second attempt. Once a share is found, all
1919a99982a7Sdougm 		 * operations are based off of the share variable.
1920a99982a7Sdougm 		 */
1921a99982a7Sdougm 		if (share == NULL) {
1922a99982a7Sdougm 		    if (realpath(sharepath, dir) == NULL) {
1923a99982a7Sdougm 			ret = SA_BAD_PATH;
1924a99982a7Sdougm 			(void) printf(gettext("Path is not valid: %s\n"),
1925a99982a7Sdougm 						sharepath);
1926a99982a7Sdougm 		    } else {
1927a99982a7Sdougm 			if (group != NULL)
1928a99982a7Sdougm 			    share = sa_get_share(group, dir);
1929a99982a7Sdougm 			else
1930549ec3ffSdougm 			    share = sa_find_share(handle, dir);
1931a99982a7Sdougm 		    }
1932a99982a7Sdougm 		}
1933a99982a7Sdougm 	    }
1934a99982a7Sdougm 
1935a99982a7Sdougm 		/*
1936a99982a7Sdougm 		 * If there hasn't been an error, there was likely a
1937a99982a7Sdougm 		 * path found. If not, give the appropriate error
1938a99982a7Sdougm 		 * message and set the return error. If it was found,
1939a99982a7Sdougm 		 * then disable the share and then remove it from the
1940a99982a7Sdougm 		 * configuration.
1941a99982a7Sdougm 		 */
1942a99982a7Sdougm 	    if (ret == SA_OK) {
19436185db85Sdougm 		if (share == NULL) {
19446185db85Sdougm 		    if (group != NULL)
19456185db85Sdougm 			(void) printf(gettext("Share not found in group %s:"
19466185db85Sdougm 						" %s\n"),
19476185db85Sdougm 					argv[optind], sharepath);
19486185db85Sdougm 		    else
19496185db85Sdougm 			(void) printf(gettext("Share not found: %s\n"),
19506185db85Sdougm 					sharepath);
19516185db85Sdougm 		    ret = SA_NO_SUCH_PATH;
19526185db85Sdougm 		} else {
19536185db85Sdougm 		    if (group == NULL)
19546185db85Sdougm 			group = sa_get_parent_group(share);
19556185db85Sdougm 		    if (!dryrun) {
19566185db85Sdougm 			if (ret == SA_OK) {
19576185db85Sdougm 			    ret = sa_disable_share(share, NULL);
19586185db85Sdougm 				/*
19596185db85Sdougm 				 * we don't care if it fails since it
1960a99982a7Sdougm 				 * could be disabled already. Some
1961a99982a7Sdougm 				 * unexpected errors could occur that
1962a99982a7Sdougm 				 * prevent removal, so also check for
1963a99982a7Sdougm 				 * force being set.
19646185db85Sdougm 				 */
19656185db85Sdougm 			    if (ret == SA_OK || ret == SA_NO_SUCH_PATH ||
1966a99982a7Sdougm 					ret == SA_NOT_SUPPORTED ||
1967a99982a7Sdougm 					ret == SA_SYSTEM_ERR || force) {
19686185db85Sdougm 				ret = sa_remove_share(share);
19696185db85Sdougm 			    }
19706185db85Sdougm 			    if (ret == SA_OK)
1971549ec3ffSdougm 				ret = sa_update_config(handle);
19726185db85Sdougm 			}
19736185db85Sdougm 			if (ret != SA_OK) {
19746185db85Sdougm 			    (void) printf(gettext("Could not remove share:"
19756185db85Sdougm 							" %s\n"),
19766185db85Sdougm 					sa_errorstr(ret));
19776185db85Sdougm 			}
19786185db85Sdougm 		    } else if (ret == SA_OK) {
19796185db85Sdougm 			char *pname;
19806185db85Sdougm 			pname = sa_get_group_attr(group, "name");
19816185db85Sdougm 			if (pname != NULL) {
19826185db85Sdougm 			    auth = check_authorizations(pname, flags);
19836185db85Sdougm 			    sa_free_attr_string(pname);
19846185db85Sdougm 			}
19856185db85Sdougm 			if (!auth && verbose) {
19866185db85Sdougm 			    (void) printf(gettext("Command would fail: %s\n"),
19876185db85Sdougm 					sa_errorstr(SA_NO_PERMISSION));
19886185db85Sdougm 			}
19896185db85Sdougm 		    }
19906185db85Sdougm 		}
19916185db85Sdougm 	    }
19926185db85Sdougm 	}
19936185db85Sdougm 	return (ret);
19946185db85Sdougm }
19956185db85Sdougm 
19966185db85Sdougm /*
19976185db85Sdougm  * sa_set_share(flags, argc, argv)
19986185db85Sdougm  *
19996185db85Sdougm  * implements set-share subcommand.
20006185db85Sdougm  */
20016185db85Sdougm 
20026185db85Sdougm int
2003549ec3ffSdougm sa_set_share(sa_handle_t handle, int flags, int argc, char *argv[])
20046185db85Sdougm {
20056185db85Sdougm 	int dryrun = 0;
20066185db85Sdougm 	int c;
20076185db85Sdougm 	int ret = SA_OK;
20086185db85Sdougm 	sa_group_t group, sharegroup;
20096185db85Sdougm 	sa_share_t share;
20106185db85Sdougm 	char *sharepath = NULL;
20116185db85Sdougm 	char *description = NULL;
20126185db85Sdougm 	char *resource = NULL;
20136185db85Sdougm 	int auth;
20146185db85Sdougm 	int verbose = 0;
20156185db85Sdougm 
20166185db85Sdougm 	while ((c = getopt(argc, argv, "?hnd:r:s:")) != EOF) {
20176185db85Sdougm 	    switch (c) {
20186185db85Sdougm 	    case 'n':
20196185db85Sdougm 		dryrun++;
20206185db85Sdougm 		break;
20216185db85Sdougm 	    case 'd':
20226185db85Sdougm 		description = optarg;
20236185db85Sdougm 		break;
20246185db85Sdougm 	    case 'r':
20256185db85Sdougm 		resource = optarg;
20266185db85Sdougm 		break;
20276185db85Sdougm 	    case 'v':
20286185db85Sdougm 		verbose++;
20296185db85Sdougm 		break;
20306185db85Sdougm 	    case 's':
20316185db85Sdougm 		/*
20326185db85Sdougm 		 * save share path into group. Currently limit
20336185db85Sdougm 		 * to one share per command.
20346185db85Sdougm 		 */
20356185db85Sdougm 		if (sharepath != NULL) {
20366185db85Sdougm 		    (void) printf(gettext("Updating multiple shares not"
20376185db85Sdougm 				    "supported\n"));
20386185db85Sdougm 		    return (SA_BAD_PATH);
20396185db85Sdougm 		}
20406185db85Sdougm 		sharepath = optarg;
20416185db85Sdougm 		break;
20426185db85Sdougm 	    default:
20436185db85Sdougm 	    case 'h':
20446185db85Sdougm 	    case '?':
20456185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
20466185db85Sdougm 				sa_get_usage(USAGE_SET_SHARE));
20476185db85Sdougm 		return (SA_OK);
20486185db85Sdougm 	    }
20496185db85Sdougm 	}
20506185db85Sdougm 	if (optind >= argc || sharepath == NULL) {
20516185db85Sdougm 	    if (sharepath == NULL) {
20526185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
20536185db85Sdougm 				sa_get_usage(USAGE_SET_SHARE));
20546185db85Sdougm 		(void) printf(gettext("\tgroup must be specified\n"));
20556185db85Sdougm 	    ret = SA_BAD_PATH;
20566185db85Sdougm 	    } else {
20576185db85Sdougm 		ret = SA_OK;
20586185db85Sdougm 	    }
20596185db85Sdougm 	}
20606185db85Sdougm 	if ((optind + 1) < argc) {
20616185db85Sdougm 	    (void) printf(gettext("usage: %s\n"),
20626185db85Sdougm 				sa_get_usage(USAGE_SET_SHARE));
20636185db85Sdougm 	    (void) printf(gettext("\tExtraneous group(s) at end\n"));
20646185db85Sdougm 	    ret = SA_SYNTAX_ERR;
20656185db85Sdougm 	}
20666185db85Sdougm 	if (ret == SA_OK) {
20676185db85Sdougm 	    char *groupname;
20686185db85Sdougm 	    if (optind < argc) {
20696185db85Sdougm 		groupname = argv[optind];
2070549ec3ffSdougm 		group = sa_get_group(handle, groupname);
20716185db85Sdougm 	    } else {
20726185db85Sdougm 		group = NULL;
20736185db85Sdougm 		groupname = NULL;
20746185db85Sdougm 	    }
2075549ec3ffSdougm 	    share = sa_find_share(handle, sharepath);
20766185db85Sdougm 	    if (share != NULL) {
20776185db85Sdougm 		sharegroup = sa_get_parent_group(share);
20786185db85Sdougm 		if (group != NULL && group != sharegroup) {
20796185db85Sdougm 		    (void) printf(gettext("Group \"%s\" does not contain "
20806185db85Sdougm 						"share %s\n"),
20816185db85Sdougm 			    argv[optind], sharepath);
20826185db85Sdougm 		    ret = SA_BAD_PATH;
20836185db85Sdougm 		} else {
20846185db85Sdougm 		    int delgroupname = 0;
20856185db85Sdougm 		    if (groupname == NULL) {
20866185db85Sdougm 			groupname = sa_get_group_attr(sharegroup, "name");
20876185db85Sdougm 			delgroupname = 1;
20886185db85Sdougm 		    }
20896185db85Sdougm 		    if (groupname != NULL) {
20906185db85Sdougm 			auth = check_authorizations(groupname, flags);
20916185db85Sdougm 			if (delgroupname) {
20926185db85Sdougm 			    sa_free_attr_string(groupname);
20936185db85Sdougm 			    groupname = NULL;
20946185db85Sdougm 			}
20956185db85Sdougm 		    } else {
20966185db85Sdougm 			ret = SA_NO_MEMORY;
20976185db85Sdougm 		    }
20986185db85Sdougm 		    if (resource != NULL) {
20996185db85Sdougm 			if (strpbrk(resource, " \t/") == NULL) {
21006185db85Sdougm 			    if (!dryrun) {
21016185db85Sdougm 				ret = sa_set_share_attr(share, "resource",
21026185db85Sdougm 						    resource);
21036185db85Sdougm 			    } else {
21046185db85Sdougm 				sa_share_t resshare;
21056185db85Sdougm 				resshare = sa_get_resource(sharegroup,
21066185db85Sdougm 							    resource);
21076185db85Sdougm 				if (resshare != NULL && resshare != share)
21086185db85Sdougm 				    ret = SA_DUPLICATE_NAME;
21096185db85Sdougm 			    }
21106185db85Sdougm 			} else {
21116185db85Sdougm 			    ret = SA_BAD_PATH;
21126185db85Sdougm 			    (void) printf(gettext("Resource must not contain "
21136185db85Sdougm 						"white space or '/'\n"));
21146185db85Sdougm 			}
21156185db85Sdougm 		    }
21166185db85Sdougm 		    if (ret == SA_OK && description != NULL) {
21176185db85Sdougm 			ret = sa_set_share_description(share, description);
21186185db85Sdougm 		    }
21196185db85Sdougm 		}
21206185db85Sdougm 		if (!dryrun && ret == SA_OK) {
2121549ec3ffSdougm 		    ret = sa_update_config(handle);
21226185db85Sdougm 		}
21236185db85Sdougm 		switch (ret) {
21246185db85Sdougm 		case SA_DUPLICATE_NAME:
21256185db85Sdougm 		    (void) printf(gettext("Resource name in use: %s\n"),
21266185db85Sdougm 					resource);
21276185db85Sdougm 		    break;
21286185db85Sdougm 		default:
21296185db85Sdougm 		    (void) printf(gettext("Could not set attribute: %s\n"),
21306185db85Sdougm 			    sa_errorstr(ret));
21316185db85Sdougm 		    break;
21326185db85Sdougm 		case SA_OK:
21336185db85Sdougm 		    if (dryrun && !auth && verbose) {
21346185db85Sdougm 			(void) printf(gettext("Command would fail: %s\n"),
21356185db85Sdougm 				sa_errorstr(SA_NO_PERMISSION));
21366185db85Sdougm 		    }
21376185db85Sdougm 		    break;
21386185db85Sdougm 		}
21396185db85Sdougm 	    } else {
21406185db85Sdougm 		(void) printf(gettext("Share path \"%s\" not found\n"),
21416185db85Sdougm 				sharepath);
21426185db85Sdougm 		ret = SA_NO_SUCH_PATH;
21436185db85Sdougm 	    }
21446185db85Sdougm 	}
21456185db85Sdougm 	return (ret);
21466185db85Sdougm }
21476185db85Sdougm 
21486185db85Sdougm /*
21496185db85Sdougm  * add_security(group, sectype, optlist, proto, *err)
21506185db85Sdougm  *
21516185db85Sdougm  * Helper function to add a security option (named optionset) to the
21526185db85Sdougm  * group.
21536185db85Sdougm  */
21546185db85Sdougm 
21556185db85Sdougm static int
21566185db85Sdougm add_security(sa_group_t group, char *sectype,
21576185db85Sdougm 		struct options *optlist, char *proto, int *err)
21586185db85Sdougm {
21596185db85Sdougm 	sa_security_t security;
21606185db85Sdougm 	int ret = SA_OK;
21616185db85Sdougm 	int result = 0;
21626185db85Sdougm 
21636185db85Sdougm 	sectype = sa_proto_space_alias(proto, sectype);
21646185db85Sdougm 	security = sa_get_security(group, sectype, proto);
21656185db85Sdougm 	if (security == NULL) {
21666185db85Sdougm 	    security = sa_create_security(group, sectype, proto);
21676185db85Sdougm 	}
21686185db85Sdougm 	if (sectype != NULL)
21696185db85Sdougm 	    sa_free_attr_string(sectype);
21706185db85Sdougm 	if (security != NULL) {
21716185db85Sdougm 	    while (optlist != NULL) {
21726185db85Sdougm 		sa_property_t prop;
21736185db85Sdougm 		prop = sa_get_property(security, optlist->optname);
21746185db85Sdougm 		if (prop == NULL) {
21756185db85Sdougm 			/*
21766185db85Sdougm 			 * add the property, but only if it is
21776185db85Sdougm 			 * a non-NULL or non-zero length value
21786185db85Sdougm 			 */
21796185db85Sdougm 		    if (optlist->optvalue != NULL) {
21806185db85Sdougm 			prop = sa_create_property(optlist->optname,
21816185db85Sdougm 							optlist->optvalue);
21826185db85Sdougm 			if (prop != NULL) {
21836185db85Sdougm 			    ret = sa_valid_property(security, proto, prop);
21846185db85Sdougm 			    if (ret != SA_OK) {
21856185db85Sdougm 				(void) sa_remove_property(prop);
21866185db85Sdougm 				(void) printf(gettext("Could not add "
21876185db85Sdougm 							"property %s: %s\n"),
21886185db85Sdougm 							optlist->optname,
21896185db85Sdougm 						sa_errorstr(ret));
21906185db85Sdougm 			    }
21916185db85Sdougm 			    if (ret == SA_OK) {
21926185db85Sdougm 				ret = sa_add_property(security, prop);
21936185db85Sdougm 				if (ret != SA_OK) {
21946185db85Sdougm 				    (void) printf(gettext("Could not add "
21956185db85Sdougm 						    "property (%s=%s): %s\n"),
21966185db85Sdougm 						optlist->optname,
21976185db85Sdougm 						optlist->optvalue,
21986185db85Sdougm 						sa_errorstr(ret));
21996185db85Sdougm 				} else {
22006185db85Sdougm 				    result = 1;
22016185db85Sdougm 				}
22026185db85Sdougm 			    }
22036185db85Sdougm 			}
22046185db85Sdougm 		    }
22056185db85Sdougm 		} else {
22066185db85Sdougm 		    ret = sa_update_property(prop, optlist->optvalue);
22076185db85Sdougm 		    result = 1; /* should check if really changed */
22086185db85Sdougm 		}
22096185db85Sdougm 		optlist = optlist->next;
22106185db85Sdougm 	    }
22116185db85Sdougm 		/*
22126185db85Sdougm 		 * when done, properties may have all been removed but
22136185db85Sdougm 		 * we need to keep the security type itself until
22146185db85Sdougm 		 * explicitly removed.
22156185db85Sdougm 		 */
22166185db85Sdougm 	    if (result)
22176185db85Sdougm 		ret = sa_commit_properties(security, 0);
22186185db85Sdougm 	}
22196185db85Sdougm 	*err = ret;
22206185db85Sdougm 	return (result);
22216185db85Sdougm }
22226185db85Sdougm 
22236185db85Sdougm /*
22246185db85Sdougm  * basic_set(groupname, optlist, protocol, sharepath, dryrun)
22256185db85Sdougm  *
22266185db85Sdougm  * This function implements "set" when a name space (-S) is not
22276185db85Sdougm  * specified. It is a basic set. Options and other CLI parsing has
22286185db85Sdougm  * already been done.
22296185db85Sdougm  */
22306185db85Sdougm 
22316185db85Sdougm static int
2232549ec3ffSdougm basic_set(sa_handle_t handle, char *groupname, struct options *optlist,
2233549ec3ffSdougm 		char *protocol,	char *sharepath, int dryrun)
22346185db85Sdougm {
22356185db85Sdougm 	sa_group_t group;
22366185db85Sdougm 	int ret = SA_OK;
22376185db85Sdougm 	int change = 0;
22386185db85Sdougm 	struct list *worklist = NULL;
22396185db85Sdougm 
2240549ec3ffSdougm 	group = sa_get_group(handle, groupname);
22416185db85Sdougm 	if (group != NULL) {
22426185db85Sdougm 	    sa_share_t share = NULL;
22436185db85Sdougm 	    if (sharepath != NULL) {
22446185db85Sdougm 		share = sa_get_share(group, sharepath);
22456185db85Sdougm 		if (share == NULL) {
22466185db85Sdougm 		    (void) printf(gettext("Share does not exist in group %s\n"),
22476185db85Sdougm 				groupname, sharepath);
22486185db85Sdougm 		    ret = SA_NO_SUCH_PATH;
22496185db85Sdougm 		}
22506185db85Sdougm 	    }
22516185db85Sdougm 	    if (ret == SA_OK) {
22526185db85Sdougm 		/* group must exist */
22536185db85Sdougm 		ret = valid_options(optlist, protocol,
22546185db85Sdougm 				    share == NULL ? group : share, NULL);
22556185db85Sdougm 		if (ret == SA_OK && !dryrun) {
22566185db85Sdougm 		    if (share != NULL)
22576185db85Sdougm 			change |= add_optionset(share, optlist, protocol,
22586185db85Sdougm 						&ret);
22596185db85Sdougm 		    else
22606185db85Sdougm 			change |= add_optionset(group, optlist, protocol,
22616185db85Sdougm 						&ret);
22626185db85Sdougm 		    if (ret == SA_OK && change) {
22636185db85Sdougm 			worklist = add_list(worklist, group, share);
22646185db85Sdougm 		    }
22656185db85Sdougm 		}
22666185db85Sdougm 	    }
22676185db85Sdougm 	    free_opt(optlist);
22686185db85Sdougm 	} else {
22696185db85Sdougm 		(void) printf(gettext("Group \"%s\" not found\n"), groupname);
22706185db85Sdougm 		ret = SA_NO_SUCH_GROUP;
22716185db85Sdougm 	}
22726185db85Sdougm 	/*
22736185db85Sdougm 	 * we have a group and potentially legal additions
22746185db85Sdougm 	 */
22756185db85Sdougm 
22766185db85Sdougm 	/* commit to configuration if not a dryrun */
22776185db85Sdougm 	if (!dryrun && ret == SA_OK) {
22786185db85Sdougm 	    if (change && worklist != NULL) {
22796185db85Sdougm 		/* properties changed, so update all shares */
2280549ec3ffSdougm 		(void) enable_all_groups(handle, worklist, 0, 0, protocol);
22816185db85Sdougm 	    }
22826185db85Sdougm 	}
22836185db85Sdougm 	if (worklist != NULL)
22846185db85Sdougm 	    free_list(worklist);
22856185db85Sdougm 	return (ret);
22866185db85Sdougm }
22876185db85Sdougm 
22886185db85Sdougm /*
22896185db85Sdougm  * space_set(groupname, optlist, protocol, sharepath, dryrun)
22906185db85Sdougm  *
22916185db85Sdougm  * This function implements "set" when a name space (-S) is
22926185db85Sdougm  * specified. It is a namespace set. Options and other CLI parsing has
22936185db85Sdougm  * already been done.
22946185db85Sdougm  */
22956185db85Sdougm 
22966185db85Sdougm static int
2297549ec3ffSdougm space_set(sa_handle_t handle, char *groupname, struct options *optlist,
2298549ec3ffSdougm 		char *protocol,	char *sharepath, int dryrun, char *sectype)
22996185db85Sdougm {
23006185db85Sdougm 	sa_group_t group;
23016185db85Sdougm 	int ret = SA_OK;
23026185db85Sdougm 	int change = 0;
23036185db85Sdougm 	struct list *worklist = NULL;
23046185db85Sdougm 
23056185db85Sdougm 	/*
23066185db85Sdougm 	 * make sure protcol and sectype are valid
23076185db85Sdougm 	 */
23086185db85Sdougm 
23096185db85Sdougm 	if (sa_proto_valid_space(protocol, sectype) == 0) {
23106185db85Sdougm 	    (void) printf(gettext("Option space \"%s\" not valid "
23116185db85Sdougm 					"for protocol.\n"),
23126185db85Sdougm 				sectype);
23136185db85Sdougm 	    return (SA_INVALID_SECURITY);
23146185db85Sdougm 	}
23156185db85Sdougm 
2316549ec3ffSdougm 	group = sa_get_group(handle, groupname);
23176185db85Sdougm 	if (group != NULL) {
23186185db85Sdougm 	    sa_share_t share = NULL;
23196185db85Sdougm 	    if (sharepath != NULL) {
23206185db85Sdougm 		share = sa_get_share(group, sharepath);
23216185db85Sdougm 		if (share == NULL) {
23226185db85Sdougm 		    (void) printf(gettext("Share does not exist in group %s\n"),
23236185db85Sdougm 				groupname, sharepath);
23246185db85Sdougm 		    ret = SA_NO_SUCH_PATH;
23256185db85Sdougm 		}
23266185db85Sdougm 	    }
23276185db85Sdougm 	    if (ret == SA_OK) {
23286185db85Sdougm 		/* group must exist */
23296185db85Sdougm 		ret = valid_options(optlist, protocol,
23306185db85Sdougm 				    share == NULL ? group : share, sectype);
23316185db85Sdougm 		if (ret == SA_OK && !dryrun) {
23326185db85Sdougm 		    if (share != NULL)
23336185db85Sdougm 			change = add_security(share, sectype, optlist,
23346185db85Sdougm 						protocol,
23356185db85Sdougm 						&ret);
23366185db85Sdougm 		    else
23376185db85Sdougm 			change = add_security(group, sectype, optlist,
23386185db85Sdougm 						protocol,
23396185db85Sdougm 						&ret);
23406185db85Sdougm 		    if (ret != SA_OK)
23416185db85Sdougm 			(void) printf(gettext("Could not set property: %s\n"),
23426185db85Sdougm 				sa_errorstr(ret));
23436185db85Sdougm 		}
23446185db85Sdougm 		if (ret == SA_OK && change)
23456185db85Sdougm 		    worklist = add_list(worklist, group, share);
23466185db85Sdougm 	    }
23476185db85Sdougm 	    free_opt(optlist);
23486185db85Sdougm 	} else {
23496185db85Sdougm 		(void) printf(gettext("Group \"%s\" not found\n"), groupname);
23506185db85Sdougm 		ret = SA_NO_SUCH_GROUP;
23516185db85Sdougm 	}
23526185db85Sdougm 	/*
23536185db85Sdougm 	 * we have a group and potentially legal additions
23546185db85Sdougm 	 */
23556185db85Sdougm 
23566185db85Sdougm 	/* commit to configuration if not a dryrun */
23576185db85Sdougm 	if (!dryrun && ret == 0) {
23586185db85Sdougm 	    if (change && worklist != NULL) {
23596185db85Sdougm 		/* properties changed, so update all shares */
2360549ec3ffSdougm 		(void) enable_all_groups(handle, worklist, 0, 0, protocol);
23616185db85Sdougm 	    }
2362549ec3ffSdougm 	    ret = sa_update_config(handle);
23636185db85Sdougm 	}
23646185db85Sdougm 	if (worklist != NULL)
23656185db85Sdougm 	    free_list(worklist);
23666185db85Sdougm 	return (ret);
23676185db85Sdougm }
23686185db85Sdougm 
23696185db85Sdougm /*
23706185db85Sdougm  * sa_set(flags, argc, argv)
23716185db85Sdougm  *
23726185db85Sdougm  * Implements the set subcommand. It keys off of -S to determine which
23736185db85Sdougm  * set of operations to actually do.
23746185db85Sdougm  */
23756185db85Sdougm 
23766185db85Sdougm int
2377549ec3ffSdougm sa_set(sa_handle_t handle, int flags, int argc, char *argv[])
23786185db85Sdougm {
23796185db85Sdougm 	char *groupname;
23806185db85Sdougm 	int verbose = 0;
23816185db85Sdougm 	int dryrun = 0;
23826185db85Sdougm 	int c;
23836185db85Sdougm 	char *protocol = NULL;
23846185db85Sdougm 	int ret = SA_OK;
23856185db85Sdougm 	struct options *optlist = NULL;
23866185db85Sdougm 	char *sharepath = NULL;
23876185db85Sdougm 	char *optset = NULL;
23886185db85Sdougm 	int auth;
23896185db85Sdougm 
23906185db85Sdougm 	while ((c = getopt(argc, argv, "?hvnP:p:s:S:")) != EOF) {
23916185db85Sdougm 	    switch (c) {
23926185db85Sdougm 	    case 'v':
23936185db85Sdougm 		verbose++;
23946185db85Sdougm 		break;
23956185db85Sdougm 	    case 'n':
23966185db85Sdougm 		dryrun++;
23976185db85Sdougm 		break;
23986185db85Sdougm 	    case 'P':
23996185db85Sdougm 		protocol = optarg;
24006185db85Sdougm 		if (!sa_valid_protocol(protocol)) {
24016185db85Sdougm 		    (void) printf(gettext("Invalid protocol specified:"
24026185db85Sdougm 				    "%s\n"),
24036185db85Sdougm 					protocol);
24046185db85Sdougm 		    return (SA_INVALID_PROTOCOL);
24056185db85Sdougm 		}
24066185db85Sdougm 		break;
24076185db85Sdougm 	    case 'p':
24086185db85Sdougm 		ret = add_opt(&optlist, optarg, 0);
24096185db85Sdougm 		switch (ret) {
24106185db85Sdougm 		case OPT_ADD_SYNTAX:
24116185db85Sdougm 		    (void) printf(gettext("Property syntax error: %s\n"),
24126185db85Sdougm 					optarg);
24136185db85Sdougm 		    return (SA_SYNTAX_ERR);
24146185db85Sdougm 		case OPT_ADD_MEMORY:
24156185db85Sdougm 		    (void) printf(gettext("No memory to set property: %s\n"),
24166185db85Sdougm 					optarg);
24176185db85Sdougm 		    return (SA_NO_MEMORY);
24186185db85Sdougm 		default:
24196185db85Sdougm 		    break;
24206185db85Sdougm 		}
24216185db85Sdougm 		break;
24226185db85Sdougm 	    case 's':
24236185db85Sdougm 		sharepath = optarg;
24246185db85Sdougm 		break;
24256185db85Sdougm 	    case 'S':
24266185db85Sdougm 		optset = optarg;
24276185db85Sdougm 		break;
24286185db85Sdougm 	    default:
24296185db85Sdougm 	    case 'h':
24306185db85Sdougm 	    case '?':
24316185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
24326185db85Sdougm 				sa_get_usage(USAGE_SET));
24336185db85Sdougm 		return (SA_OK);
24346185db85Sdougm 	    }
24356185db85Sdougm 	}
24366185db85Sdougm 
24376185db85Sdougm 	if (optlist != NULL)
24386185db85Sdougm 	    ret = chk_opt(optlist, optset != NULL, protocol);
24396185db85Sdougm 
24406185db85Sdougm 	if (optind >= argc || (optlist == NULL && optset == NULL) ||
24416185db85Sdougm 	    protocol == NULL ||
24426185db85Sdougm 	    ret != OPT_ADD_OK) {
24436185db85Sdougm 	    char *sep = "\t";
24446185db85Sdougm 	    (void) printf(gettext("usage: %s\n"), sa_get_usage(USAGE_SET));
24456185db85Sdougm 	    if (optind >= argc) {
24466185db85Sdougm 		(void) printf(gettext("%sgroup must be specified"), sep);
24476185db85Sdougm 		sep = ", ";
24486185db85Sdougm 	    }
24496185db85Sdougm 	    if (optlist == NULL) {
24506185db85Sdougm 		(void) printf(gettext("%sat least one property must be"
24516185db85Sdougm 				" specified"), sep);
24526185db85Sdougm 		sep = ", ";
24536185db85Sdougm 	    }
24546185db85Sdougm 	    if (protocol == NULL) {
24556185db85Sdougm 		(void) printf(gettext("%sprotocol must be specified"), sep);
24566185db85Sdougm 		sep = ", ";
24576185db85Sdougm 	    }
24586185db85Sdougm 	    (void) printf("\n");
24596185db85Sdougm 	    ret = SA_SYNTAX_ERR;
24606185db85Sdougm 	} else {
24616185db85Sdougm 		/*
24626185db85Sdougm 		 * if a group already exists, we can only add a new
24636185db85Sdougm 		 * protocol to it and not create a new one or add the
24646185db85Sdougm 		 * same protocol again.
24656185db85Sdougm 		 */
24666185db85Sdougm 
24676185db85Sdougm 	    groupname = argv[optind];
24686185db85Sdougm 	    auth = check_authorizations(groupname, flags);
24696185db85Sdougm 	    if (optset == NULL)
2470549ec3ffSdougm 		ret = basic_set(handle, groupname, optlist, protocol,
24716185db85Sdougm 				sharepath, dryrun);
24726185db85Sdougm 	    else
2473549ec3ffSdougm 		ret = space_set(handle, groupname, optlist, protocol,
24746185db85Sdougm 				sharepath, dryrun, optset);
24756185db85Sdougm 	    if (dryrun && ret == SA_OK && !auth && verbose) {
24766185db85Sdougm 		(void) printf(gettext("Command would fail: %s\n"),
24776185db85Sdougm 			sa_errorstr(SA_NO_PERMISSION));
24786185db85Sdougm 	    }
24796185db85Sdougm 	}
24806185db85Sdougm 	return (ret);
24816185db85Sdougm }
24826185db85Sdougm 
24836185db85Sdougm /*
24846185db85Sdougm  * remove_options(group, optlist, proto, *err)
24856185db85Sdougm  *
24866185db85Sdougm  * helper function to actually remove options from a group after all
24876185db85Sdougm  * preprocessing is done.
24886185db85Sdougm  */
24896185db85Sdougm 
24906185db85Sdougm static int
24916185db85Sdougm remove_options(sa_group_t group, struct options *optlist,
24926185db85Sdougm 		char *proto, int *err)
24936185db85Sdougm {
24946185db85Sdougm 	struct options *cur;
24956185db85Sdougm 	sa_optionset_t optionset;
24966185db85Sdougm 	sa_property_t prop;
24976185db85Sdougm 	int change = 0;
24986185db85Sdougm 	int ret = SA_OK;
24996185db85Sdougm 
25006185db85Sdougm 	optionset = sa_get_optionset(group, proto);
25016185db85Sdougm 	if (optionset != NULL) {
25026185db85Sdougm 	    for (cur = optlist; cur != NULL; cur = cur->next) {
25036185db85Sdougm 		prop = sa_get_property(optionset, cur->optname);
25046185db85Sdougm 		if (prop != NULL) {
25056185db85Sdougm 		    ret = sa_remove_property(prop);
25066185db85Sdougm 		    if (ret != SA_OK)
25076185db85Sdougm 			break;
25086185db85Sdougm 		    change = 1;
25096185db85Sdougm 		}
25106185db85Sdougm 	    }
25116185db85Sdougm 	}
25126185db85Sdougm 	if (ret == SA_OK && change)
25136185db85Sdougm 	    ret = sa_commit_properties(optionset, 0);
25146185db85Sdougm 
25156185db85Sdougm 	if (err != NULL)
25166185db85Sdougm 	    *err = ret;
25176185db85Sdougm 	return (change);
25186185db85Sdougm }
25196185db85Sdougm 
25206185db85Sdougm /*
25216185db85Sdougm  * valid_unset(group, optlist, proto)
25226185db85Sdougm  *
25236185db85Sdougm  * Sanity check the optlist to make sure they can be removed. Issue an
25246185db85Sdougm  * error if a property doesn't exist.
25256185db85Sdougm  */
25266185db85Sdougm 
25276185db85Sdougm static int
25286185db85Sdougm valid_unset(sa_group_t group, struct options *optlist, char *proto)
25296185db85Sdougm {
25306185db85Sdougm 	struct options *cur;
25316185db85Sdougm 	sa_optionset_t optionset;
25326185db85Sdougm 	sa_property_t prop;
25336185db85Sdougm 	int ret = SA_OK;
25346185db85Sdougm 
25356185db85Sdougm 	optionset = sa_get_optionset(group, proto);
25366185db85Sdougm 	if (optionset != NULL) {
25376185db85Sdougm 	    for (cur = optlist; cur != NULL; cur = cur->next) {
25386185db85Sdougm 		prop = sa_get_property(optionset, cur->optname);
25396185db85Sdougm 		if (prop == NULL) {
25406185db85Sdougm 		    (void) printf(gettext("Could not unset property %s:"
25416185db85Sdougm 						" not set\n"),
25426185db85Sdougm 			    cur->optname);
25436185db85Sdougm 		    ret = SA_NO_SUCH_PROP;
25446185db85Sdougm 		}
25456185db85Sdougm 	    }
25466185db85Sdougm 	}
25476185db85Sdougm 	return (ret);
25486185db85Sdougm }
25496185db85Sdougm 
25506185db85Sdougm /*
25516185db85Sdougm  * valid_unset_security(group, optlist, proto)
25526185db85Sdougm  *
25536185db85Sdougm  * Sanity check the optlist to make sure they can be removed. Issue an
25546185db85Sdougm  * error if a property doesn't exist.
25556185db85Sdougm  */
25566185db85Sdougm 
25576185db85Sdougm static int
25586185db85Sdougm valid_unset_security(sa_group_t group, struct options *optlist, char *proto,
25596185db85Sdougm 	    char *sectype)
25606185db85Sdougm {
25616185db85Sdougm 	struct options *cur;
25626185db85Sdougm 	sa_security_t security;
25636185db85Sdougm 	sa_property_t prop;
25646185db85Sdougm 	int ret = SA_OK;
25656185db85Sdougm 	char *sec;
25666185db85Sdougm 
25676185db85Sdougm 	sec = sa_proto_space_alias(proto, sectype);
25686185db85Sdougm 	security = sa_get_security(group, sec, proto);
25696185db85Sdougm 	if (security != NULL) {
25706185db85Sdougm 	    for (cur = optlist; cur != NULL; cur = cur->next) {
25716185db85Sdougm 		prop = sa_get_property(security, cur->optname);
25726185db85Sdougm 		if (prop == NULL) {
25736185db85Sdougm 		    (void) printf(gettext("Could not unset property %s:"
25746185db85Sdougm 						" not set\n"),
25756185db85Sdougm 					cur->optname);
25766185db85Sdougm 		    ret = SA_NO_SUCH_PROP;
25776185db85Sdougm 		}
25786185db85Sdougm 	    }
25796185db85Sdougm 	} else {
25806185db85Sdougm 	    (void) printf(gettext("Could not unset %s: space not defined\n"),
25816185db85Sdougm 			    sectype);
25826185db85Sdougm 	    ret = SA_NO_SUCH_SECURITY;
25836185db85Sdougm 	}
25846185db85Sdougm 	if (sec != NULL)
25856185db85Sdougm 	    sa_free_attr_string(sec);
25866185db85Sdougm 	return (ret);
25876185db85Sdougm }
25886185db85Sdougm 
25896185db85Sdougm /*
25906185db85Sdougm  * remove_security(group, optlist, proto)
25916185db85Sdougm  *
25926185db85Sdougm  * Remove the properties since they were checked as valid.
25936185db85Sdougm  */
25946185db85Sdougm 
25956185db85Sdougm static int
25966185db85Sdougm remove_security(sa_group_t group, char *sectype,
25976185db85Sdougm 		struct options *optlist, char *proto, int *err)
25986185db85Sdougm {
25996185db85Sdougm 	sa_security_t security;
26006185db85Sdougm 	int ret = SA_OK;
26016185db85Sdougm 	int change = 0;
26026185db85Sdougm 
26036185db85Sdougm 	sectype = sa_proto_space_alias(proto, sectype);
26046185db85Sdougm 	security = sa_get_security(group, sectype, proto);
26056185db85Sdougm 	if (sectype != NULL)
26066185db85Sdougm 	    sa_free_attr_string(sectype);
26076185db85Sdougm 
26086185db85Sdougm 	if (security != NULL) {
26096185db85Sdougm 	    while (optlist != NULL) {
26106185db85Sdougm 		sa_property_t prop;
26116185db85Sdougm 		prop = sa_get_property(security, optlist->optname);
26126185db85Sdougm 		if (prop != NULL) {
26136185db85Sdougm 		    ret = sa_remove_property(prop);
26146185db85Sdougm 		    if (ret != SA_OK)
26156185db85Sdougm 			break;
26166185db85Sdougm 		    change = 1;
26176185db85Sdougm 		}
26186185db85Sdougm 		optlist = optlist->next;
26196185db85Sdougm 	    }
26206185db85Sdougm 		/*
26216185db85Sdougm 		 * when done, properties may have all been removed but
26226185db85Sdougm 		 * we need to keep the security type itself until
26236185db85Sdougm 		 * explicitly removed.
26246185db85Sdougm 		 */
26256185db85Sdougm 	    if (ret == SA_OK && change)
26266185db85Sdougm 		ret = sa_commit_properties(security, 0);
26276185db85Sdougm 	} else {
26286185db85Sdougm 	    ret = SA_NO_SUCH_PROP;
26296185db85Sdougm 	}
26306185db85Sdougm 	if (err != NULL)
26316185db85Sdougm 	    *err = ret;
26326185db85Sdougm 	return (change);
26336185db85Sdougm }
26346185db85Sdougm 
26356185db85Sdougm /*
26366185db85Sdougm  * basic_unset(groupname, optlist, protocol, sharepath, dryrun)
26376185db85Sdougm  *
26386185db85Sdougm  * unset non-named optionset properties.
26396185db85Sdougm  */
26406185db85Sdougm 
26416185db85Sdougm static int
2642549ec3ffSdougm basic_unset(sa_handle_t handle, char *groupname, struct options *optlist,
2643549ec3ffSdougm 		char *protocol,	char *sharepath, int dryrun)
26446185db85Sdougm {
26456185db85Sdougm 	sa_group_t group;
26466185db85Sdougm 	int ret = SA_OK;
26476185db85Sdougm 	int change = 0;
26486185db85Sdougm 	struct list *worklist = NULL;
26496185db85Sdougm 
2650549ec3ffSdougm 	group = sa_get_group(handle, groupname);
26516185db85Sdougm 	if (group != NULL) {
26526185db85Sdougm 	    sa_share_t share = NULL;
26536185db85Sdougm 	    if (sharepath != NULL) {
26546185db85Sdougm 		share = sa_get_share(group, sharepath);
26556185db85Sdougm 		if (share == NULL) {
26566185db85Sdougm 		    (void) printf(gettext("Share does not exist in group %s\n"),
26576185db85Sdougm 				groupname, sharepath);
26586185db85Sdougm 		    ret = SA_NO_SUCH_PATH;
26596185db85Sdougm 		}
26606185db85Sdougm 	    }
26616185db85Sdougm 	    if (ret == SA_OK) {
26626185db85Sdougm 		/* group must exist */
26636185db85Sdougm 		ret = valid_unset(share != NULL ? share : group,
26646185db85Sdougm 					optlist, protocol);
26656185db85Sdougm 		if (ret == SA_OK && !dryrun) {
26666185db85Sdougm 		    if (share != NULL) {
26676185db85Sdougm 			sa_optionset_t optionset;
26686185db85Sdougm 			sa_property_t prop;
26696185db85Sdougm 			change |= remove_options(share, optlist, protocol,
26706185db85Sdougm 							&ret);
26716185db85Sdougm 			/* if a share optionset is empty, remove it */
26726185db85Sdougm 			optionset = sa_get_optionset((sa_share_t)share,
26736185db85Sdougm 							protocol);
26746185db85Sdougm 			if (optionset != NULL) {
26756185db85Sdougm 			    prop = sa_get_property(optionset, NULL);
26766185db85Sdougm 			    if (prop == NULL)
26776185db85Sdougm 				(void) sa_destroy_optionset(optionset);
26786185db85Sdougm 			}
26796185db85Sdougm 		    } else {
26806185db85Sdougm 			change |= remove_options(group, optlist, protocol,
26816185db85Sdougm 							&ret);
26826185db85Sdougm 		    }
26836185db85Sdougm 		    if (ret == SA_OK && change)
26846185db85Sdougm 			worklist = add_list(worklist, group, share);
26856185db85Sdougm 		    if (ret != SA_OK)
26866185db85Sdougm 			(void) printf(gettext("Could not remove properties:"
26876185db85Sdougm 						"%s\n"),
26886185db85Sdougm 				sa_errorstr(ret));
26896185db85Sdougm 		}
26906185db85Sdougm 	    } else {
26916185db85Sdougm 		(void) printf(gettext("Group \"%s\" not found\n"), groupname);
26926185db85Sdougm 		ret = SA_NO_SUCH_GROUP;
26936185db85Sdougm 	    }
26946185db85Sdougm 	    free_opt(optlist);
26956185db85Sdougm 	}
26966185db85Sdougm 
26976185db85Sdougm 	/*
26986185db85Sdougm 	 * we have a group and potentially legal additions
26996185db85Sdougm 	 */
27006185db85Sdougm 	/* commit to configuration if not a dryrun */
27016185db85Sdougm 	if (!dryrun && ret == SA_OK) {
27026185db85Sdougm 	    if (change && worklist != NULL) {
27036185db85Sdougm 		/* properties changed, so update all shares */
2704549ec3ffSdougm 		(void) enable_all_groups(handle, worklist, 0, 0, protocol);
27056185db85Sdougm 	    }
27066185db85Sdougm 	}
27076185db85Sdougm 	if (worklist != NULL)
27086185db85Sdougm 	    free_list(worklist);
27096185db85Sdougm 	return (ret);
27106185db85Sdougm }
27116185db85Sdougm 
27126185db85Sdougm /*
27136185db85Sdougm  * space_unset(groupname, optlist, protocol, sharepath, dryrun)
27146185db85Sdougm  *
27156185db85Sdougm  * unset named optionset properties.
27166185db85Sdougm  */
27176185db85Sdougm static int
2718549ec3ffSdougm space_unset(sa_handle_t handle, char *groupname, struct options *optlist,
2719549ec3ffSdougm 		char *protocol, char *sharepath, int dryrun, char *sectype)
27206185db85Sdougm {
27216185db85Sdougm 	sa_group_t group;
27226185db85Sdougm 	int ret = SA_OK;
27236185db85Sdougm 	int change = 0;
27246185db85Sdougm 	struct list *worklist = NULL;
27256185db85Sdougm 
2726549ec3ffSdougm 	group = sa_get_group(handle, groupname);
27276185db85Sdougm 	if (group != NULL) {
27286185db85Sdougm 	    sa_share_t share = NULL;
27296185db85Sdougm 	    if (sharepath != NULL) {
27306185db85Sdougm 		share = sa_get_share(group, sharepath);
27316185db85Sdougm 		if (share == NULL) {
27326185db85Sdougm 		    (void) printf(gettext("Share does not exist in group %s\n"),
27336185db85Sdougm 				groupname, sharepath);
27346185db85Sdougm 		    ret = SA_NO_SUCH_PATH;
27356185db85Sdougm 		}
27366185db85Sdougm 	    }
27376185db85Sdougm 	    if (ret == SA_OK) {
27386185db85Sdougm 		ret = valid_unset_security(share != NULL ? share : group,
27396185db85Sdougm 						optlist, protocol, sectype);
27406185db85Sdougm 		if (ret == SA_OK && !dryrun) {
27416185db85Sdougm 		    if (optlist != NULL) {
27426185db85Sdougm 			if (share != NULL) {
27436185db85Sdougm 			    sa_security_t optionset;
27446185db85Sdougm 			    sa_property_t prop;
27456185db85Sdougm 			    change = remove_security(share, sectype,
27466185db85Sdougm 							optlist, protocol,
27476185db85Sdougm 							&ret);
27486185db85Sdougm 			    /* if a share security is empty, remove it */
27496185db85Sdougm 			    optionset = sa_get_security((sa_group_t)share,
27506185db85Sdougm 							sectype,
27516185db85Sdougm 							protocol);
27526185db85Sdougm 			    if (optionset != NULL) {
27536185db85Sdougm 				prop = sa_get_property(optionset, NULL);
27546185db85Sdougm 				if (prop == NULL)
27556185db85Sdougm 				    ret = sa_destroy_security(optionset);
27566185db85Sdougm 			    }
27576185db85Sdougm 			} else {
27586185db85Sdougm 			    change = remove_security(group, sectype,
27596185db85Sdougm 							optlist, protocol,
27606185db85Sdougm 							&ret);
27616185db85Sdougm 			}
27626185db85Sdougm 		    } else {
27636185db85Sdougm 			sa_security_t security;
27646185db85Sdougm 			char *sec;
27656185db85Sdougm 			sec = sa_proto_space_alias(protocol, sectype);
27666185db85Sdougm 			security = sa_get_security(group, sec, protocol);
27676185db85Sdougm 			if (sec != NULL)
27686185db85Sdougm 			    sa_free_attr_string(sec);
27696185db85Sdougm 			if (security != NULL) {
27706185db85Sdougm 			    ret = sa_destroy_security(security);
27716185db85Sdougm 			    if (ret == SA_OK)
27726185db85Sdougm 				change = 1;
27736185db85Sdougm 			} else {
27746185db85Sdougm 			    ret = SA_NO_SUCH_PROP;
27756185db85Sdougm 			}
27766185db85Sdougm 		    }
27776185db85Sdougm 		    if (ret != SA_OK)
27786185db85Sdougm 			(void) printf(gettext("Could not unset property: %s\n"),
27796185db85Sdougm 				sa_errorstr(ret));
27806185db85Sdougm 		}
27816185db85Sdougm 
27826185db85Sdougm 		if (ret == SA_OK && change)
27836185db85Sdougm 		    worklist = add_list(worklist, group, 0);
27846185db85Sdougm 	    }
27856185db85Sdougm 	} else {
27866185db85Sdougm 	    (void) printf(gettext("Group \"%s\" not found\n"), groupname);
27876185db85Sdougm 	    ret = SA_NO_SUCH_GROUP;
27886185db85Sdougm 	}
27896185db85Sdougm 	free_opt(optlist);
27906185db85Sdougm 	/*
27916185db85Sdougm 	 * we have a group and potentially legal additions
27926185db85Sdougm 	 */
27936185db85Sdougm 
27946185db85Sdougm 	/* commit to configuration if not a dryrun */
27956185db85Sdougm 	if (!dryrun && ret == 0) {
27966185db85Sdougm 	    if (change && worklist != NULL) {
27976185db85Sdougm 		/* properties changed, so update all shares */
2798549ec3ffSdougm 		(void) enable_all_groups(handle, worklist, 0, 0, protocol);
27996185db85Sdougm 	    }
2800549ec3ffSdougm 	    ret = sa_update_config(handle);
28016185db85Sdougm 	}
28026185db85Sdougm 	if (worklist != NULL)
28036185db85Sdougm 	    free_list(worklist);
28046185db85Sdougm 	return (ret);
28056185db85Sdougm }
28066185db85Sdougm 
28076185db85Sdougm /*
28086185db85Sdougm  * sa_unset(flags, argc, argv)
28096185db85Sdougm  *
28106185db85Sdougm  * implements the unset subcommand. Parsing done here and then basic
28116185db85Sdougm  * or space versions of the real code are called.
28126185db85Sdougm  */
28136185db85Sdougm 
28146185db85Sdougm int
2815549ec3ffSdougm sa_unset(sa_handle_t handle, int flags, int argc, char *argv[])
28166185db85Sdougm {
28176185db85Sdougm 	char *groupname;
28186185db85Sdougm 	int verbose = 0;
28196185db85Sdougm 	int dryrun = 0;
28206185db85Sdougm 	int c;
28216185db85Sdougm 	char *protocol = NULL;
28226185db85Sdougm 	int ret = SA_OK;
28236185db85Sdougm 	struct options *optlist = NULL;
28246185db85Sdougm 	char *sharepath = NULL;
28256185db85Sdougm 	char *optset = NULL;
28266185db85Sdougm 	int auth;
28276185db85Sdougm 
28286185db85Sdougm 	while ((c = getopt(argc, argv, "?hvnP:p:s:S:")) != EOF) {
28296185db85Sdougm 	    switch (c) {
28306185db85Sdougm 	    case 'v':
28316185db85Sdougm 		verbose++;
28326185db85Sdougm 		break;
28336185db85Sdougm 	    case 'n':
28346185db85Sdougm 		dryrun++;
28356185db85Sdougm 		break;
28366185db85Sdougm 	    case 'P':
28376185db85Sdougm 		protocol = optarg;
28386185db85Sdougm 		if (!sa_valid_protocol(protocol)) {
28396185db85Sdougm 		    (void) printf(gettext("Invalid protocol specified: %s\n"),
28406185db85Sdougm 					protocol);
28416185db85Sdougm 		    return (SA_INVALID_PROTOCOL);
28426185db85Sdougm 		}
28436185db85Sdougm 		break;
28446185db85Sdougm 	    case 'p':
28456185db85Sdougm 		ret = add_opt(&optlist, optarg, 1);
28466185db85Sdougm 		switch (ret) {
28476185db85Sdougm 		case OPT_ADD_SYNTAX:
28486185db85Sdougm 		    (void) printf(gettext("Property syntax error for "
28496185db85Sdougm 						"property %s\n"),
28506185db85Sdougm 					optarg);
28516185db85Sdougm 		    return (SA_SYNTAX_ERR);
28526185db85Sdougm 		case OPT_ADD_PROPERTY:
28536185db85Sdougm 		    (void) printf(gettext("Properties need to be set"
28546185db85Sdougm 						" with set command: %s\n"),
28556185db85Sdougm 					optarg);
28566185db85Sdougm 		    return (SA_SYNTAX_ERR);
28576185db85Sdougm 		default:
28586185db85Sdougm 		    break;
28596185db85Sdougm 		}
28606185db85Sdougm 		break;
28616185db85Sdougm 	    case 's':
28626185db85Sdougm 		sharepath = optarg;
28636185db85Sdougm 		break;
28646185db85Sdougm 	    case 'S':
28656185db85Sdougm 		optset = optarg;
28666185db85Sdougm 		break;
28676185db85Sdougm 	    default:
28686185db85Sdougm 	    case 'h':
28696185db85Sdougm 	    case '?':
28706185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
28716185db85Sdougm 				sa_get_usage(USAGE_UNSET));
28726185db85Sdougm 		return (SA_OK);
28736185db85Sdougm 	    }
28746185db85Sdougm 	}
28756185db85Sdougm 
28766185db85Sdougm 	if (optlist != NULL)
28776185db85Sdougm 	    ret = chk_opt(optlist, optset != NULL, protocol);
28786185db85Sdougm 
28796185db85Sdougm 	if (optind >= argc || (optlist == NULL && optset == NULL) ||
28806185db85Sdougm 	    protocol == NULL) {
28816185db85Sdougm 	    char *sep = "\t";
28826185db85Sdougm 	    (void) printf(gettext("usage: %s\n"), sa_get_usage(USAGE_UNSET));
28836185db85Sdougm 	    if (optind >= argc) {
28846185db85Sdougm 		(void) printf(gettext("%sgroup must be specified"), sep);
28856185db85Sdougm 		sep = ", ";
28866185db85Sdougm 	    }
28876185db85Sdougm 	    if (optlist == NULL) {
28886185db85Sdougm 		(void) printf(gettext("%sat least one property must be "
28896185db85Sdougm 					"specified"),
28906185db85Sdougm 			sep);
28916185db85Sdougm 		sep = ", ";
28926185db85Sdougm 	    }
28936185db85Sdougm 	    if (protocol == NULL) {
28946185db85Sdougm 		(void) printf(gettext("%sprotocol must be specified"), sep);
28956185db85Sdougm 		sep = ", ";
28966185db85Sdougm 	    }
28976185db85Sdougm 	    (void) printf("\n");
28986185db85Sdougm 	    ret = SA_SYNTAX_ERR;
28996185db85Sdougm 	} else {
29006185db85Sdougm 
29016185db85Sdougm 		/*
29026185db85Sdougm 		 * if a group already exists, we can only add a new
29036185db85Sdougm 		 * protocol to it and not create a new one or add the
29046185db85Sdougm 		 * same protocol again.
29056185db85Sdougm 		 */
29066185db85Sdougm 
29076185db85Sdougm 	    groupname = argv[optind];
29086185db85Sdougm 	    auth = check_authorizations(groupname, flags);
29096185db85Sdougm 	    if (optset == NULL)
2910549ec3ffSdougm 		ret = basic_unset(handle, groupname, optlist, protocol,
29116185db85Sdougm 					sharepath, dryrun);
29126185db85Sdougm 	    else
2913549ec3ffSdougm 		ret = space_unset(handle, groupname, optlist, protocol,
29146185db85Sdougm 					sharepath, dryrun, optset);
29156185db85Sdougm 
29166185db85Sdougm 	    if (dryrun && ret == SA_OK && !auth && verbose) {
29176185db85Sdougm 		(void) printf(gettext("Command would fail: %s\n"),
29186185db85Sdougm 			sa_errorstr(SA_NO_PERMISSION));
29196185db85Sdougm 	    }
29206185db85Sdougm 	}
29216185db85Sdougm 	return (ret);
29226185db85Sdougm }
29236185db85Sdougm 
29246185db85Sdougm /*
29256185db85Sdougm  * sa_enable_group(flags, argc, argv)
29266185db85Sdougm  *
29276185db85Sdougm  * Implements the enable subcommand
29286185db85Sdougm  */
29296185db85Sdougm 
29306185db85Sdougm int
2931549ec3ffSdougm sa_enable_group(sa_handle_t handle, int flags, int argc, char *argv[])
29326185db85Sdougm {
29336185db85Sdougm 	int verbose = 0;
29346185db85Sdougm 	int dryrun = 0;
29356185db85Sdougm 	int all = 0;
29366185db85Sdougm 	int c;
29376185db85Sdougm 	int ret = SA_OK;
29386185db85Sdougm 	char *protocol = NULL;
29396185db85Sdougm 	char *state;
29406185db85Sdougm 	struct list *worklist = NULL;
29416185db85Sdougm 	int auth = 1;
29426185db85Sdougm 
29436185db85Sdougm 	while ((c = getopt(argc, argv, "?havnP:")) != EOF) {
29446185db85Sdougm 	    switch (c) {
29456185db85Sdougm 	    case 'a':
29466185db85Sdougm 		all = 1;
29476185db85Sdougm 		break;
29486185db85Sdougm 	    case 'n':
29496185db85Sdougm 		dryrun++;
29506185db85Sdougm 		break;
29516185db85Sdougm 	    case 'P':
29526185db85Sdougm 		protocol = optarg;
29536185db85Sdougm 		if (!sa_valid_protocol(protocol)) {
29546185db85Sdougm 		    (void) printf(gettext("Invalid protocol specified: %s\n"),
29556185db85Sdougm 				    protocol);
29566185db85Sdougm 		    return (SA_INVALID_PROTOCOL);
29576185db85Sdougm 		}
29586185db85Sdougm 		break;
29596185db85Sdougm 	    case 'v':
29606185db85Sdougm 		verbose++;
29616185db85Sdougm 		break;
29626185db85Sdougm 	    default:
29636185db85Sdougm 	    case 'h':
29646185db85Sdougm 	    case '?':
29656185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
29666185db85Sdougm 				sa_get_usage(USAGE_ENABLE));
29676185db85Sdougm 		return (0);
29686185db85Sdougm 	    }
29696185db85Sdougm 	}
29706185db85Sdougm 
29716185db85Sdougm 	if (optind == argc && !all) {
29726185db85Sdougm 	    (void) printf(gettext("usage: %s\n"), sa_get_usage(USAGE_ENABLE));
29736185db85Sdougm 	    (void) printf(gettext("\tmust specify group\n"));
29746185db85Sdougm 	    ret = SA_NO_SUCH_PATH;
29756185db85Sdougm 	} else {
29766185db85Sdougm 	    sa_group_t group;
29776185db85Sdougm 	    if (!all) {
29786185db85Sdougm 		while (optind < argc) {
2979549ec3ffSdougm 		    group = sa_get_group(handle, argv[optind]);
29806185db85Sdougm 		    if (group != NULL) {
29816185db85Sdougm 			auth &= check_authorizations(argv[optind], flags);
29826185db85Sdougm 			state = sa_get_group_attr(group, "state");
29836185db85Sdougm 			if (state != NULL &&
29846185db85Sdougm 			    strcmp(state, "enabled") == 0) {
29856185db85Sdougm 			    /* already enabled */
29866185db85Sdougm 			    if (verbose)
29876185db85Sdougm 				(void) printf(gettext("Group \"%s\" is already "
29886185db85Sdougm 						"enabled\n"),
29896185db85Sdougm 					argv[optind]);
29906185db85Sdougm 			    ret = SA_BUSY; /* already enabled */
29916185db85Sdougm 			} else {
29926185db85Sdougm 			    worklist = add_list(worklist, group, 0);
29936185db85Sdougm 			    if (verbose)
29946185db85Sdougm 				(void) printf(gettext("Enabling group "
29956185db85Sdougm 							"\"%s\"\n"),
29966185db85Sdougm 					argv[optind]);
29976185db85Sdougm 			}
29986185db85Sdougm 			if (state != NULL)
29996185db85Sdougm 			    sa_free_attr_string(state);
30006185db85Sdougm 		    } else {
30016185db85Sdougm 			ret = SA_NO_SUCH_GROUP;
30026185db85Sdougm 		    }
30036185db85Sdougm 		    optind++;
30046185db85Sdougm 		}
30056185db85Sdougm 	    } else {
3006549ec3ffSdougm 		for (group = sa_get_group(handle, NULL); group != NULL;
30076185db85Sdougm 		    group = sa_get_next_group(group)) {
30086185db85Sdougm 		    worklist = add_list(worklist, group, 0);
30096185db85Sdougm 		}
30106185db85Sdougm 	    }
30116185db85Sdougm 	    if (!dryrun && ret == SA_OK) {
3012549ec3ffSdougm 		ret = enable_all_groups(handle, worklist, 1, 0, NULL);
30136185db85Sdougm 	    }
30146185db85Sdougm 	    if (ret != SA_OK && ret != SA_BUSY)
30156185db85Sdougm 		(void) printf(gettext("Could not enable group: %s\n"),
30166185db85Sdougm 			sa_errorstr(ret));
30176185db85Sdougm 	    if (ret == SA_BUSY)
30186185db85Sdougm 		ret = SA_OK;
30196185db85Sdougm 	}
30206185db85Sdougm 	if (worklist != NULL)
30216185db85Sdougm 	    free_list(worklist);
30226185db85Sdougm 	if (dryrun && ret == SA_OK && !auth && verbose) {
30236185db85Sdougm 	    (void) printf(gettext("Command would fail: %s\n"),
30246185db85Sdougm 			sa_errorstr(SA_NO_PERMISSION));
30256185db85Sdougm 	}
30266185db85Sdougm 	return (ret);
30276185db85Sdougm }
30286185db85Sdougm 
30296185db85Sdougm /*
30306185db85Sdougm  * disable_group(group, setstate)
30316185db85Sdougm  *
30326185db85Sdougm  * disable all the shares in the specified group honoring the setstate
30336185db85Sdougm  * argument. This is a helper for disable_all_groups in order to
30346185db85Sdougm  * simplify regular and subgroup (zfs) disabling. Group has already
30356185db85Sdougm  * been checked for non-NULL.
30366185db85Sdougm  */
30376185db85Sdougm 
30386185db85Sdougm static int
30396185db85Sdougm disable_group(sa_group_t group)
30406185db85Sdougm {
30416185db85Sdougm 	sa_share_t share;
30426185db85Sdougm 	int ret = SA_OK;
30436185db85Sdougm 
30446185db85Sdougm 	for (share = sa_get_share(group, NULL);
30456185db85Sdougm 	    share != NULL && ret == SA_OK;
30466185db85Sdougm 	    share = sa_get_next_share(share)) {
30476185db85Sdougm 	    ret = sa_disable_share(share, NULL);
30486185db85Sdougm 	    if (ret == SA_NO_SUCH_PATH) {
30496185db85Sdougm 		/*
30506185db85Sdougm 		 * this is OK since the path is gone. we can't
30516185db85Sdougm 		 * re-share it anyway so no error.
30526185db85Sdougm 		 */
30536185db85Sdougm 		ret = SA_OK;
30546185db85Sdougm 	    }
30556185db85Sdougm 	}
30566185db85Sdougm 	return (ret);
30576185db85Sdougm }
30586185db85Sdougm 
30596185db85Sdougm 
30606185db85Sdougm /*
30616185db85Sdougm  * disable_all_groups(work, setstate)
30626185db85Sdougm  *
30636185db85Sdougm  * helper function that disables the shares in the list of groups
30646185db85Sdougm  * provided. It optionally marks the group as disabled. Used by both
30656185db85Sdougm  * enable and start subcommands.
30666185db85Sdougm  */
30676185db85Sdougm 
30686185db85Sdougm static int
3069549ec3ffSdougm disable_all_groups(sa_handle_t handle, struct list *work, int setstate)
30706185db85Sdougm {
30716185db85Sdougm 	int ret = SA_OK;
30726185db85Sdougm 	sa_group_t subgroup, group;
30736185db85Sdougm 
30746185db85Sdougm 	while (work != NULL && ret == SA_OK) {
30756185db85Sdougm 	    group = (sa_group_t)work->item;
30766185db85Sdougm 	    if (setstate)
30776185db85Sdougm 		ret = sa_set_group_attr(group, "state", "disabled");
30786185db85Sdougm 	    if (ret == SA_OK) {
30796185db85Sdougm 		char *name;
30806185db85Sdougm 		name = sa_get_group_attr(group, "name");
30816185db85Sdougm 		if (name != NULL && strcmp(name, "zfs") == 0) {
30826185db85Sdougm 		    /* need to get the sub-groups for stopping */
30836185db85Sdougm 		    for (subgroup = sa_get_sub_group(group); subgroup != NULL;
30846185db85Sdougm 			subgroup = sa_get_next_group(subgroup)) {
30856185db85Sdougm 			ret = disable_group(subgroup);
30866185db85Sdougm 		    }
30876185db85Sdougm 		} else {
30886185db85Sdougm 		    ret = disable_group(group);
30896185db85Sdougm 		}
30906185db85Sdougm 		/*
30916185db85Sdougm 		 * we don't want to "disable" since it won't come
30926185db85Sdougm 		 * up after a reboot.  The SMF framework should do
30936185db85Sdougm 		 * the right thing. On enable we do want to do
30946185db85Sdougm 		 * something.
30956185db85Sdougm 		 */
30966185db85Sdougm 	    }
30976185db85Sdougm 	    work = work->next;
30986185db85Sdougm 	}
30996185db85Sdougm 	if (ret == SA_OK)
3100549ec3ffSdougm 	    ret = sa_update_config(handle);
31016185db85Sdougm 	return (ret);
31026185db85Sdougm }
31036185db85Sdougm 
31046185db85Sdougm /*
31056185db85Sdougm  * sa_disable_group(flags, argc, argv)
31066185db85Sdougm  *
31076185db85Sdougm  * Implements the disable subcommand
31086185db85Sdougm  */
31096185db85Sdougm 
31106185db85Sdougm int
3111549ec3ffSdougm sa_disable_group(sa_handle_t handle, int flags, int argc, char *argv[])
31126185db85Sdougm {
31136185db85Sdougm 	int verbose = 0;
31146185db85Sdougm 	int dryrun = 0;
31156185db85Sdougm 	int all = 0;
31166185db85Sdougm 	int c;
31176185db85Sdougm 	int ret = SA_OK;
31186185db85Sdougm 	char *protocol;
31196185db85Sdougm 	char *state;
31206185db85Sdougm 	struct list *worklist = NULL;
31216185db85Sdougm 	int auth = 1;
31226185db85Sdougm 
31236185db85Sdougm 	while ((c = getopt(argc, argv, "?havn")) != EOF) {
31246185db85Sdougm 	    switch (c) {
31256185db85Sdougm 	    case 'a':
31266185db85Sdougm 		all = 1;
31276185db85Sdougm 		break;
31286185db85Sdougm 	    case 'n':
31296185db85Sdougm 		dryrun++;
31306185db85Sdougm 		break;
31316185db85Sdougm 	    case 'P':
31326185db85Sdougm 		protocol = optarg;
31336185db85Sdougm 		if (!sa_valid_protocol(protocol)) {
31346185db85Sdougm 		    (void) printf(gettext("Invalid protocol specified: %s\n"),
31356185db85Sdougm 					protocol);
31366185db85Sdougm 		    return (SA_INVALID_PROTOCOL);
31376185db85Sdougm 		}
31386185db85Sdougm 		break;
31396185db85Sdougm 	    case 'v':
31406185db85Sdougm 		verbose++;
31416185db85Sdougm 		break;
31426185db85Sdougm 	    default:
31436185db85Sdougm 	    case 'h':
31446185db85Sdougm 	    case '?':
31456185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
31466185db85Sdougm 				sa_get_usage(USAGE_DISABLE));
31476185db85Sdougm 		return (0);
31486185db85Sdougm 	    }
31496185db85Sdougm 	}
31506185db85Sdougm 
31516185db85Sdougm 	if (optind == argc && !all) {
31526185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
31536185db85Sdougm 				sa_get_usage(USAGE_DISABLE));
31546185db85Sdougm 		(void) printf(gettext("\tmust specify group\n"));
31556185db85Sdougm 		ret = SA_NO_SUCH_PATH;
31566185db85Sdougm 	} else {
31576185db85Sdougm 		sa_group_t group;
31586185db85Sdougm 		if (!all) {
31596185db85Sdougm 		    while (optind < argc) {
3160549ec3ffSdougm 			group = sa_get_group(handle, argv[optind]);
31616185db85Sdougm 			if (group != NULL) {
31626185db85Sdougm 			    auth &= check_authorizations(argv[optind], flags);
31636185db85Sdougm 			    state = sa_get_group_attr(group, "state");
31646185db85Sdougm 			    if (state == NULL ||
31656185db85Sdougm 				strcmp(state, "disabled") == 0) {
31666185db85Sdougm 				/* already disabled */
31676185db85Sdougm 				if (verbose)
31686185db85Sdougm 				    (void) printf(gettext("Group \"%s\" is "
31696185db85Sdougm 							"already disabled\n"),
31706185db85Sdougm 					    argv[optind]);
31716185db85Sdougm 				ret = SA_BUSY; /* already disable */
31726185db85Sdougm 			    } else {
31736185db85Sdougm 				worklist = add_list(worklist, group, 0);
31746185db85Sdougm 				if (verbose)
31756185db85Sdougm 				    (void) printf(gettext("Disabling group "
31766185db85Sdougm 							    "\"%s\"\n"),
31776185db85Sdougm 					    argv[optind]);
31786185db85Sdougm 			    }
31796185db85Sdougm 			    if (state != NULL)
31806185db85Sdougm 				sa_free_attr_string(state);
31816185db85Sdougm 			} else {
31826185db85Sdougm 			    ret = SA_NO_SUCH_GROUP;
31836185db85Sdougm 			}
31846185db85Sdougm 			optind++;
31856185db85Sdougm 		    }
31866185db85Sdougm 		} else {
3187549ec3ffSdougm 		    for (group = sa_get_group(handle, NULL); group != NULL;
31886185db85Sdougm 			    group = sa_get_next_group(group)) {
31896185db85Sdougm 			worklist = add_list(worklist, group, 0);
31906185db85Sdougm 		    }
31916185db85Sdougm 		}
31926185db85Sdougm 		if (ret == SA_OK && !dryrun) {
3193549ec3ffSdougm 			ret = disable_all_groups(handle, worklist, 1);
31946185db85Sdougm 		}
31956185db85Sdougm 		if (ret != SA_OK && ret != SA_BUSY)
31966185db85Sdougm 		    (void) printf(gettext("Could not disable group: %s\n"),
31976185db85Sdougm 				sa_errorstr(ret));
31986185db85Sdougm 		if (ret == SA_BUSY)
31996185db85Sdougm 		    ret = SA_OK;
32006185db85Sdougm 	}
32016185db85Sdougm 	if (worklist != NULL)
32026185db85Sdougm 	    free_list(worklist);
32036185db85Sdougm 	if (dryrun && ret == SA_OK && !auth && verbose) {
32046185db85Sdougm 	    (void) printf(gettext("Command would fail: %s\n"),
32056185db85Sdougm 			sa_errorstr(SA_NO_PERMISSION));
32066185db85Sdougm 	}
32076185db85Sdougm 	return (ret);
32086185db85Sdougm }
32096185db85Sdougm 
32106185db85Sdougm /*
32116185db85Sdougm  * sa_start_group(flags, argc, argv)
32126185db85Sdougm  *
32136185db85Sdougm  * Implements the start command.
32146185db85Sdougm  * This is similar to enable except it doesn't change the state
32156185db85Sdougm  * of the group(s) and only enables shares if the group is already
32166185db85Sdougm  * enabled.
32176185db85Sdougm  */
32186185db85Sdougm 
32196185db85Sdougm int
3220549ec3ffSdougm sa_start_group(sa_handle_t handle, int flags, int argc, char *argv[])
32216185db85Sdougm {
32226185db85Sdougm 	int verbose = 0;
32236185db85Sdougm 	int all = 0;
32246185db85Sdougm 	int c;
32256185db85Sdougm 	int ret = SMF_EXIT_OK;
32266185db85Sdougm 	char *protocol = NULL;
32276185db85Sdougm 	char *state;
32286185db85Sdougm 	struct list *worklist = NULL;
32296185db85Sdougm #ifdef lint
32306185db85Sdougm 	flags = flags;
32316185db85Sdougm #endif
32326185db85Sdougm 
32336185db85Sdougm 	while ((c = getopt(argc, argv, "?havP:")) != EOF) {
32346185db85Sdougm 	    switch (c) {
32356185db85Sdougm 	    case 'a':
32366185db85Sdougm 		all = 1;
32376185db85Sdougm 		break;
32386185db85Sdougm 	    case 'P':
32396185db85Sdougm 		protocol = optarg;
32406185db85Sdougm 		if (!sa_valid_protocol(protocol)) {
32416185db85Sdougm 		    (void) printf(gettext("Invalid protocol specified: %s\n"),
32426185db85Sdougm 				    protocol);
32436185db85Sdougm 		    return (SA_INVALID_PROTOCOL);
32446185db85Sdougm 		}
32456185db85Sdougm 		break;
32466185db85Sdougm 	    case 'v':
32476185db85Sdougm 		verbose++;
32486185db85Sdougm 		break;
32496185db85Sdougm 	    default:
32506185db85Sdougm 	    case 'h':
32516185db85Sdougm 	    case '?':
32526185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
32536185db85Sdougm 				sa_get_usage(USAGE_START));
32546185db85Sdougm 		return (SA_OK);
32556185db85Sdougm 	    }
32566185db85Sdougm 	}
32576185db85Sdougm 
32586185db85Sdougm 	if (optind == argc && !all) {
32596185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
32606185db85Sdougm 				sa_get_usage(USAGE_START));
32616185db85Sdougm 		ret = SMF_EXIT_ERR_FATAL;
32626185db85Sdougm 	} else {
32636185db85Sdougm 		sa_group_t group;
32646185db85Sdougm 
32656185db85Sdougm 		if (!all) {
32666185db85Sdougm 		    while (optind < argc) {
3267549ec3ffSdougm 			group = sa_get_group(handle, argv[optind]);
32686185db85Sdougm 			if (group != NULL) {
32696185db85Sdougm 			    state = sa_get_group_attr(group, "state");
32706185db85Sdougm 			    if (state == NULL ||
32716185db85Sdougm 				strcmp(state, "enabled") == 0) {
32726185db85Sdougm 				worklist = add_list(worklist, group, 0);
32736185db85Sdougm 				if (verbose)
32746185db85Sdougm 				    (void) printf(gettext("Starting group "
32756185db85Sdougm 								"\"%s\"\n"),
32766185db85Sdougm 					    argv[optind]);
32776185db85Sdougm 			    } else {
32786185db85Sdougm 				/*
32796185db85Sdougm 				 * determine if there are any
32806185db85Sdougm 				 * protocols.  if there aren't any,
32816185db85Sdougm 				 * then there isn't anything to do in
32826185db85Sdougm 				 * any case so no error.
32836185db85Sdougm 				 */
32846185db85Sdougm 				if (sa_get_optionset(group, protocol) != NULL) {
32856185db85Sdougm 				    ret = SMF_EXIT_OK;
32866185db85Sdougm 				}
32876185db85Sdougm 			    }
32886185db85Sdougm 			    if (state != NULL)
32896185db85Sdougm 				sa_free_attr_string(state);
32906185db85Sdougm 			}
32916185db85Sdougm 			optind++;
32926185db85Sdougm 		    }
32936185db85Sdougm 		} else {
3294549ec3ffSdougm 		    for (group = sa_get_group(handle, NULL); group != NULL;
32956185db85Sdougm 			    group = sa_get_next_group(group)) {
32966185db85Sdougm 			state = sa_get_group_attr(group, "state");
32976185db85Sdougm 			if (state == NULL || strcmp(state, "enabled") == 0)
32986185db85Sdougm 			    worklist = add_list(worklist, group, 0);
32996185db85Sdougm 			if (state != NULL)
33006185db85Sdougm 			    sa_free_attr_string(state);
33016185db85Sdougm 		    }
33026185db85Sdougm 		}
3303549ec3ffSdougm 		(void) enable_all_groups(handle, worklist, 0, 1, NULL);
33046185db85Sdougm 	}
33056185db85Sdougm 	if (worklist != NULL)
33066185db85Sdougm 	    free_list(worklist);
33076185db85Sdougm 	return (ret);
33086185db85Sdougm }
33096185db85Sdougm 
33106185db85Sdougm /*
33116185db85Sdougm  * sa_stop_group(flags, argc, argv)
33126185db85Sdougm  *
33136185db85Sdougm  * Implements the stop command.
33146185db85Sdougm  * This is similar to disable except it doesn't change the state
33156185db85Sdougm  * of the group(s) and only disables shares if the group is already
33166185db85Sdougm  * enabled.
33176185db85Sdougm  */
33186185db85Sdougm 
33196185db85Sdougm int
3320549ec3ffSdougm sa_stop_group(sa_handle_t handle, int flags, int argc, char *argv[])
33216185db85Sdougm {
33226185db85Sdougm 	int verbose = 0;
33236185db85Sdougm 	int all = 0;
33246185db85Sdougm 	int c;
33256185db85Sdougm 	int ret = SMF_EXIT_OK;
33266185db85Sdougm 	char *protocol = NULL;
33276185db85Sdougm 	char *state;
33286185db85Sdougm 	struct list *worklist = NULL;
33296185db85Sdougm #ifdef lint
33306185db85Sdougm 	flags = flags;
33316185db85Sdougm #endif
33326185db85Sdougm 
33336185db85Sdougm 	while ((c = getopt(argc, argv, "?havP:")) != EOF) {
33346185db85Sdougm 	    switch (c) {
33356185db85Sdougm 	    case 'a':
33366185db85Sdougm 		all = 1;
33376185db85Sdougm 		break;
33386185db85Sdougm 	    case 'P':
33396185db85Sdougm 		protocol = optarg;
33406185db85Sdougm 		if (!sa_valid_protocol(protocol)) {
33416185db85Sdougm 		    (void) printf(gettext("Invalid protocol specified: %s\n"),
33426185db85Sdougm 					protocol);
33436185db85Sdougm 		    return (SA_INVALID_PROTOCOL);
33446185db85Sdougm 		}
33456185db85Sdougm 		break;
33466185db85Sdougm 	    case 'v':
33476185db85Sdougm 		verbose++;
33486185db85Sdougm 		break;
33496185db85Sdougm 	    default:
33506185db85Sdougm 	    case 'h':
33516185db85Sdougm 	    case '?':
33526185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
33536185db85Sdougm 				sa_get_usage(USAGE_STOP));
33546185db85Sdougm 		return (0);
33556185db85Sdougm 	    }
33566185db85Sdougm 	}
33576185db85Sdougm 
33586185db85Sdougm 	if (optind == argc && !all) {
33596185db85Sdougm 		(void) printf(gettext("usage: %s\n"), sa_get_usage(USAGE_STOP));
33606185db85Sdougm 		ret = SMF_EXIT_ERR_FATAL;
33616185db85Sdougm 	} else {
33626185db85Sdougm 		sa_group_t group;
33636185db85Sdougm 		if (!all) {
33646185db85Sdougm 		    while (optind < argc) {
3365549ec3ffSdougm 			group = sa_get_group(handle, argv[optind]);
33666185db85Sdougm 			if (group != NULL) {
33676185db85Sdougm 			    state = sa_get_group_attr(group, "state");
33686185db85Sdougm 			    if (state == NULL ||
33696185db85Sdougm 				strcmp(state, "enabled") == 0) {
33706185db85Sdougm 				worklist = add_list(worklist, group, 0);
33716185db85Sdougm 				if (verbose)
33726185db85Sdougm 				    (void) printf(gettext("Stopping group "
33736185db85Sdougm 								"\"%s\"\n"),
33746185db85Sdougm 					    argv[optind]);
33756185db85Sdougm 			    } else {
33766185db85Sdougm 				ret = SMF_EXIT_OK;
33776185db85Sdougm 			    }
33786185db85Sdougm 			    if (state != NULL)
33796185db85Sdougm 				sa_free_attr_string(state);
33806185db85Sdougm 			}
33816185db85Sdougm 			optind++;
33826185db85Sdougm 		    }
33836185db85Sdougm 		} else {
3384549ec3ffSdougm 		    for (group = sa_get_group(handle, NULL); group != NULL;
33856185db85Sdougm 			    group = sa_get_next_group(group)) {
33866185db85Sdougm 			state = sa_get_group_attr(group, "state");
33876185db85Sdougm 			if (state == NULL || strcmp(state, "enabled") == 0)
33886185db85Sdougm 			    worklist = add_list(worklist, group, 0);
33896185db85Sdougm 			if (state != NULL)
33906185db85Sdougm 			    sa_free_attr_string(state);
33916185db85Sdougm 		    }
33926185db85Sdougm 		}
3393549ec3ffSdougm 		(void) disable_all_groups(handle, worklist, 0);
3394549ec3ffSdougm 		ret = sa_update_config(handle);
33956185db85Sdougm 	}
33966185db85Sdougm 	if (worklist != NULL)
33976185db85Sdougm 	    free_list(worklist);
33986185db85Sdougm 	return (ret);
33996185db85Sdougm }
34006185db85Sdougm 
34016185db85Sdougm /*
34026185db85Sdougm  * remove_all_options(share, proto)
34036185db85Sdougm  *
34046185db85Sdougm  * Removes all options on a share.
34056185db85Sdougm  */
34066185db85Sdougm 
34076185db85Sdougm static void
34086185db85Sdougm remove_all_options(sa_share_t share, char *proto)
34096185db85Sdougm {
34106185db85Sdougm 	sa_optionset_t optionset;
34116185db85Sdougm 	sa_security_t security;
34126185db85Sdougm 	sa_security_t prevsec = NULL;
34136185db85Sdougm 
34146185db85Sdougm 	optionset = sa_get_optionset(share, proto);
34156185db85Sdougm 	if (optionset != NULL)
34166185db85Sdougm 	    (void) sa_destroy_optionset(optionset);
34176185db85Sdougm 	for (security = sa_get_security(share, NULL, NULL);
34186185db85Sdougm 	    security != NULL;
34196185db85Sdougm 	    security = sa_get_next_security(security)) {
34206185db85Sdougm 	    char *type;
34216185db85Sdougm 		/*
34226185db85Sdougm 		 * we walk through the list.  prevsec keeps the
34236185db85Sdougm 		 * previous security so we can delete it without
34246185db85Sdougm 		 * destroying the list.
34256185db85Sdougm 		 */
34266185db85Sdougm 	    if (prevsec != NULL) {
34276185db85Sdougm 		/* remove the previously seen security */
34286185db85Sdougm 		(void) sa_destroy_security(prevsec);
34296185db85Sdougm 		/* set to NULL so we don't try multiple times */
34306185db85Sdougm 		prevsec = NULL;
34316185db85Sdougm 	    }
34326185db85Sdougm 	    type = sa_get_security_attr(security, "type");
34336185db85Sdougm 	    if (type != NULL) {
34346185db85Sdougm 		/*
34356185db85Sdougm 		 * if the security matches the specified protocol, we
34366185db85Sdougm 		 * want to remove it. prevsec holds it until either
34376185db85Sdougm 		 * the next pass or we fall out of the loop.
34386185db85Sdougm 		 */
34396185db85Sdougm 		if (strcmp(type, proto) == 0)
34406185db85Sdougm 		    prevsec = security;
34416185db85Sdougm 		sa_free_attr_string(type);
34426185db85Sdougm 	    }
34436185db85Sdougm 	}
34446185db85Sdougm 	/* in case there is one left */
34456185db85Sdougm 	if (prevsec != NULL)
34466185db85Sdougm 	    (void) sa_destroy_security(prevsec);
34476185db85Sdougm }
34486185db85Sdougm 
34496185db85Sdougm 
34506185db85Sdougm /*
34516185db85Sdougm  * for legacy support, we need to handle the old syntax. This is what
34526185db85Sdougm  * we get if sharemgr is called with the name "share" rather than
34536185db85Sdougm  * sharemgr.
34546185db85Sdougm  */
34556185db85Sdougm 
34566185db85Sdougm static int
34576185db85Sdougm format_legacy_path(char *buff, int buffsize, char *proto, char *cmd)
34586185db85Sdougm {
34596185db85Sdougm 	int err;
34606185db85Sdougm 
34616185db85Sdougm 	err = snprintf(buff, buffsize, "/usr/lib/fs/%s/%s", proto, cmd);
34626185db85Sdougm 	if (err > buffsize)
34636185db85Sdougm 	    return (-1);
34646185db85Sdougm 	return (0);
34656185db85Sdougm }
34666185db85Sdougm 
34676185db85Sdougm 
34686185db85Sdougm /*
34696185db85Sdougm  * check_legacy_cmd(proto, cmd)
34706185db85Sdougm  *
34716185db85Sdougm  * Check to see if the cmd exists in /usr/lib/fs/<proto>/<cmd> and is
34726185db85Sdougm  * executable.
34736185db85Sdougm  */
34746185db85Sdougm 
34756185db85Sdougm static int
34766185db85Sdougm check_legacy_cmd(char *path)
34776185db85Sdougm {
34786185db85Sdougm 	struct stat st;
34796185db85Sdougm 	int ret = 0;
34806185db85Sdougm 
34816185db85Sdougm 	if (stat(path, &st) == 0) {
34826185db85Sdougm 	    if (S_ISREG(st.st_mode) && st.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH))
34836185db85Sdougm 		ret = 1;
34846185db85Sdougm 	}
34856185db85Sdougm 	return (ret);
34866185db85Sdougm }
34876185db85Sdougm 
34886185db85Sdougm /*
34896185db85Sdougm  * run_legacy_command(proto, cmd, argv)
34906185db85Sdougm  *
34916185db85Sdougm  * we know the command exists, so attempt to execute it with all the
34926185db85Sdougm  * arguments. This implements full legacy share support for those
34936185db85Sdougm  * protocols that don't have plugin providers.
34946185db85Sdougm  */
34956185db85Sdougm 
34966185db85Sdougm static int
34976185db85Sdougm run_legacy_command(char *path, char *argv[])
34986185db85Sdougm {
34996185db85Sdougm 	int ret;
35006185db85Sdougm 
35016185db85Sdougm 	ret = execv(path, argv);
35026185db85Sdougm 	if (ret < 0) {
35036185db85Sdougm 	    switch (errno) {
35046185db85Sdougm 	    case EACCES:
35056185db85Sdougm 		ret = SA_NO_PERMISSION;
35066185db85Sdougm 		break;
35076185db85Sdougm 	    default:
35086185db85Sdougm 		ret = SA_SYSTEM_ERR;
35096185db85Sdougm 		break;
35106185db85Sdougm 	    }
35116185db85Sdougm 	}
35126185db85Sdougm 	return (ret);
35136185db85Sdougm }
35146185db85Sdougm 
35156185db85Sdougm /*
3516f345c0beSdougm  * out_share(out, group, proto)
35176185db85Sdougm  *
35186185db85Sdougm  * Display the share information in the format that the "share"
35196185db85Sdougm  * command has traditionally used.
35206185db85Sdougm  */
35216185db85Sdougm 
35226185db85Sdougm static void
3523f345c0beSdougm out_share(FILE *out, sa_group_t group, char *proto)
35246185db85Sdougm {
35256185db85Sdougm 	sa_share_t share;
35266185db85Sdougm 	char resfmt[128];
35276185db85Sdougm 
35286185db85Sdougm 	for (share = sa_get_share(group, NULL); share != NULL;
35296185db85Sdougm 		share = sa_get_next_share(share)) {
35306185db85Sdougm 	    char *path;
35316185db85Sdougm 	    char *type;
35326185db85Sdougm 	    char *resource;
35336185db85Sdougm 	    char *description;
35346185db85Sdougm 	    char *groupname;
35356185db85Sdougm 	    char *sharedstate;
35366185db85Sdougm 	    int shared = 1;
35376185db85Sdougm 	    char *soptions;
35386185db85Sdougm 
35396185db85Sdougm 	    sharedstate = sa_get_share_attr(share, "shared");
35406185db85Sdougm 	    path = sa_get_share_attr(share, "path");
35416185db85Sdougm 	    type = sa_get_share_attr(share, "type");
35426185db85Sdougm 	    resource = sa_get_share_attr(share, "resource");
35436185db85Sdougm 	    groupname = sa_get_group_attr(group, "name");
35446185db85Sdougm 
35456185db85Sdougm 	    if (groupname != NULL && strcmp(groupname, "default") == 0) {
35466185db85Sdougm 		sa_free_attr_string(groupname);
35476185db85Sdougm 		groupname = NULL;
35486185db85Sdougm 	    }
35496185db85Sdougm 	    description = sa_get_share_description(share);
3550f345c0beSdougm 
3551f345c0beSdougm 	    /* want the sharetab version if it exists */
3552f345c0beSdougm 	    soptions = sa_get_share_attr(share, "shareopts");
35536185db85Sdougm 
35546185db85Sdougm 	    if (sharedstate == NULL)
35556185db85Sdougm 		shared = 0;
35566185db85Sdougm 
3557f345c0beSdougm 	    if (soptions == NULL)
35586185db85Sdougm 		soptions = sa_proto_legacy_format(proto, share, 1);
35596185db85Sdougm 
35606185db85Sdougm 	    if (shared) {
3561f345c0beSdougm 		/* only active shares go here */
35626185db85Sdougm 		(void) snprintf(resfmt, sizeof (resfmt), "%s%s%s",
35636185db85Sdougm 			resource != NULL ? resource : "-",
35646185db85Sdougm 			groupname != NULL ? "@" : "",
35656185db85Sdougm 			groupname != NULL ? groupname : "");
35666185db85Sdougm 		(void) fprintf(out, "%-14.14s  %s   %s   \"%s\"  \n",
35676185db85Sdougm 			resfmt,
35686185db85Sdougm 			path,
35696185db85Sdougm 			(soptions != NULL && strlen(soptions) > 0) ?
35706185db85Sdougm 					soptions : "rw",
35716185db85Sdougm 			(description != NULL) ? description : "");
35726185db85Sdougm 	    }
35736185db85Sdougm 
35746185db85Sdougm 	    if (path != NULL)
35756185db85Sdougm 		sa_free_attr_string(path);
35766185db85Sdougm 	    if (type != NULL)
35776185db85Sdougm 		sa_free_attr_string(type);
35786185db85Sdougm 	    if (resource != NULL)
35796185db85Sdougm 		sa_free_attr_string(resource);
35806185db85Sdougm 	    if (groupname != NULL)
35816185db85Sdougm 		sa_free_attr_string(groupname);
35826185db85Sdougm 	    if (description != NULL)
35836185db85Sdougm 		sa_free_share_description(description);
35846185db85Sdougm 	    if (sharedstate != NULL)
35856185db85Sdougm 		sa_free_attr_string(sharedstate);
3586f345c0beSdougm 	    if (soptions != NULL)
35876185db85Sdougm 		sa_format_free(soptions);
35886185db85Sdougm 	}
35896185db85Sdougm }
35906185db85Sdougm 
35916185db85Sdougm /*
35926185db85Sdougm  * output_legacy_file(out, proto)
35936185db85Sdougm  *
35946185db85Sdougm  * Walk all of the groups for the specified protocol and call
35956185db85Sdougm  * out_share() to format and write in the format displayed by the
35966185db85Sdougm  * "share" command with no arguments.
35976185db85Sdougm  */
35986185db85Sdougm 
35996185db85Sdougm static void
3600549ec3ffSdougm output_legacy_file(FILE *out, char *proto, sa_handle_t handle)
36016185db85Sdougm {
36026185db85Sdougm 	sa_group_t group;
36036185db85Sdougm 
3604549ec3ffSdougm 	for (group = sa_get_group(handle, NULL); group != NULL;
36056185db85Sdougm 		group = sa_get_next_group(group)) {
36066185db85Sdougm 	    char *options;
36076185db85Sdougm 	    char *zfs;
36086185db85Sdougm 
36096185db85Sdougm 		/*
36106185db85Sdougm 		 * get default options preformated, being careful to
36116185db85Sdougm 		 * handle legacy shares differently from new style
36126185db85Sdougm 		 * shares. Legacy share have options on the share.
36136185db85Sdougm 		 */
36146185db85Sdougm 
36156185db85Sdougm 	    zfs = sa_get_group_attr(group, "zfs");
36166185db85Sdougm 	    if (zfs != NULL) {
36176185db85Sdougm 		sa_group_t zgroup;
36186185db85Sdougm 		sa_free_attr_string(zfs);
36196185db85Sdougm 		options = sa_proto_legacy_format(proto, group, 1);
36206185db85Sdougm 		for (zgroup = sa_get_sub_group(group); zgroup != NULL;
36216185db85Sdougm 		    zgroup = sa_get_next_group(zgroup)) {
36226185db85Sdougm 
36236185db85Sdougm 		    /* got a group, so display it */
3624f345c0beSdougm 		    out_share(out, zgroup, proto);
36256185db85Sdougm 		}
36266185db85Sdougm 	    } else {
36276185db85Sdougm 		options = sa_proto_legacy_format(proto, group, 1);
3628f345c0beSdougm 		out_share(out, group, proto);
36296185db85Sdougm 	    }
36306185db85Sdougm 	    if (options != NULL)
36316185db85Sdougm 		free(options);
36326185db85Sdougm 	}
36336185db85Sdougm }
36346185db85Sdougm 
36356185db85Sdougm int
3636549ec3ffSdougm sa_legacy_share(sa_handle_t handle, int flags, int argc, char *argv[])
36376185db85Sdougm {
36386185db85Sdougm 	char *protocol = "nfs";
36396185db85Sdougm 	char *options = NULL;
36406185db85Sdougm 	char *description = NULL;
36416185db85Sdougm 	char *groupname = NULL;
36426185db85Sdougm 	char *sharepath = NULL;
36436185db85Sdougm 	char *resource = NULL;
36446185db85Sdougm 	char *groupstatus = NULL;
36456185db85Sdougm 	int persist = SA_SHARE_TRANSIENT;
36466185db85Sdougm 	int argsused = 0;
36476185db85Sdougm 	int c;
36486185db85Sdougm 	int ret = SA_OK;
36496185db85Sdougm 	int zfs = 0;
36506185db85Sdougm 	int true_legacy = 0;
36516185db85Sdougm 	int curtype = SA_SHARE_TRANSIENT;
36526185db85Sdougm 	char cmd[MAXPATHLEN];
36536185db85Sdougm #ifdef lint
36546185db85Sdougm 	flags = flags;
36556185db85Sdougm #endif
36566185db85Sdougm 
36576185db85Sdougm 	while ((c = getopt(argc, argv, "?hF:d:o:p")) != EOF) {
36586185db85Sdougm 	    switch (c) {
36596185db85Sdougm 	    case 'd':
36606185db85Sdougm 		description = optarg;
36616185db85Sdougm 		argsused++;
36626185db85Sdougm 		break;
36636185db85Sdougm 	    case 'F':
36646185db85Sdougm 		protocol = optarg;
36656185db85Sdougm 		if (!sa_valid_protocol(protocol)) {
36666185db85Sdougm 		    if (format_legacy_path(cmd, MAXPATHLEN,
36676185db85Sdougm 			    protocol, "share") == 0 && check_legacy_cmd(cmd)) {
36686185db85Sdougm 			true_legacy++;
36696185db85Sdougm 		    } else {
36706185db85Sdougm 			(void) fprintf(stderr,
36716185db85Sdougm 					gettext("Invalid protocol specified:"
36726185db85Sdougm 						"%s\n"),
36736185db85Sdougm 				protocol);
36746185db85Sdougm 			return (SA_INVALID_PROTOCOL);
36756185db85Sdougm 		    }
36766185db85Sdougm 		}
36776185db85Sdougm 		break;
36786185db85Sdougm 	    case 'o':
36796185db85Sdougm 		options = optarg;
36806185db85Sdougm 		argsused++;
36816185db85Sdougm 		break;
36826185db85Sdougm 	    case 'p':
36836185db85Sdougm 		persist = SA_SHARE_PERMANENT;
36846185db85Sdougm 		argsused++;
36856185db85Sdougm 		break;
36866185db85Sdougm 	    case 'h':
36876185db85Sdougm 	    case '?':
36886185db85Sdougm 	    default:
36896185db85Sdougm 		(void) fprintf(stderr, gettext("usage: %s\n"),
36906185db85Sdougm 						sa_get_usage(USAGE_SHARE));
36916185db85Sdougm 		return (SA_OK);
36926185db85Sdougm 	    }
36936185db85Sdougm 	}
36946185db85Sdougm 
36956185db85Sdougm 	/* have the info so construct what is needed */
36966185db85Sdougm 	if (!argsused && optind == argc) {
36976185db85Sdougm 	    /* display current info in share format */
3698549ec3ffSdougm 	    (void) output_legacy_file(stdout, "nfs", handle);
36996185db85Sdougm 	} else {
37006185db85Sdougm 	    sa_group_t group = NULL;
37016185db85Sdougm 	    sa_share_t share;
37026185db85Sdougm 	    char dir[MAXPATHLEN];
37036185db85Sdougm 
37046185db85Sdougm 	    /* we are modifying the configuration */
37056185db85Sdougm 	    if (optind == argc) {
37066185db85Sdougm 		(void) fprintf(stderr, gettext("usage: %s\n"),
37076185db85Sdougm 				sa_get_usage(USAGE_SHARE));
37086185db85Sdougm 		return (SA_LEGACY_ERR);
37096185db85Sdougm 	    }
37106185db85Sdougm 
37116185db85Sdougm 	    if (true_legacy) {
37126185db85Sdougm 		/* if still using legacy share/unshare, exec it */
37136185db85Sdougm 		ret = run_legacy_command(cmd, argv);
37146185db85Sdougm 		return (ret);
37156185db85Sdougm 	    }
37166185db85Sdougm 
37176185db85Sdougm 	    sharepath = argv[optind++];
37186185db85Sdougm 	    if (optind < argc) {
37196185db85Sdougm 		resource = argv[optind];
37206185db85Sdougm 		groupname = strchr(resource, '@');
37216185db85Sdougm 		if (groupname != NULL)
37226185db85Sdougm 		    *groupname++ = '\0';
37236185db85Sdougm 	    }
37246185db85Sdougm 	    if (realpath(sharepath, dir) == NULL)
37256185db85Sdougm 		ret = SA_BAD_PATH;
37266185db85Sdougm 	    else
37276185db85Sdougm 		sharepath = dir;
37286185db85Sdougm 	    if (ret == SA_OK) {
3729549ec3ffSdougm 		share = sa_find_share(handle, sharepath);
37306185db85Sdougm 	    } else {
37316185db85Sdougm 		share = NULL;
37326185db85Sdougm 	    }
37336185db85Sdougm 	    if (groupname != NULL) {
37346185db85Sdougm 		    ret = SA_NOT_ALLOWED;
37356185db85Sdougm 	    } else if (ret == SA_OK) {
37366185db85Sdougm 		char *legacygroup = "default";
37376185db85Sdougm 		/*
37386185db85Sdougm 		 * the legacy group is always present and zfs groups
37396185db85Sdougm 		 * come and go.  zfs shares may be in sub-groups and
37406185db85Sdougm 		 * the zfs share will already be in that group so it
37416185db85Sdougm 		 * isn't an error.
37426185db85Sdougm 		 */
37436185db85Sdougm 		if (share != NULL) {
37446185db85Sdougm 		/*
37456185db85Sdougm 		 * if the share exists, then make sure it is one we
37466185db85Sdougm 		 * want to handle.
37476185db85Sdougm 		 */
37486185db85Sdougm 		    group = sa_get_parent_group(share);
37496185db85Sdougm 		} else {
3750549ec3ffSdougm 		    group = sa_get_group(handle, legacygroup);
37516185db85Sdougm 		}
37526185db85Sdougm 		if (group != NULL) {
37536185db85Sdougm 		    groupstatus = group_status(group);
37546185db85Sdougm 		    if (share == NULL) {
37556185db85Sdougm 			share = sa_add_share(group, sharepath, persist, &ret);
37566185db85Sdougm 			if (share == NULL && ret == SA_DUPLICATE_NAME) {
37576185db85Sdougm 			    /* could be a ZFS path being started */
3758549ec3ffSdougm 			    if (sa_zfs_is_shared(handle, sharepath)) {
37596185db85Sdougm 				ret = SA_OK;
3760549ec3ffSdougm 				group = sa_get_group(handle, "zfs");
37616185db85Sdougm 				if (group == NULL) {
37626185db85Sdougm 				    /* this shouldn't happen */
37636185db85Sdougm 				    ret = SA_CONFIG_ERR;
37646185db85Sdougm 				}
37656185db85Sdougm 				if (group != NULL) {
37666185db85Sdougm 				    share = sa_add_share(group, sharepath,
37676185db85Sdougm 							    persist, &ret);
37686185db85Sdougm 				}
37696185db85Sdougm 			    }
37706185db85Sdougm 			}
37716185db85Sdougm 		    } else {
377293a6f655Sdougm 			char *type;
37736185db85Sdougm 			/*
37746185db85Sdougm 			 * may want to change persist state, but the
377593a6f655Sdougm 			 * important thing is to change options. We
377693a6f655Sdougm 			 * need to change them regardless of the
377793a6f655Sdougm 			 * source.
37786185db85Sdougm 			 */
3779549ec3ffSdougm 			if (sa_zfs_is_shared(handle, sharepath)) {
378093a6f655Sdougm 			    zfs = 1;
378193a6f655Sdougm 			}
37826185db85Sdougm 			remove_all_options(share, protocol);
37836185db85Sdougm 			type = sa_get_share_attr(share, "type");
37846185db85Sdougm 			if (type != NULL &&
37856185db85Sdougm 			    strcmp(type, "transient") != 0) {
37866185db85Sdougm 			    curtype = SA_SHARE_PERMANENT;
37876185db85Sdougm 			}
37886185db85Sdougm 			if (type != NULL)
37896185db85Sdougm 			    sa_free_attr_string(type);
37906185db85Sdougm 			if (curtype != persist) {
37916185db85Sdougm 			    (void) sa_set_share_attr(share, "type",
37926185db85Sdougm 					persist == SA_SHARE_PERMANENT ?
37936185db85Sdougm 						"persist" : "transient");
37946185db85Sdougm 			}
37956185db85Sdougm 		    }
37966185db85Sdougm 		    /* have a group to hold this share path */
37976185db85Sdougm 		    if (ret == SA_OK && options != NULL &&
37986185db85Sdougm 			strlen(options) > 0) {
37996185db85Sdougm 			ret = sa_parse_legacy_options(share,
38006185db85Sdougm 							options,
38016185db85Sdougm 							protocol);
38026185db85Sdougm 		    }
380393a6f655Sdougm 		    if (!zfs) {
380493a6f655Sdougm 			/*
380593a6f655Sdougm 			 * zfs shares never have resource or
380693a6f655Sdougm 			 * description and we can't store the values
380793a6f655Sdougm 			 * so don't try.
380893a6f655Sdougm 			 */
38096185db85Sdougm 			if (ret == SA_OK && description != NULL)
38106185db85Sdougm 			    ret = sa_set_share_description(share, description);
38116185db85Sdougm 			if (ret == SA_OK && resource != NULL)
38126185db85Sdougm 			    ret = sa_set_share_attr(share, "resource",
38136185db85Sdougm 						    resource);
38146185db85Sdougm 		    }
38156185db85Sdougm 		    if (ret == SA_OK) {
38166185db85Sdougm 			if (strcmp(groupstatus, "enabled") == 0)
38176185db85Sdougm 			    ret = sa_enable_share(share, protocol);
38186185db85Sdougm 			if (ret == SA_OK && persist == SA_SHARE_PERMANENT) {
38196185db85Sdougm 			    (void) sa_update_legacy(share, protocol);
38206185db85Sdougm 			}
38216185db85Sdougm 			if (ret == SA_OK)
3822549ec3ffSdougm 			    ret = sa_update_config(handle);
38236185db85Sdougm 		    }
38246185db85Sdougm 		} else {
38256185db85Sdougm 		    ret = SA_SYSTEM_ERR;
38266185db85Sdougm 		}
38276185db85Sdougm 	    }
38286185db85Sdougm 	}
38296185db85Sdougm 	if (ret != SA_OK) {
38306185db85Sdougm 	    (void) fprintf(stderr, gettext("Could not share: %s: %s\n"),
38316185db85Sdougm 				sharepath, sa_errorstr(ret));
38326185db85Sdougm 	    ret = SA_LEGACY_ERR;
38336185db85Sdougm 
38346185db85Sdougm 	}
38356185db85Sdougm 	return (ret);
38366185db85Sdougm }
38376185db85Sdougm 
38386185db85Sdougm /*
38396185db85Sdougm  * sa_legacy_unshare(flags, argc, argv)
38406185db85Sdougm  *
38416185db85Sdougm  * Implements the original unshare command.
38426185db85Sdougm  */
38436185db85Sdougm 
38446185db85Sdougm int
3845549ec3ffSdougm sa_legacy_unshare(sa_handle_t handle, int flags, int argc, char *argv[])
38466185db85Sdougm {
38476185db85Sdougm 	char *protocol = "nfs"; /* for now */
38486185db85Sdougm 	char *options = NULL;
38496185db85Sdougm 	char *sharepath = NULL;
38506185db85Sdougm 	int persist = SA_SHARE_TRANSIENT;
38516185db85Sdougm 	int argsused = 0;
38526185db85Sdougm 	int c;
38536185db85Sdougm 	int ret = SA_OK;
38546185db85Sdougm 	int true_legacy = 0;
38556185db85Sdougm 	char cmd[MAXPATHLEN];
38566185db85Sdougm #ifdef lint
38576185db85Sdougm 	flags = flags;
38586185db85Sdougm 	options = options;
38596185db85Sdougm #endif
38606185db85Sdougm 
38616185db85Sdougm 	while ((c = getopt(argc, argv, "?hF:o:p")) != EOF) {
38626185db85Sdougm 	    switch (c) {
38636185db85Sdougm 	    case 'h':
38646185db85Sdougm 	    case '?':
38656185db85Sdougm 		break;
38666185db85Sdougm 	    case 'F':
38676185db85Sdougm 		protocol = optarg;
38686185db85Sdougm 		if (!sa_valid_protocol(protocol)) {
38696185db85Sdougm 		    if (format_legacy_path(cmd, MAXPATHLEN,
38706185db85Sdougm 						protocol, "unshare") == 0 &&
38716185db85Sdougm 			check_legacy_cmd(cmd)) {
38726185db85Sdougm 			true_legacy++;
38736185db85Sdougm 		    } else {
38746185db85Sdougm 			(void) printf(gettext("Invalid file system name\n"));
38756185db85Sdougm 			return (SA_INVALID_PROTOCOL);
38766185db85Sdougm 		    }
38776185db85Sdougm 		}
38786185db85Sdougm 		break;
38796185db85Sdougm 	    case 'o':
38806185db85Sdougm 		options = optarg;
38816185db85Sdougm 		argsused++;
38826185db85Sdougm 		break;
38836185db85Sdougm 	    case 'p':
38846185db85Sdougm 		persist = SA_SHARE_PERMANENT;
38856185db85Sdougm 		argsused++;
38866185db85Sdougm 		break;
38876185db85Sdougm 	    default:
38886185db85Sdougm 		(void) printf(gettext("usage: %s\n"),
38896185db85Sdougm 				sa_get_usage(USAGE_UNSHARE));
38906185db85Sdougm 		return (SA_OK);
38916185db85Sdougm 	    }
38926185db85Sdougm 	}
38936185db85Sdougm 
38946185db85Sdougm 	/* have the info so construct what is needed */
38956185db85Sdougm 	if (optind == argc || (optind + 1) < argc) {
38966185db85Sdougm 	    ret = SA_SYNTAX_ERR;
38976185db85Sdougm 	} else {
38986185db85Sdougm 	    sa_share_t share;
38996185db85Sdougm 	    char dir[MAXPATHLEN];
39006185db85Sdougm 	    if (true_legacy) {
39016185db85Sdougm 		/* if still using legacy share/unshare, exec it */
39026185db85Sdougm 		ret = run_legacy_command(cmd, argv);
39036185db85Sdougm 		return (ret);
39046185db85Sdougm 	    }
3905a99982a7Sdougm 		/*
3906a99982a7Sdougm 		 * Find the path in the internal configuration. If it
3907a99982a7Sdougm 		 * isn't found, attempt to resolve the path via
3908a99982a7Sdougm 		 * realpath() and try again.
3909a99982a7Sdougm 		 */
39106185db85Sdougm 	    sharepath = argv[optind++];
3911549ec3ffSdougm 	    share = sa_find_share(handle, sharepath);
3912a99982a7Sdougm 	    if (share == NULL) {
39136185db85Sdougm 		if (realpath(sharepath, dir) == NULL) {
39146185db85Sdougm 		    ret = SA_NO_SUCH_PATH;
39156185db85Sdougm 		} else {
3916549ec3ffSdougm 		    share = sa_find_share(handle, dir);
3917a99982a7Sdougm 		}
3918a99982a7Sdougm 	    }
39196185db85Sdougm 	    if (share != NULL) {
39206185db85Sdougm 		ret = sa_disable_share(share, protocol);
3921a99982a7Sdougm 		/*
3922a99982a7Sdougm 		 * Errors are ok and removal should still occur. The
3923a99982a7Sdougm 		 * legacy unshare is more forgiving of errors than the
3924a99982a7Sdougm 		 * remove-share subcommand which may need the force
3925a99982a7Sdougm 		 * flag set for some error conditions. That is, the
3926a99982a7Sdougm 		 * "unshare" command will always unshare if it can
3927a99982a7Sdougm 		 * while "remove-share" might require the force option.
3928a99982a7Sdougm 		 */
3929a99982a7Sdougm 		if (persist == SA_SHARE_PERMANENT) {
39306185db85Sdougm 		    ret = sa_remove_share(share);
3931a99982a7Sdougm 		    if (ret == SA_OK)
3932549ec3ffSdougm 			ret = sa_update_config(handle);
39336185db85Sdougm 		}
39346185db85Sdougm 	    } else {
39356185db85Sdougm 		ret = SA_NOT_SHARED;
39366185db85Sdougm 	    }
39376185db85Sdougm 	}
39386185db85Sdougm 	switch (ret) {
39396185db85Sdougm 	default:
39406185db85Sdougm 	    (void) printf("%s: %s\n", sharepath, sa_errorstr(ret));
39416185db85Sdougm 	    ret = SA_LEGACY_ERR;
39426185db85Sdougm 	    break;
39436185db85Sdougm 	case SA_SYNTAX_ERR:
39446185db85Sdougm 	    (void) printf(gettext("usage: %s\n"),
39456185db85Sdougm 				sa_get_usage(USAGE_UNSHARE));
39466185db85Sdougm 	    break;
39476185db85Sdougm 	case SA_OK:
39486185db85Sdougm 	    break;
39496185db85Sdougm 	}
39506185db85Sdougm 	return (ret);
39516185db85Sdougm }
39526185db85Sdougm 
39536185db85Sdougm /*
39546185db85Sdougm  * common commands that implement the sub-commands used by all
39556185db85Sdougm  * protcols. The entries are found via the lookup command
39566185db85Sdougm  */
39576185db85Sdougm 
39586185db85Sdougm static sa_command_t commands[] = {
39596185db85Sdougm 	{"add-share", 0, sa_addshare, USAGE_ADD_SHARE, SVC_SET},
39606185db85Sdougm 	{"create", 0, sa_create, USAGE_CREATE, SVC_SET|SVC_ACTION},
39616185db85Sdougm 	{"delete", 0, sa_delete, USAGE_DELETE, SVC_SET|SVC_ACTION},
39626185db85Sdougm 	{"disable", 0, sa_disable_group, USAGE_DISABLE, SVC_SET|SVC_ACTION},
39636185db85Sdougm 	{"enable", 0, sa_enable_group, USAGE_ENABLE, SVC_SET|SVC_ACTION},
39646185db85Sdougm 	{"list", 0, sa_list, USAGE_LIST},
39656185db85Sdougm 	{"move-share", 0, sa_moveshare, USAGE_MOVE_SHARE, SVC_SET},
39666185db85Sdougm 	{"remove-share", 0, sa_removeshare, USAGE_REMOVE_SHARE, SVC_SET},
39676185db85Sdougm 	{"set", 0, sa_set, USAGE_SET, SVC_SET},
39686185db85Sdougm 	{"set-share", 0, sa_set_share, USAGE_SET_SHARE, SVC_SET},
39696185db85Sdougm 	{"show", 0, sa_show, USAGE_SHOW},
39706185db85Sdougm 	{"share", 0, sa_legacy_share, USAGE_SHARE, SVC_SET|SVC_ACTION},
39716185db85Sdougm 	{"start", CMD_NODISPLAY, sa_start_group, USAGE_START,
39726185db85Sdougm 		SVC_SET|SVC_ACTION},
39736185db85Sdougm 	{"stop", CMD_NODISPLAY, sa_stop_group, USAGE_STOP, SVC_SET|SVC_ACTION},
39746185db85Sdougm 	{"unset", 0, sa_unset, USAGE_UNSET, SVC_SET},
39756185db85Sdougm 	{"unshare", 0, sa_legacy_unshare, USAGE_UNSHARE, SVC_SET|SVC_ACTION},
39766185db85Sdougm 	{NULL, 0, NULL, NULL}
39776185db85Sdougm };
39786185db85Sdougm 
39796185db85Sdougm static char *
39806185db85Sdougm sa_get_usage(sa_usage_t index)
39816185db85Sdougm {
39826185db85Sdougm 	char *ret = NULL;
39836185db85Sdougm 	switch (index) {
39846185db85Sdougm 	case USAGE_ADD_SHARE:
39856185db85Sdougm 	    ret = gettext("add-share [-nth] [-r resource-name] "
39866185db85Sdougm 			    "[-d \"description text\"] -s sharepath group");
39876185db85Sdougm 	    break;
39886185db85Sdougm 	case USAGE_CREATE:
39896185db85Sdougm 	    ret = gettext("create [-nvh] [-P proto [-p property=value]] group");
39906185db85Sdougm 	    break;
39916185db85Sdougm 	case USAGE_DELETE:
39926185db85Sdougm 	    ret = gettext("delete [-nvh] [-P proto] [-f] group");
39936185db85Sdougm 	    break;
39946185db85Sdougm 	case USAGE_DISABLE:
39956185db85Sdougm 	    ret = gettext("disable [-nvh] {-a | group ...}");
39966185db85Sdougm 	    break;
39976185db85Sdougm 	case USAGE_ENABLE:
39986185db85Sdougm 	    ret = gettext("enable [-nvh] {-a | group ...}");
39996185db85Sdougm 	    break;
40006185db85Sdougm 	case USAGE_LIST:
40016185db85Sdougm 	    ret = gettext("list [-vh] [-P proto]");
40026185db85Sdougm 	    break;
40036185db85Sdougm 	case USAGE_MOVE_SHARE:
40046185db85Sdougm 	    ret = gettext("move-share [-nvh] -s sharepath destination-group");
40056185db85Sdougm 	    break;
40066185db85Sdougm 	case USAGE_REMOVE_SHARE:
40076185db85Sdougm 	    ret = gettext("remove-share [-fnvh] -s sharepath group");
40086185db85Sdougm 	    break;
40096185db85Sdougm 	case USAGE_SET:
40106185db85Sdougm 	    ret = gettext("set [-nvh] -P proto [-S optspace] "
40116185db85Sdougm 				"[-p property=value]* [-s sharepath] group");
40126185db85Sdougm 	    break;
40136185db85Sdougm 	case USAGE_SET_SECURITY:
40146185db85Sdougm 	    ret = gettext("set-security [-nvh] -P proto -S security-type "
40156185db85Sdougm 			    "[-p property=value]* group");
40166185db85Sdougm 	    break;
40176185db85Sdougm 	case USAGE_SET_SHARE:
40186185db85Sdougm 	    ret = gettext("set-share [-nh] [-r resource] "
40196185db85Sdougm 			    "[-d \"description text\"] -s sharepath group");
40206185db85Sdougm 	    break;
40216185db85Sdougm 	case USAGE_SHOW:
40226185db85Sdougm 	    ret = gettext("show [-pvxh] [-P proto] [group ...]");
40236185db85Sdougm 	    break;
40246185db85Sdougm 	case USAGE_SHARE:
40256185db85Sdougm 	    ret = gettext("share [-F fstype] [-p] [-o optionlist]"
40266185db85Sdougm 			    "[-d description] [pathname [resourcename]]");
40276185db85Sdougm 	    break;
40286185db85Sdougm 	case USAGE_START:
40296185db85Sdougm 	    ret = gettext("start [-vh] [-P proto] {-a | group ...}");
40306185db85Sdougm 	    break;
40316185db85Sdougm 	case USAGE_STOP:
40326185db85Sdougm 	    ret = gettext("stop [-vh] [-P proto] {-a | group ...}");
40336185db85Sdougm 	    break;
40346185db85Sdougm 	case USAGE_UNSET:
40356185db85Sdougm 	    ret = gettext("unset [-nvh] -P proto [-S optspace] "
40366185db85Sdougm 			    "[-p property]* group");
40376185db85Sdougm 	    break;
40386185db85Sdougm 	case USAGE_UNSET_SECURITY:
40396185db85Sdougm 	    ret = gettext("unset-security [-nvh] -P proto -S security-type "
40406185db85Sdougm 				"[-p property]* group");
40416185db85Sdougm 	    break;
40426185db85Sdougm 	case USAGE_UNSHARE:
40436185db85Sdougm 	    ret = gettext("unshare [-F fstype] [-p] [-o optionlist] sharepath");
40446185db85Sdougm 	    break;
40456185db85Sdougm 	}
40466185db85Sdougm 	return (ret);
40476185db85Sdougm }
40486185db85Sdougm 
40496185db85Sdougm /*
40506185db85Sdougm  * sa_lookup(cmd, proto)
40516185db85Sdougm  *
40526185db85Sdougm  * Lookup the sub-command. proto isn't currently used, but it may
40536185db85Sdougm  * eventually provide a way to provide protocol specific sub-commands.
40546185db85Sdougm  */
40556185db85Sdougm 
40566185db85Sdougm sa_command_t *
40576185db85Sdougm sa_lookup(char *cmd, char *proto)
40586185db85Sdougm {
40596185db85Sdougm 	int i;
40606185db85Sdougm 	size_t len;
40616185db85Sdougm #ifdef lint
40626185db85Sdougm 	proto = proto;
40636185db85Sdougm #endif
40646185db85Sdougm 
40656185db85Sdougm 	len = strlen(cmd);
40666185db85Sdougm 	for (i = 0; commands[i].cmdname != NULL; i++) {
40676185db85Sdougm 	    if (strncmp(cmd, commands[i].cmdname, len) == 0)
40686185db85Sdougm 		return (&commands[i]);
40696185db85Sdougm 	}
40706185db85Sdougm 	return (NULL);
40716185db85Sdougm }
40726185db85Sdougm 
40736185db85Sdougm void
40746185db85Sdougm sub_command_help(char *proto)
40756185db85Sdougm {
40766185db85Sdougm 	int i;
40776185db85Sdougm #ifdef lint
40786185db85Sdougm 	proto = proto;
40796185db85Sdougm #endif
40806185db85Sdougm 
40816185db85Sdougm 	(void) printf(gettext("\tsub-commands:\n"));
40826185db85Sdougm 	for (i = 0; commands[i].cmdname != NULL; i++) {
40836185db85Sdougm 	    if (!(commands[i].flags & (CMD_ALIAS|CMD_NODISPLAY)))
40846185db85Sdougm 		(void) printf("\t%s\n",
40856185db85Sdougm 				sa_get_usage((sa_usage_t)commands[i].cmdidx));
40866185db85Sdougm 	}
40876185db85Sdougm }
4088