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 /*
230b4fd3b1SSurya Prakki * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
246185db85Sdougm * Use is subject to license terms.
25*0dfe541eSEvan Layton */
26*0dfe541eSEvan Layton
27*0dfe541eSEvan Layton /*
2833f5ff17SMilan Jurik * Copyright 2012 Milan Jurik. All rights reserved.
29*0dfe541eSEvan Layton * Copyright 2018 Nexenta Systems, Inc.
30a8cc26d6SJohn Levon * Copyright 2019, Joyent, Inc.
316185db85Sdougm */
326185db85Sdougm
336185db85Sdougm #include <sys/types.h>
346185db85Sdougm #include <sys/stat.h>
356185db85Sdougm #include <fcntl.h>
366185db85Sdougm #include <stdlib.h>
376185db85Sdougm #include <stdio.h>
386185db85Sdougm #include <string.h>
396185db85Sdougm #include <ctype.h>
406185db85Sdougm #include <unistd.h>
416185db85Sdougm #include <getopt.h>
426185db85Sdougm #include <utmpx.h>
436185db85Sdougm #include <pwd.h>
446185db85Sdougm #include <auth_attr.h>
456185db85Sdougm #include <secdb.h>
466185db85Sdougm #include <sys/param.h>
476185db85Sdougm #include <sys/stat.h>
486185db85Sdougm #include <errno.h>
496185db85Sdougm
506185db85Sdougm #include <libshare.h>
516185db85Sdougm #include "sharemgr.h"
526185db85Sdougm #include <libscf.h>
536185db85Sdougm #include <libxml/tree.h>
546185db85Sdougm #include <libintl.h>
55da6c28aaSamw #include <assert.h>
56da6c28aaSamw #include <iconv.h>
57da6c28aaSamw #include <langinfo.h>
58da6c28aaSamw #include <dirent.h>
596185db85Sdougm
606185db85Sdougm static char *sa_get_usage(sa_usage_t);
616185db85Sdougm
626185db85Sdougm /*
636185db85Sdougm * Implementation of the common sub-commands supported by sharemgr.
646185db85Sdougm * A number of helper functions are also included.
656185db85Sdougm */
666185db85Sdougm
676185db85Sdougm /*
686185db85Sdougm * has_protocol(group, proto)
696185db85Sdougm * If the group has an optionset with the specified protocol,
706185db85Sdougm * return true (1) otherwise false (0).
716185db85Sdougm */
726185db85Sdougm static int
has_protocol(sa_group_t group,char * protocol)736185db85Sdougm has_protocol(sa_group_t group, char *protocol)
746185db85Sdougm {
756185db85Sdougm sa_optionset_t optionset;
766185db85Sdougm int result = 0;
776185db85Sdougm
786185db85Sdougm optionset = sa_get_optionset(group, protocol);
796185db85Sdougm if (optionset != NULL) {
8025a68471Sdougm result++;
816185db85Sdougm }
826185db85Sdougm return (result);
836185db85Sdougm }
846185db85Sdougm
856185db85Sdougm /*
86da6c28aaSamw * validresource(name)
87da6c28aaSamw *
88da6c28aaSamw * Check that name only has valid characters in it. The current valid
89da6c28aaSamw * set are the printable characters but not including:
90da6c28aaSamw * " / \ [ ] : | < > + ; , ? * = \t
91da6c28aaSamw * Note that space is included and there is a maximum length.
92da6c28aaSamw */
93da6c28aaSamw static int
validresource(const char * name)94da6c28aaSamw validresource(const char *name)
95da6c28aaSamw {
96da6c28aaSamw const char *cp;
97da6c28aaSamw size_t len;
98da6c28aaSamw
99da6c28aaSamw if (name == NULL)
100da6c28aaSamw return (B_FALSE);
101da6c28aaSamw
102da6c28aaSamw len = strlen(name);
103da6c28aaSamw if (len == 0 || len > SA_MAX_RESOURCE_NAME)
104da6c28aaSamw return (B_FALSE);
105da6c28aaSamw
106da6c28aaSamw if (strpbrk(name, "\"/\\[]:|<>+;,?*=\t") != NULL) {
107da6c28aaSamw return (B_FALSE);
108da6c28aaSamw }
109da6c28aaSamw
110da6c28aaSamw for (cp = name; *cp != '\0'; cp++)
111da6c28aaSamw if (iscntrl(*cp))
112da6c28aaSamw return (B_FALSE);
113da6c28aaSamw
114da6c28aaSamw return (B_TRUE);
115da6c28aaSamw }
116da6c28aaSamw
117da6c28aaSamw /*
118da6c28aaSamw * conv_to_utf8(input)
119da6c28aaSamw *
120da6c28aaSamw * Convert the input string to utf8 from the current locale. If the
121da6c28aaSamw * conversion fails, use the current locale, it is likely close
122da6c28aaSamw * enough. For example, the "C" locale is a subset of utf-8. The
123da6c28aaSamw * return value may be a new string or the original input string.
124da6c28aaSamw */
125da6c28aaSamw
126da6c28aaSamw static char *
conv_to_utf8(char * input)127da6c28aaSamw conv_to_utf8(char *input)
128da6c28aaSamw {
129da6c28aaSamw iconv_t cd;
13055bf511dSas char *inval = input;
131da6c28aaSamw char *output = input;
132da6c28aaSamw char *outleft;
133da6c28aaSamw char *curlocale;
134da6c28aaSamw size_t bytesleft;
135da6c28aaSamw size_t size;
136da6c28aaSamw size_t osize;
137da6c28aaSamw static int warned = 0;
138da6c28aaSamw
139da6c28aaSamw curlocale = nl_langinfo(CODESET);
140da6c28aaSamw if (curlocale == NULL)
141da6c28aaSamw curlocale = "C";
142da6c28aaSamw cd = iconv_open("UTF-8", curlocale);
143da6c28aaSamw if (cd != NULL && cd != (iconv_t)-1) {
144da6c28aaSamw size = strlen(input);
145da6c28aaSamw /* Assume worst case of characters expanding to 4 bytes. */
146da6c28aaSamw bytesleft = size * 4;
147da6c28aaSamw output = calloc(bytesleft, 1);
148da6c28aaSamw if (output != NULL) {
149da6c28aaSamw outleft = output;
15055bf511dSas /* inval can be modified on return */
15155bf511dSas osize = iconv(cd, (const char **)&inval, &size,
152da6c28aaSamw &outleft, &bytesleft);
153da6c28aaSamw if (osize == (size_t)-1 || size != 0) {
154da6c28aaSamw free(output);
155da6c28aaSamw output = input;
156da6c28aaSamw }
15755bf511dSas } else {
15855bf511dSas /* Need to return something. */
15955bf511dSas output = input;
160da6c28aaSamw }
161da6c28aaSamw (void) iconv_close(cd);
162da6c28aaSamw } else {
163da6c28aaSamw if (!warned)
164da6c28aaSamw (void) fprintf(stderr,
165da6c28aaSamw gettext("Cannot convert to UTF-8 from %s\n"),
166da6c28aaSamw curlocale ? curlocale : gettext("unknown"));
167da6c28aaSamw warned = 1;
168da6c28aaSamw }
169da6c28aaSamw return (output);
170da6c28aaSamw }
171da6c28aaSamw
172da6c28aaSamw /*
173da6c28aaSamw * conv_from(input)
174da6c28aaSamw *
175da6c28aaSamw * Convert the input string from utf8 to current locale. If the
176da6c28aaSamw * conversion isn't supported, just use as is. The return value may be
177da6c28aaSamw * a new string or the original input string.
178da6c28aaSamw */
179da6c28aaSamw
180da6c28aaSamw static char *
conv_from_utf8(char * input)181da6c28aaSamw conv_from_utf8(char *input)
182da6c28aaSamw {
183da6c28aaSamw iconv_t cd;
184da6c28aaSamw char *output = input;
18555bf511dSas char *inval = input;
186da6c28aaSamw char *outleft;
187da6c28aaSamw char *curlocale;
188da6c28aaSamw size_t bytesleft;
189da6c28aaSamw size_t size;
190da6c28aaSamw size_t osize;
191da6c28aaSamw static int warned = 0;
192da6c28aaSamw
193da6c28aaSamw curlocale = nl_langinfo(CODESET);
194da6c28aaSamw if (curlocale == NULL)
195da6c28aaSamw curlocale = "C";
196da6c28aaSamw cd = iconv_open(curlocale, "UTF-8");
197da6c28aaSamw if (cd != NULL && cd != (iconv_t)-1) {
198da6c28aaSamw size = strlen(input);
199da6c28aaSamw /* Assume worst case of characters expanding to 4 bytes. */
200da6c28aaSamw bytesleft = size * 4;
201da6c28aaSamw output = calloc(bytesleft, 1);
202da6c28aaSamw if (output != NULL) {
203da6c28aaSamw outleft = output;
20455bf511dSas osize = iconv(cd, (const char **)&inval, &size,
205da6c28aaSamw &outleft, &bytesleft);
20655bf511dSas if (osize == (size_t)-1 || size != 0)
207da6c28aaSamw output = input;
20855bf511dSas } else {
20955bf511dSas /* Need to return something. */
21055bf511dSas output = input;
211da6c28aaSamw }
212da6c28aaSamw (void) iconv_close(cd);
213da6c28aaSamw } else {
214da6c28aaSamw if (!warned)
215da6c28aaSamw (void) fprintf(stderr,
216da6c28aaSamw gettext("Cannot convert to %s from UTF-8\n"),
217da6c28aaSamw curlocale ? curlocale : gettext("unknown"));
218da6c28aaSamw warned = 1;
219da6c28aaSamw }
220da6c28aaSamw return (output);
221da6c28aaSamw }
222da6c28aaSamw
223573b0c00Sdougm /*
224573b0c00Sdougm * print_rsrc_desc(resource, sharedesc)
225573b0c00Sdougm *
226573b0c00Sdougm * Print the resource description string after converting from UTF8 to
227573b0c00Sdougm * the current locale. If sharedesc is not NULL and there is no
228573b0c00Sdougm * description on the resource, use sharedesc. sharedesc will already
229573b0c00Sdougm * be converted to UTF8.
230573b0c00Sdougm */
231573b0c00Sdougm
232da6c28aaSamw static void
print_rsrc_desc(sa_resource_t resource,char * sharedesc)233573b0c00Sdougm print_rsrc_desc(sa_resource_t resource, char *sharedesc)
234da6c28aaSamw {
235da6c28aaSamw char *description;
236da6c28aaSamw char *desc;
237da6c28aaSamw
238573b0c00Sdougm if (resource == NULL)
239573b0c00Sdougm return;
240573b0c00Sdougm
241da6c28aaSamw description = sa_get_resource_description(resource);
242da6c28aaSamw if (description != NULL) {
243da6c28aaSamw desc = conv_from_utf8(description);
244da6c28aaSamw if (desc != description) {
245da6c28aaSamw sa_free_share_description(description);
246da6c28aaSamw description = desc;
247da6c28aaSamw }
248573b0c00Sdougm } else if (sharedesc != NULL) {
249573b0c00Sdougm description = strdup(sharedesc);
250573b0c00Sdougm }
251573b0c00Sdougm if (description != NULL) {
252da6c28aaSamw (void) printf("\t\"%s\"", description);
253da6c28aaSamw sa_free_share_description(description);
254da6c28aaSamw }
255da6c28aaSamw }
256da6c28aaSamw
257573b0c00Sdougm /*
258573b0c00Sdougm * set_resource_desc(share, description)
259573b0c00Sdougm *
260573b0c00Sdougm * Set the share description value after converting the description
261573b0c00Sdougm * string to UTF8 from the current locale.
262573b0c00Sdougm */
263573b0c00Sdougm
264573b0c00Sdougm static int
set_resource_desc(sa_share_t share,char * description)265573b0c00Sdougm set_resource_desc(sa_share_t share, char *description)
266573b0c00Sdougm {
267573b0c00Sdougm char *desc;
268573b0c00Sdougm int ret;
269573b0c00Sdougm
270573b0c00Sdougm desc = conv_to_utf8(description);
271573b0c00Sdougm ret = sa_set_resource_description(share, desc);
272573b0c00Sdougm if (description != desc)
273573b0c00Sdougm sa_free_share_description(desc);
274573b0c00Sdougm return (ret);
275573b0c00Sdougm }
276573b0c00Sdougm
277573b0c00Sdougm /*
278573b0c00Sdougm * set_share_desc(share, description)
279573b0c00Sdougm *
280573b0c00Sdougm * Set the resource description value after converting the description
281573b0c00Sdougm * string to UTF8 from the current locale.
282573b0c00Sdougm */
283573b0c00Sdougm
284da6c28aaSamw static int
set_share_desc(sa_share_t share,char * description)285da6c28aaSamw set_share_desc(sa_share_t share, char *description)
286da6c28aaSamw {
287da6c28aaSamw char *desc;
288da6c28aaSamw int ret;
289da6c28aaSamw
290da6c28aaSamw desc = conv_to_utf8(description);
291da6c28aaSamw ret = sa_set_share_description(share, desc);
292da6c28aaSamw if (description != desc)
293da6c28aaSamw sa_free_share_description(desc);
294da6c28aaSamw return (ret);
295da6c28aaSamw }
296da6c28aaSamw
297da6c28aaSamw /*
298da6c28aaSamw * add_list(list, item, data, proto)
299da6c28aaSamw * Adds a new list member that points holds item in the list.
3006185db85Sdougm * If list is NULL, it starts a new list. The function returns
3016185db85Sdougm * the first member of the list.
3026185db85Sdougm */
3036185db85Sdougm struct list *
add_list(struct list * listp,void * item,void * data,char * proto)304da6c28aaSamw add_list(struct list *listp, void *item, void *data, char *proto)
3056185db85Sdougm {
3066185db85Sdougm struct list *new, *tmp;
3076185db85Sdougm
3086185db85Sdougm new = malloc(sizeof (struct list));
3096185db85Sdougm if (new != NULL) {
31025a68471Sdougm new->next = NULL;
31125a68471Sdougm new->item = item;
31225a68471Sdougm new->itemdata = data;
313da6c28aaSamw new->proto = proto;
3146185db85Sdougm } else {
31525a68471Sdougm return (listp);
3166185db85Sdougm }
3176185db85Sdougm
3186185db85Sdougm if (listp == NULL)
31925a68471Sdougm return (new);
3206185db85Sdougm
3216185db85Sdougm for (tmp = listp; tmp->next != NULL; tmp = tmp->next) {
3226185db85Sdougm /* get to end of list */
3236185db85Sdougm }
3246185db85Sdougm tmp->next = new;
3256185db85Sdougm return (listp);
3266185db85Sdougm }
3276185db85Sdougm
3286185db85Sdougm /*
3296185db85Sdougm * free_list(list)
3306185db85Sdougm * Given a list, free all the members of the list;
3316185db85Sdougm */
3326185db85Sdougm static void
free_list(struct list * listp)3336185db85Sdougm free_list(struct list *listp)
3346185db85Sdougm {
3356185db85Sdougm struct list *tmp;
3366185db85Sdougm while (listp != NULL) {
33725a68471Sdougm tmp = listp;
33825a68471Sdougm listp = listp->next;
33925a68471Sdougm free(tmp);
3406185db85Sdougm }
3416185db85Sdougm }
3426185db85Sdougm
3436185db85Sdougm /*
3446185db85Sdougm * check_authorization(instname, which)
3456185db85Sdougm *
3466185db85Sdougm * Checks to see if the specific type of authorization in which is
3476185db85Sdougm * enabled for the user in this SMF service instance.
3486185db85Sdougm */
3496185db85Sdougm
3506185db85Sdougm static int
check_authorization(char * instname,int which)3516185db85Sdougm check_authorization(char *instname, int which)
3526185db85Sdougm {
3536185db85Sdougm scf_handle_t *handle = NULL;
3546185db85Sdougm scf_simple_prop_t *prop = NULL;
3556185db85Sdougm char svcstring[SA_MAX_NAME_LEN + sizeof (SA_SVC_FMRI_BASE) + 1];
3566185db85Sdougm char *authstr = NULL;
3576185db85Sdougm ssize_t numauths;
35825a68471Sdougm int ret = B_TRUE;
3596185db85Sdougm uid_t uid;
3606185db85Sdougm struct passwd *pw = NULL;
3616185db85Sdougm
3626185db85Sdougm uid = getuid();
3636185db85Sdougm pw = getpwuid(uid);
36425a68471Sdougm if (pw == NULL) {
36525a68471Sdougm ret = B_FALSE;
36625a68471Sdougm } else {
36725a68471Sdougm /*
36825a68471Sdougm * Since names are restricted to SA_MAX_NAME_LEN won't
36925a68471Sdougm * overflow.
37025a68471Sdougm */
37125a68471Sdougm (void) snprintf(svcstring, sizeof (svcstring), "%s:%s",
37225a68471Sdougm SA_SVC_FMRI_BASE, instname);
37325a68471Sdougm handle = scf_handle_create(SCF_VERSION);
37425a68471Sdougm if (handle != NULL) {
37525a68471Sdougm if (scf_handle_bind(handle) == 0) {
37625a68471Sdougm switch (which) {
37725a68471Sdougm case SVC_SET:
37825a68471Sdougm prop = scf_simple_prop_get(handle,
37925a68471Sdougm svcstring, "general",
38025a68471Sdougm SVC_AUTH_VALUE);
38125a68471Sdougm break;
38225a68471Sdougm case SVC_ACTION:
38325a68471Sdougm prop = scf_simple_prop_get(handle,
38425a68471Sdougm svcstring, "general",
38525a68471Sdougm SVC_AUTH_ACTION);
38625a68471Sdougm break;
38725a68471Sdougm }
38825a68471Sdougm }
38925a68471Sdougm }
3906185db85Sdougm }
3916185db85Sdougm /* make sure we have an authorization string property */
3926185db85Sdougm if (prop != NULL) {
39325a68471Sdougm int i;
39425a68471Sdougm numauths = scf_simple_prop_numvalues(prop);
39525a68471Sdougm for (ret = 0, i = 0; i < numauths; i++) {
39625a68471Sdougm authstr = scf_simple_prop_next_astring(prop);
39725a68471Sdougm if (authstr != NULL) {
39825a68471Sdougm /* check if this user has one of the strings */
39925a68471Sdougm if (chkauthattr(authstr, pw->pw_name)) {
40025a68471Sdougm ret = 1;
40125a68471Sdougm break;
40225a68471Sdougm }
40325a68471Sdougm }
4046185db85Sdougm }
40525a68471Sdougm endauthattr();
40625a68471Sdougm scf_simple_prop_free(prop);
4076185db85Sdougm } else {
40825a68471Sdougm /* no authorization string defined */
40925a68471Sdougm ret = 0;
4106185db85Sdougm }
4116185db85Sdougm if (handle != NULL)
41225a68471Sdougm scf_handle_destroy(handle);
4136185db85Sdougm return (ret);
4146185db85Sdougm }
4156185db85Sdougm
4166185db85Sdougm /*
4176185db85Sdougm * check_authorizations(instname, flags)
4186185db85Sdougm *
4196185db85Sdougm * check all the needed authorizations for the user in this service
4206185db85Sdougm * instance. Return value of 1(true) or 0(false) indicates whether
4216185db85Sdougm * there are authorizations for the user or not.
4226185db85Sdougm */
4236185db85Sdougm
4246185db85Sdougm static int
check_authorizations(char * instname,int flags)4256185db85Sdougm check_authorizations(char *instname, int flags)
4266185db85Sdougm {
4276185db85Sdougm int ret1 = 0;
4286185db85Sdougm int ret2 = 0;
4296185db85Sdougm int ret;
4306185db85Sdougm
4316185db85Sdougm if (flags & SVC_SET)
43225a68471Sdougm ret1 = check_authorization(instname, SVC_SET);
4336185db85Sdougm if (flags & SVC_ACTION)
43425a68471Sdougm ret2 = check_authorization(instname, SVC_ACTION);
4356185db85Sdougm switch (flags) {
4366185db85Sdougm case SVC_ACTION:
43725a68471Sdougm ret = ret2;
43825a68471Sdougm break;
4396185db85Sdougm case SVC_SET:
44025a68471Sdougm ret = ret1;
44125a68471Sdougm break;
4426185db85Sdougm case SVC_ACTION|SVC_SET:
44325a68471Sdougm ret = ret1 & ret2;
44425a68471Sdougm break;
4456185db85Sdougm default:
44625a68471Sdougm /* if not flags set, we assume we don't need authorizations */
44725a68471Sdougm ret = 1;
4486185db85Sdougm }
4496185db85Sdougm return (ret);
4506185db85Sdougm }
4516185db85Sdougm
4526185db85Sdougm /*
453da6c28aaSamw * notify_or_enable_share(share, protocol)
454da6c28aaSamw *
455da6c28aaSamw * Since some protocols don't want an "enable" when properties change,
456da6c28aaSamw * this function will use the protocol specific notify function
457da6c28aaSamw * first. If that fails, it will then attempt to use the
458da6c28aaSamw * sa_enable_share(). "protocol" is the protocol that was specified
459da6c28aaSamw * on the command line.
460da6c28aaSamw */
461da6c28aaSamw static void
notify_or_enable_share(sa_share_t share,char * protocol)462da6c28aaSamw notify_or_enable_share(sa_share_t share, char *protocol)
463da6c28aaSamw {
464da6c28aaSamw sa_group_t group;
465da6c28aaSamw sa_optionset_t opt;
466da6c28aaSamw int ret = SA_OK;
467da6c28aaSamw char *path;
468da6c28aaSamw char *groupproto;
469da6c28aaSamw sa_share_t parent = share;
470da6c28aaSamw
471da6c28aaSamw /* If really a resource, get parent share */
472da6c28aaSamw if (!sa_is_share(share)) {
473da6c28aaSamw parent = sa_get_resource_parent((sa_resource_t)share);
474da6c28aaSamw }
475da6c28aaSamw
476da6c28aaSamw /*
477da6c28aaSamw * Now that we've got a share in "parent", make sure it has a path.
478da6c28aaSamw */
479da6c28aaSamw path = sa_get_share_attr(parent, "path");
480da6c28aaSamw if (path == NULL)
481da6c28aaSamw return;
482da6c28aaSamw
483da6c28aaSamw group = sa_get_parent_group(parent);
484da6c28aaSamw
485da6c28aaSamw if (group == NULL) {
486da6c28aaSamw sa_free_attr_string(path);
487da6c28aaSamw return;
488da6c28aaSamw }
489da6c28aaSamw for (opt = sa_get_optionset(group, NULL);
490da6c28aaSamw opt != NULL;
491da6c28aaSamw opt = sa_get_next_optionset(opt)) {
492da6c28aaSamw groupproto = sa_get_optionset_attr(opt, "type");
493da6c28aaSamw if (groupproto == NULL ||
494da6c28aaSamw (protocol != NULL && strcmp(groupproto, protocol) != 0)) {
495fe1c642dSBill Krier if (groupproto != NULL)
496fe1c642dSBill Krier sa_free_attr_string(groupproto);
497da6c28aaSamw continue;
498da6c28aaSamw }
499da6c28aaSamw if (sa_is_share(share)) {
500da6c28aaSamw if ((ret = sa_proto_change_notify(share,
501da6c28aaSamw groupproto)) != SA_OK) {
502da6c28aaSamw ret = sa_enable_share(share, groupproto);
503da6c28aaSamw if (ret != SA_OK) {
504da6c28aaSamw (void) printf(
505da6c28aaSamw gettext("Could not reenable"
506da6c28aaSamw " share %s: %s\n"),
507da6c28aaSamw path, sa_errorstr(ret));
508da6c28aaSamw }
509da6c28aaSamw }
510da6c28aaSamw } else {
511da6c28aaSamw /* Must be a resource */
512da6c28aaSamw if ((ret = sa_proto_notify_resource(share,
513da6c28aaSamw groupproto)) != SA_OK) {
514da6c28aaSamw ret = sa_enable_resource(share, groupproto);
515da6c28aaSamw if (ret != SA_OK) {
516da6c28aaSamw (void) printf(
517da6c28aaSamw gettext("Could not "
518da6c28aaSamw "reenable resource %s: "
519da6c28aaSamw "%s\n"), path,
520da6c28aaSamw sa_errorstr(ret));
521da6c28aaSamw }
522da6c28aaSamw }
523da6c28aaSamw }
524da6c28aaSamw sa_free_attr_string(groupproto);
525da6c28aaSamw }
526da6c28aaSamw sa_free_attr_string(path);
527da6c28aaSamw }
528da6c28aaSamw
529da6c28aaSamw /*
530da6c28aaSamw * enable_group(group, updateproto, notify, proto)
5317d968cb8Sdougm *
5327d968cb8Sdougm * enable all the shares in the specified group. This is a helper for
5337d968cb8Sdougm * enable_all_groups in order to simplify regular and subgroup (zfs)
534da6c28aaSamw * enabling. Group has already been checked for non-NULL. If notify
535da6c28aaSamw * is non-zero, attempt to use the notify interface rather than
536da6c28aaSamw * enable.
5376185db85Sdougm */
5387d968cb8Sdougm static void
enable_group(sa_group_t group,char * updateproto,int notify,char * proto)539da6c28aaSamw enable_group(sa_group_t group, char *updateproto, int notify, char *proto)
5406185db85Sdougm {
5416185db85Sdougm sa_share_t share;
5427d968cb8Sdougm
543e0a942cbSRichard Lowe /* If the protocol isn't enabled for this group skip it */
544e0a942cbSRichard Lowe if (!has_protocol(group, proto))
545e0a942cbSRichard Lowe return;
546e0a942cbSRichard Lowe
5477d968cb8Sdougm for (share = sa_get_share(group, NULL);
5487d968cb8Sdougm share != NULL;
5497d968cb8Sdougm share = sa_get_next_share(share)) {
55025a68471Sdougm if (updateproto != NULL)
55125a68471Sdougm (void) sa_update_legacy(share, updateproto);
552da6c28aaSamw if (notify)
553da6c28aaSamw notify_or_enable_share(share, proto);
554da6c28aaSamw else
555da6c28aaSamw (void) sa_enable_share(share, proto);
5567d968cb8Sdougm }
5577d968cb8Sdougm }
5587d968cb8Sdougm
559330ef417Sdougm /*
560330ef417Sdougm * isenabled(group)
561330ef417Sdougm *
562330ef417Sdougm * Returns B_TRUE if the group is enabled or B_FALSE if it isn't.
563330ef417Sdougm * Moved to separate function to reduce clutter in the code.
564330ef417Sdougm */
565330ef417Sdougm
566330ef417Sdougm static int
isenabled(sa_group_t group)567330ef417Sdougm isenabled(sa_group_t group)
568330ef417Sdougm {
569330ef417Sdougm char *state;
570330ef417Sdougm int ret = B_FALSE;
571330ef417Sdougm
572330ef417Sdougm if (group != NULL) {
57325a68471Sdougm state = sa_get_group_attr(group, "state");
57425a68471Sdougm if (state != NULL) {
575da6c28aaSamw
57625a68471Sdougm if (strcmp(state, "enabled") == 0)
57725a68471Sdougm ret = B_TRUE;
57825a68471Sdougm sa_free_attr_string(state);
57925a68471Sdougm }
580330ef417Sdougm }
581330ef417Sdougm return (ret);
582330ef417Sdougm }
583330ef417Sdougm
5847d968cb8Sdougm /*
5857d968cb8Sdougm * enable_all_groups(list, setstate, online, updateproto)
586da6c28aaSamw *
587da6c28aaSamw * Given a list of groups, enable each one found. If updateproto is
588da6c28aaSamw * not NULL, then update all the shares for the protocol that was
589da6c28aaSamw * passed in. If enable is non-zero, tell enable_group to try the
590da6c28aaSamw * notify interface since this is a property change.
5917d968cb8Sdougm */
5927d968cb8Sdougm static int
enable_all_groups(sa_handle_t handle,struct list * work,int setstate,int online,char * updateproto,int enable)593549ec3ffSdougm enable_all_groups(sa_handle_t handle, struct list *work, int setstate,
594da6c28aaSamw int online, char *updateproto, int enable)
5957d968cb8Sdougm {
596330ef417Sdougm int ret;
5976185db85Sdougm char instance[SA_MAX_NAME_LEN + sizeof (SA_SVC_FMRI_BASE) + 1];
5986185db85Sdougm char *state;
5996185db85Sdougm char *name;
6006185db85Sdougm char *zfs = NULL;
6016185db85Sdougm sa_group_t group;
6027d968cb8Sdougm sa_group_t subgroup;
6036185db85Sdougm
604330ef417Sdougm for (ret = SA_OK; work != NULL; work = work->next) {
60525a68471Sdougm group = (sa_group_t)work->item;
606330ef417Sdougm
607330ef417Sdougm /*
608330ef417Sdougm * If setstate == TRUE, then make sure to set
609330ef417Sdougm * enabled. This needs to be done here in order for
610330ef417Sdougm * the isenabled check to succeed on a newly enabled
611330ef417Sdougm * group.
612330ef417Sdougm */
61325a68471Sdougm if (setstate == B_TRUE) {
61425a68471Sdougm ret = sa_set_group_attr(group, "state", "enabled");
61525a68471Sdougm if (ret != SA_OK)
61625a68471Sdougm break;
61725a68471Sdougm }
618330ef417Sdougm
619330ef417Sdougm /*
620330ef417Sdougm * Check to see if group is enabled. If it isn't, skip
621330ef417Sdougm * the rest. We don't want shares starting if the
622330ef417Sdougm * group is disabled. The properties may have been
623330ef417Sdougm * updated, but there won't be a change until the
624330ef417Sdougm * group is enabled.
625330ef417Sdougm */
62625a68471Sdougm if (!isenabled(group))
62725a68471Sdougm continue;
628330ef417Sdougm
62925a68471Sdougm /* if itemdata != NULL then a single share */
63025a68471Sdougm if (work->itemdata != NULL) {
631da6c28aaSamw if (enable) {
632da6c28aaSamw if (work->itemdata != NULL)
633da6c28aaSamw notify_or_enable_share(work->itemdata,
634da6c28aaSamw updateproto);
635da6c28aaSamw else
636da6c28aaSamw ret = SA_CONFIG_ERR;
637da6c28aaSamw } else {
638da6c28aaSamw if (sa_is_share(work->itemdata)) {
639da6c28aaSamw ret = sa_enable_share(
640da6c28aaSamw (sa_share_t)work->itemdata,
641da6c28aaSamw updateproto);
642da6c28aaSamw } else {
643da6c28aaSamw ret = sa_enable_resource(
644da6c28aaSamw (sa_resource_t)work->itemdata,
645da6c28aaSamw updateproto);
646da6c28aaSamw }
647da6c28aaSamw }
64825a68471Sdougm }
64925a68471Sdougm if (ret != SA_OK)
65025a68471Sdougm break;
65125a68471Sdougm
65225a68471Sdougm /* if itemdata == NULL then the whole group */
65325a68471Sdougm if (work->itemdata == NULL) {
65425a68471Sdougm zfs = sa_get_group_attr(group, "zfs");
65525a68471Sdougm /*
656da6c28aaSamw * If the share is managed by ZFS, don't
65725a68471Sdougm * update any of the protocols since ZFS is
658da6c28aaSamw * handling this. Updateproto will contain
65925a68471Sdougm * the name of the protocol that we want to
66025a68471Sdougm * update legacy files for.
66125a68471Sdougm */
662da6c28aaSamw enable_group(group, zfs == NULL ? updateproto : NULL,
663da6c28aaSamw enable, work->proto);
664fe1c642dSBill Krier if (zfs != NULL)
665fe1c642dSBill Krier sa_free_attr_string(zfs);
666fe1c642dSBill Krier
66725a68471Sdougm for (subgroup = sa_get_sub_group(group);
66825a68471Sdougm subgroup != NULL;
66925a68471Sdougm subgroup = sa_get_next_group(subgroup)) {
67025a68471Sdougm /* never update legacy for ZFS subgroups */
671da6c28aaSamw enable_group(subgroup, NULL, enable,
672da6c28aaSamw work->proto);
67325a68471Sdougm }
67425a68471Sdougm }
67525a68471Sdougm if (online) {
67625a68471Sdougm zfs = sa_get_group_attr(group, "zfs");
67725a68471Sdougm name = sa_get_group_attr(group, "name");
67825a68471Sdougm if (name != NULL) {
67925a68471Sdougm if (zfs == NULL) {
68025a68471Sdougm (void) snprintf(instance,
68125a68471Sdougm sizeof (instance), "%s:%s",
68225a68471Sdougm SA_SVC_FMRI_BASE, name);
68325a68471Sdougm state = smf_get_state(instance);
68425a68471Sdougm if (state == NULL ||
68525a68471Sdougm strcmp(state, "online") != 0) {
68625a68471Sdougm (void) smf_enable_instance(
68725a68471Sdougm instance, 0);
68825a68471Sdougm free(state);
68925a68471Sdougm }
69025a68471Sdougm } else {
69125a68471Sdougm sa_free_attr_string(zfs);
69225a68471Sdougm zfs = NULL;
69325a68471Sdougm }
69425a68471Sdougm if (name != NULL)
69525a68471Sdougm sa_free_attr_string(name);
6966185db85Sdougm }
6976185db85Sdougm }
6986185db85Sdougm }
6996185db85Sdougm if (ret == SA_OK) {
70025a68471Sdougm ret = sa_update_config(handle);
7016185db85Sdougm }
7026185db85Sdougm return (ret);
7036185db85Sdougm }
7046185db85Sdougm
7056185db85Sdougm /*
7066185db85Sdougm * chk_opt(optlistp, security, proto)
7076185db85Sdougm *
7086185db85Sdougm * Do a sanity check on the optlist provided for the protocol. This
7096185db85Sdougm * is a syntax check and verification that the property is either a
7106185db85Sdougm * general or specific to a names optionset.
7116185db85Sdougm */
7126185db85Sdougm
7136185db85Sdougm static int
chk_opt(struct options * optlistp,int security,char * proto)7146185db85Sdougm chk_opt(struct options *optlistp, int security, char *proto)
7156185db85Sdougm {
7166185db85Sdougm struct options *optlist;
7176185db85Sdougm char *sep = "";
7186185db85Sdougm int notfirst = 0;
7196185db85Sdougm int ret;
7206185db85Sdougm
7216185db85Sdougm for (optlist = optlistp; optlist != NULL; optlist = optlist->next) {
72225a68471Sdougm char *optname;
72325a68471Sdougm
72425a68471Sdougm optname = optlist->optname;
72525a68471Sdougm ret = OPT_ADD_OK;
72625a68471Sdougm /* extract property/value pair */
72725a68471Sdougm if (sa_is_security(optname, proto)) {
72825a68471Sdougm if (!security)
72925a68471Sdougm ret = OPT_ADD_SECURITY;
73025a68471Sdougm } else {
73125a68471Sdougm if (security)
73225a68471Sdougm ret = OPT_ADD_PROPERTY;
73325a68471Sdougm }
73425a68471Sdougm if (ret != OPT_ADD_OK) {
73525a68471Sdougm if (notfirst == 0)
73625a68471Sdougm (void) printf(
73725a68471Sdougm gettext("Property syntax error: "));
73825a68471Sdougm switch (ret) {
73925a68471Sdougm case OPT_ADD_SYNTAX:
74025a68471Sdougm (void) printf(gettext("%ssyntax error: %s"),
7416185db85Sdougm sep, optname);
74225a68471Sdougm sep = ", ";
74325a68471Sdougm break;
74425a68471Sdougm case OPT_ADD_SECURITY:
74525a68471Sdougm (void) printf(gettext("%s%s requires -S"),
7466185db85Sdougm optname, sep);
74725a68471Sdougm sep = ", ";
74825a68471Sdougm break;
74925a68471Sdougm case OPT_ADD_PROPERTY:
75025a68471Sdougm (void) printf(
75125a68471Sdougm gettext("%s%s not supported with -S"),
7526185db85Sdougm optname, sep);
75325a68471Sdougm sep = ", ";
75425a68471Sdougm break;
75525a68471Sdougm }
75625a68471Sdougm notfirst++;
7576185db85Sdougm }
7586185db85Sdougm }
7596185db85Sdougm if (notfirst) {
76025a68471Sdougm (void) printf("\n");
76125a68471Sdougm ret = SA_SYNTAX_ERR;
7626185db85Sdougm }
7636185db85Sdougm return (ret);
7646185db85Sdougm }
7656185db85Sdougm
7666185db85Sdougm /*
7676185db85Sdougm * free_opt(optlist)
7686185db85Sdougm * Free the specified option list.
7696185db85Sdougm */
7706185db85Sdougm static void
free_opt(struct options * optlist)7716185db85Sdougm free_opt(struct options *optlist)
7726185db85Sdougm {
7736185db85Sdougm struct options *nextopt;
7746185db85Sdougm while (optlist != NULL) {
7756185db85Sdougm nextopt = optlist->next;
7766185db85Sdougm free(optlist);
7776185db85Sdougm optlist = nextopt;
7786185db85Sdougm }
7796185db85Sdougm }
7806185db85Sdougm
7816185db85Sdougm /*
7826185db85Sdougm * check property list for valid properties
7836185db85Sdougm * A null value is a remove which is always valid.
7846185db85Sdougm */
7856185db85Sdougm static int
valid_options(sa_handle_t handle,struct options * optlist,char * proto,void * object,char * sec)786687915e9Sdougm valid_options(sa_handle_t handle, struct options *optlist, char *proto,
787687915e9Sdougm void *object, char *sec)
7886185db85Sdougm {
7896185db85Sdougm int ret = SA_OK;
7906185db85Sdougm struct options *cur;
7916185db85Sdougm sa_property_t prop;
7926185db85Sdougm sa_optionset_t parent = NULL;
7936185db85Sdougm
7946185db85Sdougm if (object != NULL) {
79525a68471Sdougm if (sec == NULL)
79625a68471Sdougm parent = sa_get_optionset(object, proto);
79725a68471Sdougm else
79825a68471Sdougm parent = sa_get_security(object, sec, proto);
7996185db85Sdougm }
8006185db85Sdougm
8016185db85Sdougm for (cur = optlist; cur != NULL; cur = cur->next) {
80225a68471Sdougm if (cur->optvalue == NULL)
80325a68471Sdougm continue;
8046185db85Sdougm prop = sa_create_property(cur->optname, cur->optvalue);
8056185db85Sdougm if (prop == NULL)
80625a68471Sdougm ret = SA_NO_MEMORY;
8076185db85Sdougm if (ret != SA_OK ||
808687915e9Sdougm (ret = sa_valid_property(handle, parent, proto, prop)) !=
809687915e9Sdougm SA_OK) {
81025a68471Sdougm (void) printf(
81125a68471Sdougm gettext("Could not add property %s: %s\n"),
81225a68471Sdougm cur->optname, sa_errorstr(ret));
8136185db85Sdougm }
8146185db85Sdougm (void) sa_remove_property(prop);
8156185db85Sdougm }
8166185db85Sdougm return (ret);
8176185db85Sdougm }
8186185db85Sdougm
8196185db85Sdougm /*
8206185db85Sdougm * add_optionset(group, optlist, protocol, *err)
8216185db85Sdougm * Add the options in optlist to an optionset and then add the optionset
8226185db85Sdougm * to the group.
8236185db85Sdougm *
8246185db85Sdougm * The return value indicates if there was a "change" while errors are
8256185db85Sdougm * returned via the *err parameters.
8266185db85Sdougm */
8276185db85Sdougm static int
add_optionset(sa_group_t group,struct options * optlist,char * proto,int * err)8286185db85Sdougm add_optionset(sa_group_t group, struct options *optlist, char *proto, int *err)
8296185db85Sdougm {
8306185db85Sdougm sa_optionset_t optionset;
8316185db85Sdougm int ret = SA_OK;
832da6c28aaSamw int result = B_FALSE;
833687915e9Sdougm sa_handle_t handle;
8346185db85Sdougm
8356185db85Sdougm optionset = sa_get_optionset(group, proto);
8366185db85Sdougm if (optionset == NULL) {
83725a68471Sdougm optionset = sa_create_optionset(group, proto);
838da6c28aaSamw if (optionset == NULL)
839da6c28aaSamw ret = SA_NO_MEMORY;
840da6c28aaSamw result = B_TRUE; /* adding a protocol is a change */
8416185db85Sdougm }
84225a68471Sdougm if (optionset == NULL) {
84325a68471Sdougm ret = SA_NO_MEMORY;
84425a68471Sdougm goto out;
84525a68471Sdougm }
846687915e9Sdougm handle = sa_find_group_handle(group);
847687915e9Sdougm if (handle == NULL) {
848687915e9Sdougm ret = SA_CONFIG_ERR;
849687915e9Sdougm goto out;
850687915e9Sdougm }
85125a68471Sdougm while (optlist != NULL) {
8526185db85Sdougm sa_property_t prop;
8536185db85Sdougm prop = sa_get_property(optionset, optlist->optname);
8546185db85Sdougm if (prop == NULL) {
8556185db85Sdougm /*
8566185db85Sdougm * add the property, but only if it is
8576185db85Sdougm * a non-NULL or non-zero length value
8586185db85Sdougm */
85925a68471Sdougm if (optlist->optvalue != NULL) {
86025a68471Sdougm prop = sa_create_property(optlist->optname,
86125a68471Sdougm optlist->optvalue);
86225a68471Sdougm if (prop != NULL) {
863687915e9Sdougm ret = sa_valid_property(handle,
864687915e9Sdougm optionset, proto, prop);
86525a68471Sdougm if (ret != SA_OK) {
86625a68471Sdougm (void) sa_remove_property(prop);
86725a68471Sdougm (void) printf(gettext("Could "
86825a68471Sdougm "not add property "
86925a68471Sdougm "%s: %s\n"),
87025a68471Sdougm optlist->optname,
87125a68471Sdougm sa_errorstr(ret));
87225a68471Sdougm }
87325a68471Sdougm }
87425a68471Sdougm if (ret == SA_OK) {
87525a68471Sdougm ret = sa_add_property(optionset, prop);
87625a68471Sdougm if (ret != SA_OK) {
87725a68471Sdougm (void) printf(gettext(
87825a68471Sdougm "Could not add property "
87925a68471Sdougm "%s: %s\n"),
88025a68471Sdougm optlist->optname,
88125a68471Sdougm sa_errorstr(ret));
88225a68471Sdougm } else {
88325a68471Sdougm /* there was a change */
884da6c28aaSamw result = B_TRUE;
88525a68471Sdougm }
88625a68471Sdougm }
8876185db85Sdougm }
88825a68471Sdougm } else {
88925a68471Sdougm ret = sa_update_property(prop, optlist->optvalue);
89025a68471Sdougm /* should check to see if value changed */
89125a68471Sdougm if (ret != SA_OK) {
89225a68471Sdougm (void) printf(gettext("Could not update "
89325a68471Sdougm "property %s: %s\n"), optlist->optname,
89425a68471Sdougm sa_errorstr(ret));
89525a68471Sdougm } else {
896da6c28aaSamw result = B_TRUE;
8976185db85Sdougm }
8986185db85Sdougm }
8996185db85Sdougm optlist = optlist->next;
9006185db85Sdougm }
90125a68471Sdougm ret = sa_commit_properties(optionset, 0);
90225a68471Sdougm
90325a68471Sdougm out:
9046185db85Sdougm if (err != NULL)
90525a68471Sdougm *err = ret;
9066185db85Sdougm return (result);
9076185db85Sdougm }
9086185db85Sdougm
909da6c28aaSamw /*
910da6c28aaSamw * resource_compliant(group)
911da6c28aaSamw *
912da6c28aaSamw * Go through all the shares in the group. Assume compliant, but if
913da6c28aaSamw * any share doesn't have at least one resource name, it isn't
914da6c28aaSamw * compliant.
915da6c28aaSamw */
916da6c28aaSamw static int
resource_compliant(sa_group_t group)917da6c28aaSamw resource_compliant(sa_group_t group)
918da6c28aaSamw {
919da6c28aaSamw sa_share_t share;
920da6c28aaSamw
921da6c28aaSamw for (share = sa_get_share(group, NULL); share != NULL;
922da6c28aaSamw share = sa_get_next_share(share)) {
923da6c28aaSamw if (sa_get_share_resource(share, NULL) == NULL) {
924da6c28aaSamw return (B_FALSE);
925da6c28aaSamw }
926da6c28aaSamw }
927da6c28aaSamw return (B_TRUE);
928da6c28aaSamw }
929da6c28aaSamw
930da6c28aaSamw /*
931da6c28aaSamw * fix_path(path)
932da6c28aaSamw *
933da6c28aaSamw * change all illegal characters to something else. For now, all get
934da6c28aaSamw * converted to '_' and the leading '/' is stripped off. This is used
935da6c28aaSamw * to construct an resource name (SMB share name) that is valid.
936da6c28aaSamw * Caller must pass a valid path.
937da6c28aaSamw */
938da6c28aaSamw static void
fix_path(char * path)939da6c28aaSamw fix_path(char *path)
940da6c28aaSamw {
941da6c28aaSamw char *cp;
942da6c28aaSamw size_t len;
943da6c28aaSamw
944da6c28aaSamw assert(path != NULL);
945da6c28aaSamw
946da6c28aaSamw /* make sure we are appropriate length */
947da6c28aaSamw cp = path + 1; /* skip leading slash */
948da6c28aaSamw while (cp != NULL && strlen(cp) > SA_MAX_RESOURCE_NAME) {
949da6c28aaSamw cp = strchr(cp, '/');
950da6c28aaSamw if (cp != NULL)
951da6c28aaSamw cp++;
952da6c28aaSamw }
953da6c28aaSamw /* two cases - cp == NULL and cp is substring of path */
954da6c28aaSamw if (cp == NULL) {
955da6c28aaSamw /* just take last SA_MAX_RESOURCE_NAME chars */
956da6c28aaSamw len = 1 + strlen(path) - SA_MAX_RESOURCE_NAME;
957da6c28aaSamw (void) memmove(path, path + len, SA_MAX_RESOURCE_NAME);
958da6c28aaSamw path[SA_MAX_RESOURCE_NAME] = '\0';
959da6c28aaSamw } else {
960da6c28aaSamw len = strlen(cp) + 1;
961da6c28aaSamw (void) memmove(path, cp, len);
962da6c28aaSamw }
963da6c28aaSamw
964da6c28aaSamw /*
965da6c28aaSamw * Don't want any of the characters that are not allowed
966da6c28aaSamw * in and SMB share name. Replace them with '_'.
967da6c28aaSamw */
968da6c28aaSamw while (*path) {
969da6c28aaSamw switch (*path) {
970da6c28aaSamw case '/':
971da6c28aaSamw case '"':
972da6c28aaSamw case '\\':
973da6c28aaSamw case '[':
974da6c28aaSamw case ']':
975da6c28aaSamw case ':':
976da6c28aaSamw case '|':
977da6c28aaSamw case '<':
978da6c28aaSamw case '>':
979da6c28aaSamw case '+':
980da6c28aaSamw case ';':
981da6c28aaSamw case ',':
982da6c28aaSamw case '?':
983da6c28aaSamw case '*':
984da6c28aaSamw case '=':
985da6c28aaSamw case '\t':
986da6c28aaSamw *path = '_';
987da6c28aaSamw break;
988da6c28aaSamw }
989da6c28aaSamw path++;
990da6c28aaSamw }
991da6c28aaSamw }
992da6c28aaSamw
993da6c28aaSamw /*
994da6c28aaSamw * name_adjust(path, count)
995da6c28aaSamw *
996da6c28aaSamw * Add a ~<count> in place of last few characters. The total number of
997da6c28aaSamw * characters is dependent on count.
998da6c28aaSamw */
999da6c28aaSamw #define MAX_MANGLE_NUMBER 10000
1000da6c28aaSamw
1001da6c28aaSamw static int
name_adjust(char * path,int count)1002da6c28aaSamw name_adjust(char *path, int count)
1003da6c28aaSamw {
1004da6c28aaSamw size_t len;
1005da6c28aaSamw
1006da6c28aaSamw len = strlen(path) - 2;
1007da6c28aaSamw if (count > 10)
1008da6c28aaSamw len--;
1009da6c28aaSamw if (count > 100)
1010da6c28aaSamw len--;
1011da6c28aaSamw if (count > 1000)
1012da6c28aaSamw len--;
1013da6c28aaSamw if (len > 0)
1014da6c28aaSamw (void) sprintf(path + len, "~%d", count);
1015da6c28aaSamw else
1016da6c28aaSamw return (SA_BAD_VALUE);
1017da6c28aaSamw
1018da6c28aaSamw return (SA_OK);
1019da6c28aaSamw }
1020da6c28aaSamw
1021da6c28aaSamw /*
1022da6c28aaSamw * make_resources(group)
1023da6c28aaSamw *
1024da6c28aaSamw * Go through all the shares in the group and make them have resource
1025da6c28aaSamw * names.
1026da6c28aaSamw */
1027da6c28aaSamw static void
make_resources(sa_group_t group)1028da6c28aaSamw make_resources(sa_group_t group)
1029da6c28aaSamw {
1030da6c28aaSamw sa_share_t share;
1031da6c28aaSamw int count;
1032da6c28aaSamw int err = SA_OK;
1033da6c28aaSamw
1034da6c28aaSamw for (share = sa_get_share(group, NULL); share != NULL;
1035da6c28aaSamw share = sa_get_next_share(share)) {
1036da6c28aaSamw /* Skip those with resources */
1037da6c28aaSamw if (sa_get_share_resource(share, NULL) == NULL) {
1038da6c28aaSamw char *path;
1039da6c28aaSamw path = sa_get_share_attr(share, "path");
1040da6c28aaSamw if (path == NULL)
1041da6c28aaSamw continue;
1042da6c28aaSamw fix_path(path);
1043da6c28aaSamw count = 0; /* reset for next resource */
1044da6c28aaSamw while (sa_add_resource(share, path,
1045da6c28aaSamw SA_SHARE_PERMANENT, &err) == NULL &&
1046da6c28aaSamw err == SA_DUPLICATE_NAME) {
1047da6c28aaSamw int ret;
1048da6c28aaSamw ret = name_adjust(path, count);
1049da6c28aaSamw count++;
1050da6c28aaSamw if (ret != SA_OK ||
1051da6c28aaSamw count >= MAX_MANGLE_NUMBER) {
1052da6c28aaSamw (void) printf(gettext(
1053da6c28aaSamw "Cannot create resource name for"
1054da6c28aaSamw " path: %s\n"), path);
1055da6c28aaSamw break;
1056da6c28aaSamw }
1057da6c28aaSamw }
1058da6c28aaSamw sa_free_attr_string(path);
1059da6c28aaSamw }
1060da6c28aaSamw }
1061da6c28aaSamw }
1062da6c28aaSamw
10639e5da854Sdougm /*
10649e5da854Sdougm * check_valid_group(group, protocol)
10659e5da854Sdougm *
10669e5da854Sdougm * Check to see that the group should have the protocol added (if
10679e5da854Sdougm * there is one specified).
10689e5da854Sdougm */
10699e5da854Sdougm
10709e5da854Sdougm static int
check_valid_group(sa_group_t group,char * groupname,char * protocol)10719e5da854Sdougm check_valid_group(sa_group_t group, char *groupname, char *protocol)
10729e5da854Sdougm {
10739e5da854Sdougm
10749e5da854Sdougm if (protocol != NULL) {
10759e5da854Sdougm if (has_protocol(group, protocol)) {
10769e5da854Sdougm (void) printf(gettext(
10779e5da854Sdougm "Group \"%s\" already exists"
10789e5da854Sdougm " with protocol %s\n"), groupname,
10799e5da854Sdougm protocol);
10809e5da854Sdougm return (SA_DUPLICATE_NAME);
10819e5da854Sdougm } else if (strcmp(groupname, "default") == 0 &&
10829e5da854Sdougm strcmp(protocol, "nfs") != 0) {
10839e5da854Sdougm (void) printf(gettext(
10849e5da854Sdougm "Group \"%s\" only allows protocol "
10859e5da854Sdougm "\"%s\"\n"), groupname, "nfs");
10869e5da854Sdougm return (SA_INVALID_PROTOCOL);
10879e5da854Sdougm }
10889e5da854Sdougm } else {
10899e5da854Sdougm /* must add new protocol */
10909e5da854Sdougm (void) printf(gettext(
10919e5da854Sdougm "Group already exists and no protocol "
10929e5da854Sdougm "specified.\n"));
10939e5da854Sdougm return (SA_DUPLICATE_NAME);
10949e5da854Sdougm }
10959e5da854Sdougm return (SA_OK);
10969e5da854Sdougm }
10979e5da854Sdougm
10989e5da854Sdougm /*
10999e5da854Sdougm * enforce_featureset(group, protocol, dryrun, force)
11009e5da854Sdougm *
11019e5da854Sdougm * Check the protocol featureset against the group and enforce any
11029e5da854Sdougm * rules that might be imposed.
11039e5da854Sdougm */
11049e5da854Sdougm
11059e5da854Sdougm static int
enforce_featureset(sa_group_t group,char * protocol,boolean_t dryrun,boolean_t force)11069e5da854Sdougm enforce_featureset(sa_group_t group, char *protocol, boolean_t dryrun,
11079e5da854Sdougm boolean_t force)
11089e5da854Sdougm {
11099e5da854Sdougm uint64_t features;
11109e5da854Sdougm
11119e5da854Sdougm if (protocol == NULL)
11129e5da854Sdougm return (SA_OK);
11139e5da854Sdougm
11149e5da854Sdougm /*
11159e5da854Sdougm * First check to see if specified protocol is one we want to
11169e5da854Sdougm * allow on a group. Only server protocols are allowed here.
11179e5da854Sdougm */
11189e5da854Sdougm features = sa_proto_get_featureset(protocol);
11199e5da854Sdougm if (!(features & SA_FEATURE_SERVER)) {
11209e5da854Sdougm (void) printf(
11219e5da854Sdougm gettext("Protocol \"%s\" not supported.\n"), protocol);
11229e5da854Sdougm return (SA_INVALID_PROTOCOL);
11239e5da854Sdougm }
11249e5da854Sdougm
11259e5da854Sdougm /*
11269e5da854Sdougm * Check to see if the new protocol is one that requires
11279e5da854Sdougm * resource names and make sure we are compliant before
11289e5da854Sdougm * proceeding.
11299e5da854Sdougm */
11309e5da854Sdougm if ((features & SA_FEATURE_RESOURCE) &&
11319e5da854Sdougm !resource_compliant(group)) {
11329e5da854Sdougm if (force && !dryrun) {
11339e5da854Sdougm make_resources(group);
11349e5da854Sdougm } else {
11359e5da854Sdougm (void) printf(
11369e5da854Sdougm gettext("Protocol requires resource names to be "
11379e5da854Sdougm "set: %s\n"), protocol);
11389e5da854Sdougm return (SA_RESOURCE_REQUIRED);
11399e5da854Sdougm }
11409e5da854Sdougm }
11419e5da854Sdougm return (SA_OK);
11429e5da854Sdougm }
11439e5da854Sdougm
11449e5da854Sdougm /*
11459e5da854Sdougm * set_all_protocols(group)
11469e5da854Sdougm *
11479e5da854Sdougm * Get the list of all protocols and add all server protocols to the
11489e5da854Sdougm * group.
11499e5da854Sdougm */
11509e5da854Sdougm
11519e5da854Sdougm static int
set_all_protocols(sa_group_t group)11529e5da854Sdougm set_all_protocols(sa_group_t group)
11539e5da854Sdougm {
11549e5da854Sdougm char **protolist;
11559e5da854Sdougm int numprotos, i;
11569e5da854Sdougm uint64_t features;
11579e5da854Sdougm sa_optionset_t optionset;
11589e5da854Sdougm int ret = SA_OK;
11599e5da854Sdougm
11609e5da854Sdougm /*
11619e5da854Sdougm * Now make sure we really want to put this protocol on a
11629e5da854Sdougm * group. Only server protocols can go here.
11639e5da854Sdougm */
11649e5da854Sdougm numprotos = sa_get_protocols(&protolist);
11659e5da854Sdougm for (i = 0; i < numprotos; i++) {
11669e5da854Sdougm features = sa_proto_get_featureset(protolist[i]);
11679e5da854Sdougm if (features & SA_FEATURE_SERVER) {
11689e5da854Sdougm optionset = sa_create_optionset(group, protolist[i]);
11699e5da854Sdougm if (optionset == NULL) {
11709e5da854Sdougm ret = SA_NO_MEMORY;
11719e5da854Sdougm break;
11729e5da854Sdougm }
11739e5da854Sdougm }
11749e5da854Sdougm }
11759e5da854Sdougm
11769e5da854Sdougm if (protolist != NULL)
11779e5da854Sdougm free(protolist);
11789e5da854Sdougm
11799e5da854Sdougm return (ret);
11809e5da854Sdougm }
11819e5da854Sdougm
11826185db85Sdougm /*
11836185db85Sdougm * sa_create(flags, argc, argv)
11846185db85Sdougm * create a new group
11856185db85Sdougm * this may or may not have a protocol associated with it.
11866185db85Sdougm * No protocol means "all" protocols in this case.
11876185db85Sdougm */
11886185db85Sdougm static int
sa_create(sa_handle_t handle,int flags,int argc,char * argv[])1189549ec3ffSdougm sa_create(sa_handle_t handle, int flags, int argc, char *argv[])
11906185db85Sdougm {
11916185db85Sdougm char *groupname;
11926185db85Sdougm
11936185db85Sdougm sa_group_t group;
11949e5da854Sdougm boolean_t force = B_FALSE;
11959e5da854Sdougm boolean_t verbose = B_FALSE;
11969e5da854Sdougm boolean_t dryrun = B_FALSE;
11976185db85Sdougm int c;
11986185db85Sdougm char *protocol = NULL;
11996185db85Sdougm int ret = SA_OK;
12006185db85Sdougm struct options *optlist = NULL;
1201e7bab347Sdougm int err = SA_OK;
12026185db85Sdougm int auth;
12039e5da854Sdougm boolean_t created = B_FALSE;
12046185db85Sdougm
1205da6c28aaSamw while ((c = getopt(argc, argv, "?fhvnP:p:")) != EOF) {
120625a68471Sdougm switch (c) {
1207da6c28aaSamw case 'f':
12089e5da854Sdougm force = B_TRUE;
1209da6c28aaSamw break;
121025a68471Sdougm case 'v':
12119e5da854Sdougm verbose = B_TRUE;
121225a68471Sdougm break;
121325a68471Sdougm case 'n':
12149e5da854Sdougm dryrun = B_TRUE;
121525a68471Sdougm break;
121625a68471Sdougm case 'P':
1217da6c28aaSamw if (protocol != NULL) {
1218da6c28aaSamw (void) printf(gettext("Specifying "
1219da6c28aaSamw "multiple protocols "
1220da6c28aaSamw "not supported: %s\n"), protocol);
1221da6c28aaSamw return (SA_SYNTAX_ERR);
1222da6c28aaSamw }
122325a68471Sdougm protocol = optarg;
122425a68471Sdougm if (sa_valid_protocol(protocol))
122525a68471Sdougm break;
122625a68471Sdougm (void) printf(gettext(
122725a68471Sdougm "Invalid protocol specified: %s\n"), protocol);
122825a68471Sdougm return (SA_INVALID_PROTOCOL);
122925a68471Sdougm case 'p':
123025a68471Sdougm ret = add_opt(&optlist, optarg, 0);
123125a68471Sdougm switch (ret) {
123225a68471Sdougm case OPT_ADD_SYNTAX:
123325a68471Sdougm (void) printf(gettext(
123425a68471Sdougm "Property syntax error for property: %s\n"),
12356185db85Sdougm optarg);
123625a68471Sdougm return (SA_SYNTAX_ERR);
123725a68471Sdougm case OPT_ADD_SECURITY:
123825a68471Sdougm (void) printf(gettext(
123925a68471Sdougm "Security properties need "
124025a68471Sdougm "to be set with set-security: %s\n"),
12416185db85Sdougm optarg);
124225a68471Sdougm return (SA_SYNTAX_ERR);
124325a68471Sdougm default:
124425a68471Sdougm break;
124525a68471Sdougm }
124625a68471Sdougm break;
124725a68471Sdougm case 'h':
1248e7bab347Sdougm /* optopt on valid arg isn't defined */
1249e7bab347Sdougm optopt = c;
1250e7bab347Sdougm /*FALLTHROUGH*/
125125a68471Sdougm case '?':
1252e7bab347Sdougm default:
1253e7bab347Sdougm /*
1254e7bab347Sdougm * Since a bad option gets to here, sort it
1255e7bab347Sdougm * out and return a syntax error return value
1256e7bab347Sdougm * if necessary.
1257e7bab347Sdougm */
1258e7bab347Sdougm switch (optopt) {
1259e7bab347Sdougm default:
1260e7bab347Sdougm err = SA_SYNTAX_ERR;
1261e7bab347Sdougm break;
1262e7bab347Sdougm case 'h':
1263e7bab347Sdougm case '?':
1264e7bab347Sdougm break;
1265e7bab347Sdougm }
126625a68471Sdougm (void) printf(gettext("usage: %s\n"),
126725a68471Sdougm sa_get_usage(USAGE_CREATE));
1268e7bab347Sdougm return (err);
12696185db85Sdougm }
12706185db85Sdougm }
12716185db85Sdougm
12726185db85Sdougm if (optind >= argc) {
127325a68471Sdougm (void) printf(gettext("usage: %s\n"),
127425a68471Sdougm sa_get_usage(USAGE_CREATE));
127525a68471Sdougm (void) printf(gettext("\tgroup must be specified.\n"));
127625a68471Sdougm return (SA_BAD_PATH);
12776185db85Sdougm }
12786185db85Sdougm
12796185db85Sdougm if ((optind + 1) < argc) {
128025a68471Sdougm (void) printf(gettext("usage: %s\n"),
128125a68471Sdougm sa_get_usage(USAGE_CREATE));
128225a68471Sdougm (void) printf(gettext("\textraneous group(s) at end\n"));
128325a68471Sdougm return (SA_SYNTAX_ERR);
12846185db85Sdougm }
12856185db85Sdougm
12866185db85Sdougm if (protocol == NULL && optlist != NULL) {
128725a68471Sdougm /* lookup default protocol */
128825a68471Sdougm (void) printf(gettext("usage: %s\n"),
128925a68471Sdougm sa_get_usage(USAGE_CREATE));
129025a68471Sdougm (void) printf(gettext("\tprotocol must be specified "
129125a68471Sdougm "with properties\n"));
129225a68471Sdougm return (SA_INVALID_PROTOCOL);
12936185db85Sdougm }
12946185db85Sdougm
12956185db85Sdougm if (optlist != NULL)
129625a68471Sdougm ret = chk_opt(optlist, 0, protocol);
12976185db85Sdougm if (ret == OPT_ADD_SECURITY) {
129825a68471Sdougm (void) printf(gettext("Security properties not "
129925a68471Sdougm "supported with create\n"));
130025a68471Sdougm return (SA_SYNTAX_ERR);
13016185db85Sdougm }
13026185db85Sdougm
13036185db85Sdougm /*
130425a68471Sdougm * If a group already exists, we can only add a new protocol
13056185db85Sdougm * to it and not create a new one or add the same protocol
13066185db85Sdougm * again.
13076185db85Sdougm */
13086185db85Sdougm
13096185db85Sdougm groupname = argv[optind];
13106185db85Sdougm
13116185db85Sdougm auth = check_authorizations(groupname, flags);
13126185db85Sdougm
1313549ec3ffSdougm group = sa_get_group(handle, groupname);
13146185db85Sdougm if (group != NULL) {
131525a68471Sdougm /* group exists so must be a protocol add */
13169e5da854Sdougm ret = check_valid_group(group, groupname, protocol);
13176185db85Sdougm } else {
13186185db85Sdougm /*
13196185db85Sdougm * is it a valid name? Must comply with SMF instance
13206185db85Sdougm * name restrictions.
13216185db85Sdougm */
132225a68471Sdougm if (!sa_valid_group_name(groupname)) {
132325a68471Sdougm ret = SA_INVALID_NAME;
132425a68471Sdougm (void) printf(gettext("Invalid group name: %s\n"),
132525a68471Sdougm groupname);
132625a68471Sdougm }
13276185db85Sdougm }
13286185db85Sdougm if (ret == SA_OK) {
132925a68471Sdougm /* check protocol vs optlist */
133025a68471Sdougm if (optlist != NULL) {
133125a68471Sdougm /* check options, if any, for validity */
1332687915e9Sdougm ret = valid_options(handle, optlist, protocol,
1333687915e9Sdougm group, NULL);
133425a68471Sdougm }
13356185db85Sdougm }
13366185db85Sdougm if (ret == SA_OK && !dryrun) {
133725a68471Sdougm if (group == NULL) {
133825a68471Sdougm group = sa_create_group(handle, (char *)groupname,
133925a68471Sdougm &err);
13409e5da854Sdougm created = B_TRUE;
13416185db85Sdougm }
134225a68471Sdougm if (group != NULL) {
134325a68471Sdougm sa_optionset_t optionset;
13449e5da854Sdougm
1345da6c28aaSamw /*
13469e5da854Sdougm * Check group and protocol against featureset
13479e5da854Sdougm * requirements.
1348da6c28aaSamw */
13499e5da854Sdougm ret = enforce_featureset(group, protocol,
13509e5da854Sdougm dryrun, force);
13519e5da854Sdougm if (ret != SA_OK)
13529e5da854Sdougm goto err;
1353da6c28aaSamw
13549e5da854Sdougm /*
13559e5da854Sdougm * So far so good. Now add the required
13569e5da854Sdougm * optionset(s) to the group.
13579e5da854Sdougm */
135825a68471Sdougm if (optlist != NULL) {
135925a68471Sdougm (void) add_optionset(group, optlist, protocol,
136025a68471Sdougm &ret);
136125a68471Sdougm } else if (protocol != NULL) {
136225a68471Sdougm optionset = sa_create_optionset(group,
136325a68471Sdougm protocol);
136425a68471Sdougm if (optionset == NULL)
136525a68471Sdougm ret = SA_NO_MEMORY;
136625a68471Sdougm } else if (protocol == NULL) {
13679e5da854Sdougm /* default group create so add all protocols */
13689e5da854Sdougm ret = set_all_protocols(group);
136925a68471Sdougm }
13706185db85Sdougm /*
137125a68471Sdougm * We have a group and legal additions
13726185db85Sdougm */
137325a68471Sdougm if (ret == SA_OK) {
137425a68471Sdougm /*
137525a68471Sdougm * Commit to configuration for protocols that
137625a68471Sdougm * need to do block updates. For NFS, this
137725a68471Sdougm * doesn't do anything but it will be run for
137825a68471Sdougm * all protocols that implement the
137925a68471Sdougm * appropriate plugin.
138025a68471Sdougm */
138125a68471Sdougm ret = sa_update_config(handle);
138225a68471Sdougm } else {
138325a68471Sdougm if (group != NULL)
138425a68471Sdougm (void) sa_remove_group(group);
138525a68471Sdougm }
13866185db85Sdougm } else {
138725a68471Sdougm ret = err;
138825a68471Sdougm (void) printf(gettext("Could not create group: %s\n"),
138925a68471Sdougm sa_errorstr(ret));
13906185db85Sdougm }
13916185db85Sdougm }
13926185db85Sdougm if (dryrun && ret == SA_OK && !auth && verbose) {
139325a68471Sdougm (void) printf(gettext("Command would fail: %s\n"),
139425a68471Sdougm sa_errorstr(SA_NO_PERMISSION));
139525a68471Sdougm ret = SA_NO_PERMISSION;
13966185db85Sdougm }
1397da6c28aaSamw err:
13989e5da854Sdougm if (ret != SA_OK && created)
13999e5da854Sdougm ret = sa_remove_group(group);
14009e5da854Sdougm
14016185db85Sdougm free_opt(optlist);
14026185db85Sdougm return (ret);
14036185db85Sdougm }
14046185db85Sdougm
14056185db85Sdougm /*
14066185db85Sdougm * group_status(group)
14076185db85Sdougm *
14086185db85Sdougm * return the current status (enabled/disabled) of the group.
14096185db85Sdougm */
14106185db85Sdougm
14116185db85Sdougm static char *
group_status(sa_group_t group)14126185db85Sdougm group_status(sa_group_t group)
14136185db85Sdougm {
14146185db85Sdougm char *state;
14156185db85Sdougm int enabled = 0;
14166185db85Sdougm
14176185db85Sdougm state = sa_get_group_attr(group, "state");
14186185db85Sdougm if (state != NULL) {
141925a68471Sdougm if (strcmp(state, "enabled") == 0) {
142025a68471Sdougm enabled = 1;
142125a68471Sdougm }
142225a68471Sdougm sa_free_attr_string(state);
14236185db85Sdougm }
14244db300d5Sdougm return (enabled ? "enabled" : "disabled");
14256185db85Sdougm }
14266185db85Sdougm
14276185db85Sdougm /*
14286185db85Sdougm * sa_delete(flags, argc, argv)
14296185db85Sdougm *
14306185db85Sdougm * Delete a group.
14316185db85Sdougm */
14326185db85Sdougm
14336185db85Sdougm static int
sa_delete(sa_handle_t handle,int flags,int argc,char * argv[])1434549ec3ffSdougm sa_delete(sa_handle_t handle, int flags, int argc, char *argv[])
14356185db85Sdougm {
14366185db85Sdougm char *groupname;
14376185db85Sdougm sa_group_t group;
14386185db85Sdougm sa_share_t share;
14396185db85Sdougm int verbose = 0;
14406185db85Sdougm int dryrun = 0;
14416185db85Sdougm int force = 0;
14426185db85Sdougm int c;
14436185db85Sdougm char *protocol = NULL;
14446185db85Sdougm char *sectype = NULL;
14456185db85Sdougm int ret = SA_OK;
14466185db85Sdougm int auth;
14476185db85Sdougm
14486185db85Sdougm while ((c = getopt(argc, argv, "?hvnP:fS:")) != EOF) {
144925a68471Sdougm switch (c) {
145025a68471Sdougm case 'v':
145125a68471Sdougm verbose++;
145225a68471Sdougm break;
145325a68471Sdougm case 'n':
145425a68471Sdougm dryrun++;
145525a68471Sdougm break;
145625a68471Sdougm case 'P':
1457da6c28aaSamw if (protocol != NULL) {
1458da6c28aaSamw (void) printf(gettext("Specifying "
1459da6c28aaSamw "multiple protocols "
1460da6c28aaSamw "not supported: %s\n"), protocol);
1461da6c28aaSamw return (SA_SYNTAX_ERR);
1462da6c28aaSamw }
146325a68471Sdougm protocol = optarg;
146425a68471Sdougm if (!sa_valid_protocol(protocol)) {
146525a68471Sdougm (void) printf(gettext("Invalid protocol "
1466da6c28aaSamw "specified: %s\n"), protocol);
146725a68471Sdougm return (SA_INVALID_PROTOCOL);
146825a68471Sdougm }
146925a68471Sdougm break;
147025a68471Sdougm case 'S':
1471da6c28aaSamw if (sectype != NULL) {
1472da6c28aaSamw (void) printf(gettext("Specifying "
1473da6c28aaSamw "multiple property "
1474da6c28aaSamw "spaces not supported: %s\n"), sectype);
1475da6c28aaSamw return (SA_SYNTAX_ERR);
1476da6c28aaSamw }
147725a68471Sdougm sectype = optarg;
147825a68471Sdougm break;
147925a68471Sdougm case 'f':
148025a68471Sdougm force++;
148125a68471Sdougm break;
148225a68471Sdougm case 'h':
1483e7bab347Sdougm /* optopt on valid arg isn't defined */
1484e7bab347Sdougm optopt = c;
1485e7bab347Sdougm /*FALLTHROUGH*/
148625a68471Sdougm case '?':
1487e7bab347Sdougm default:
1488e7bab347Sdougm /*
1489e7bab347Sdougm * Since a bad option gets to here, sort it
1490e7bab347Sdougm * out and return a syntax error return value
1491e7bab347Sdougm * if necessary.
1492e7bab347Sdougm */
1493e7bab347Sdougm switch (optopt) {
1494e7bab347Sdougm default:
1495e7bab347Sdougm ret = SA_SYNTAX_ERR;
1496e7bab347Sdougm break;
1497e7bab347Sdougm case 'h':
1498e7bab347Sdougm case '?':
1499e7bab347Sdougm break;
1500e7bab347Sdougm }
150125a68471Sdougm (void) printf(gettext("usage: %s\n"),
150225a68471Sdougm sa_get_usage(USAGE_DELETE));
1503e7bab347Sdougm return (ret);
15046185db85Sdougm }
15056185db85Sdougm }
15066185db85Sdougm
15076185db85Sdougm if (optind >= argc) {
150825a68471Sdougm (void) printf(gettext("usage: %s\n"),
150925a68471Sdougm sa_get_usage(USAGE_DELETE));
151025a68471Sdougm (void) printf(gettext("\tgroup must be specified.\n"));
151125a68471Sdougm return (SA_SYNTAX_ERR);
15126185db85Sdougm }
15136185db85Sdougm
15146185db85Sdougm if ((optind + 1) < argc) {
151525a68471Sdougm (void) printf(gettext("usage: %s\n"),
151625a68471Sdougm sa_get_usage(USAGE_DELETE));
151725a68471Sdougm (void) printf(gettext("\textraneous group(s) at end\n"));
151825a68471Sdougm return (SA_SYNTAX_ERR);
15196185db85Sdougm }
15206185db85Sdougm
15216185db85Sdougm if (sectype != NULL && protocol == NULL) {
152225a68471Sdougm (void) printf(gettext("usage: %s\n"),
152325a68471Sdougm sa_get_usage(USAGE_DELETE));
152425a68471Sdougm (void) printf(gettext("\tsecurity requires protocol to be "
152525a68471Sdougm "specified.\n"));
152625a68471Sdougm return (SA_SYNTAX_ERR);
15276185db85Sdougm }
15286185db85Sdougm
15296185db85Sdougm /*
15306185db85Sdougm * Determine if the group already exists since it must in
15316185db85Sdougm * order to be removed.
15326185db85Sdougm *
15336185db85Sdougm * We can delete when:
15346185db85Sdougm *
15356185db85Sdougm * - group is empty
15366185db85Sdougm * - force flag is set
15376185db85Sdougm * - if protocol specified, only delete the protocol
15386185db85Sdougm */
15396185db85Sdougm
15406185db85Sdougm groupname = argv[optind];
1541549ec3ffSdougm group = sa_get_group(handle, groupname);
15426185db85Sdougm if (group == NULL) {
15436185db85Sdougm ret = SA_NO_SUCH_GROUP;
154425a68471Sdougm goto done;
154525a68471Sdougm }
154625a68471Sdougm auth = check_authorizations(groupname, flags);
154725a68471Sdougm if (protocol == NULL) {
15486185db85Sdougm share = sa_get_share(group, NULL);
15496185db85Sdougm if (share != NULL)
155025a68471Sdougm ret = SA_BUSY;
15516185db85Sdougm if (share == NULL || (share != NULL && force == 1)) {
155225a68471Sdougm ret = SA_OK;
155325a68471Sdougm if (!dryrun) {
155425a68471Sdougm while (share != NULL) {
155525a68471Sdougm sa_share_t next_share;
155625a68471Sdougm next_share = sa_get_next_share(share);
155725a68471Sdougm /*
155825a68471Sdougm * need to do the disable of
155925a68471Sdougm * each share, but don't
156025a68471Sdougm * actually do anything on a
156125a68471Sdougm * dryrun.
156225a68471Sdougm */
156325a68471Sdougm ret = sa_disable_share(share, NULL);
156425a68471Sdougm ret = sa_remove_share(share);
156525a68471Sdougm share = next_share;
156625a68471Sdougm }
156725a68471Sdougm ret = sa_remove_group(group);
15686185db85Sdougm }
15696185db85Sdougm }
157025a68471Sdougm /* Commit to configuration if not a dryrun */
15716185db85Sdougm if (!dryrun && ret == SA_OK) {
157225a68471Sdougm ret = sa_update_config(handle);
15736185db85Sdougm }
157425a68471Sdougm } else {
15756185db85Sdougm /* a protocol delete */
15766185db85Sdougm sa_optionset_t optionset;
15776185db85Sdougm sa_security_t security;
1578da6c28aaSamw if (sectype != NULL) {
157925a68471Sdougm /* only delete specified security */
158025a68471Sdougm security = sa_get_security(group, sectype, protocol);
158125a68471Sdougm if (security != NULL && !dryrun)
15826185db85Sdougm ret = sa_destroy_security(security);
158325a68471Sdougm else
158425a68471Sdougm ret = SA_INVALID_PROTOCOL;
158525a68471Sdougm } else {
158625a68471Sdougm optionset = sa_get_optionset(group, protocol);
158725a68471Sdougm if (optionset != NULL && !dryrun) {
158825a68471Sdougm /*
158925a68471Sdougm * have an optionset with
159025a68471Sdougm * protocol to delete
159125a68471Sdougm */
159225a68471Sdougm ret = sa_destroy_optionset(optionset);
159325a68471Sdougm /*
159425a68471Sdougm * Now find all security sets
159525a68471Sdougm * for the protocol and remove
159625a68471Sdougm * them. Don't remove other
159725a68471Sdougm * protocols.
159825a68471Sdougm */
159925a68471Sdougm for (security =
160025a68471Sdougm sa_get_security(group, NULL, NULL);
160125a68471Sdougm ret == SA_OK && security != NULL;
160225a68471Sdougm security = sa_get_next_security(security)) {
160325a68471Sdougm char *secprot;
160425a68471Sdougm secprot = sa_get_security_attr(security,
160525a68471Sdougm "type");
160625a68471Sdougm if (secprot != NULL &&
160725a68471Sdougm strcmp(secprot, protocol) == 0)
160825a68471Sdougm ret = sa_destroy_security(
160925a68471Sdougm security);
161025a68471Sdougm if (secprot != NULL)
161125a68471Sdougm sa_free_attr_string(secprot);
161225a68471Sdougm }
161325a68471Sdougm } else {
161425a68471Sdougm if (!dryrun)
161525a68471Sdougm ret = SA_INVALID_PROTOCOL;
16166185db85Sdougm }
16176185db85Sdougm }
1618da6c28aaSamw /*
1619da6c28aaSamw * With the protocol items removed, make sure that all
1620da6c28aaSamw * the shares are updated in the legacy files, if
1621da6c28aaSamw * necessary.
1622da6c28aaSamw */
1623da6c28aaSamw for (share = sa_get_share(group, NULL);
1624da6c28aaSamw share != NULL;
1625da6c28aaSamw share = sa_get_next_share(share)) {
1626da6c28aaSamw (void) sa_delete_legacy(share, protocol);
1627da6c28aaSamw }
16286185db85Sdougm }
162925a68471Sdougm
163025a68471Sdougm done:
16316185db85Sdougm if (ret != SA_OK) {
163225a68471Sdougm (void) printf(gettext("Could not delete group: %s\n"),
163325a68471Sdougm sa_errorstr(ret));
16346185db85Sdougm } else if (dryrun && !auth && verbose) {
163525a68471Sdougm (void) printf(gettext("Command would fail: %s\n"),
163625a68471Sdougm sa_errorstr(SA_NO_PERMISSION));
16376185db85Sdougm }
16386185db85Sdougm return (ret);
16396185db85Sdougm }
16406185db85Sdougm
16416185db85Sdougm /*
16426185db85Sdougm * strndupr(*buff, str, buffsize)
16436185db85Sdougm *
16446185db85Sdougm * used with small strings to duplicate and possibly increase the
16456185db85Sdougm * buffer size of a string.
16466185db85Sdougm */
16476185db85Sdougm static char *
strndupr(char * buff,char * str,int * buffsize)16486185db85Sdougm strndupr(char *buff, char *str, int *buffsize)
16496185db85Sdougm {
16506185db85Sdougm int limit;
16516185db85Sdougm char *orig_buff = buff;
16526185db85Sdougm
16536185db85Sdougm if (buff == NULL) {
165425a68471Sdougm buff = (char *)malloc(64);
165525a68471Sdougm if (buff == NULL)
165625a68471Sdougm return (NULL);
165725a68471Sdougm *buffsize = 64;
165825a68471Sdougm buff[0] = '\0';
16596185db85Sdougm }
16606185db85Sdougm limit = strlen(buff) + strlen(str) + 1;
16616185db85Sdougm if (limit > *buffsize) {
166225a68471Sdougm limit = *buffsize = *buffsize + ((limit / 64) + 64);
166325a68471Sdougm buff = realloc(buff, limit);
16646185db85Sdougm }
16656185db85Sdougm if (buff != NULL) {
166625a68471Sdougm (void) strcat(buff, str);
16676185db85Sdougm } else {
166825a68471Sdougm /* if it fails, fail it hard */
166925a68471Sdougm if (orig_buff != NULL)
167025a68471Sdougm free(orig_buff);
16716185db85Sdougm }
16726185db85Sdougm return (buff);
16736185db85Sdougm }
16746185db85Sdougm
16756185db85Sdougm /*
16766185db85Sdougm * group_proto(group)
16776185db85Sdougm *
16786185db85Sdougm * return a string of all the protocols (space separated) associated
16796185db85Sdougm * with this group.
16806185db85Sdougm */
16816185db85Sdougm
16826185db85Sdougm static char *
group_proto(sa_group_t group)16836185db85Sdougm group_proto(sa_group_t group)
16846185db85Sdougm {
16856185db85Sdougm sa_optionset_t optionset;
16866185db85Sdougm char *proto;
16876185db85Sdougm char *buff = NULL;
16886185db85Sdougm int buffsize = 0;
16896185db85Sdougm int addspace = 0;
16906185db85Sdougm /*
16916185db85Sdougm * get the protocol list by finding the optionsets on this
16926185db85Sdougm * group and extracting the type value. The initial call to
16936185db85Sdougm * strndupr() initailizes buff.
16946185db85Sdougm */
16956185db85Sdougm buff = strndupr(buff, "", &buffsize);
16966185db85Sdougm if (buff != NULL) {
169725a68471Sdougm for (optionset = sa_get_optionset(group, NULL);
169825a68471Sdougm optionset != NULL && buff != NULL;
169925a68471Sdougm optionset = sa_get_next_optionset(optionset)) {
170025a68471Sdougm /*
170125a68471Sdougm * extract out the protocol type from this optionset
170225a68471Sdougm * and append it to the buffer "buff". strndupr() will
170325a68471Sdougm * reallocate space as necessay.
170425a68471Sdougm */
170525a68471Sdougm proto = sa_get_optionset_attr(optionset, "type");
170625a68471Sdougm if (proto != NULL) {
170725a68471Sdougm if (addspace++)
170825a68471Sdougm buff = strndupr(buff, " ", &buffsize);
170925a68471Sdougm buff = strndupr(buff, proto, &buffsize);
171025a68471Sdougm sa_free_attr_string(proto);
171125a68471Sdougm }
17126185db85Sdougm }
17136185db85Sdougm }
17146185db85Sdougm return (buff);
17156185db85Sdougm }
17166185db85Sdougm
17176185db85Sdougm /*
17186185db85Sdougm * sa_list(flags, argc, argv)
17196185db85Sdougm *
17206185db85Sdougm * implements the "list" subcommand to list groups and optionally
17216185db85Sdougm * their state and protocols.
17226185db85Sdougm */
17236185db85Sdougm
17246185db85Sdougm static int
sa_list(sa_handle_t handle,int flags,int argc,char * argv[])1725549ec3ffSdougm sa_list(sa_handle_t handle, int flags, int argc, char *argv[])
17266185db85Sdougm {
17276185db85Sdougm sa_group_t group;
17286185db85Sdougm int verbose = 0;
17296185db85Sdougm int c;
17306185db85Sdougm char *protocol = NULL;
1731e7bab347Sdougm int ret = SA_OK;
1732da6c28aaSamw #ifdef lint
1733da6c28aaSamw flags = flags;
1734da6c28aaSamw #endif
17356185db85Sdougm
17366185db85Sdougm while ((c = getopt(argc, argv, "?hvP:")) != EOF) {
173725a68471Sdougm switch (c) {
173825a68471Sdougm case 'v':
173925a68471Sdougm verbose++;
174025a68471Sdougm break;
174125a68471Sdougm case 'P':
1742da6c28aaSamw if (protocol != NULL) {
1743da6c28aaSamw (void) printf(gettext(
1744da6c28aaSamw "Specifying multiple protocols "
1745da6c28aaSamw "not supported: %s\n"),
1746da6c28aaSamw protocol);
1747da6c28aaSamw return (SA_SYNTAX_ERR);
1748da6c28aaSamw }
174925a68471Sdougm protocol = optarg;
175025a68471Sdougm if (!sa_valid_protocol(protocol)) {
175125a68471Sdougm (void) printf(gettext(
175225a68471Sdougm "Invalid protocol specified: %s\n"),
175325a68471Sdougm protocol);
175425a68471Sdougm return (SA_INVALID_PROTOCOL);
175525a68471Sdougm }
175625a68471Sdougm break;
175725a68471Sdougm case 'h':
1758e7bab347Sdougm /* optopt on valid arg isn't defined */
1759e7bab347Sdougm optopt = c;
1760e7bab347Sdougm /*FALLTHROUGH*/
176125a68471Sdougm case '?':
1762e7bab347Sdougm default:
1763e7bab347Sdougm /*
1764e7bab347Sdougm * Since a bad option gets to here, sort it
1765e7bab347Sdougm * out and return a syntax error return value
1766e7bab347Sdougm * if necessary.
1767e7bab347Sdougm */
1768e7bab347Sdougm switch (optopt) {
1769e7bab347Sdougm default:
1770e7bab347Sdougm ret = SA_SYNTAX_ERR;
1771e7bab347Sdougm break;
1772e7bab347Sdougm case 'h':
1773e7bab347Sdougm case '?':
1774e7bab347Sdougm break;
1775e7bab347Sdougm }
177625a68471Sdougm (void) printf(gettext("usage: %s\n"),
177725a68471Sdougm sa_get_usage(USAGE_LIST));
1778a8cc26d6SJohn Levon return (ret);
17796185db85Sdougm }
17806185db85Sdougm }
17816185db85Sdougm
1782573b0c00Sdougm if (optind != argc) {
1783573b0c00Sdougm (void) printf(gettext("usage: %s\n"),
1784573b0c00Sdougm sa_get_usage(USAGE_LIST));
1785573b0c00Sdougm return (SA_SYNTAX_ERR);
1786573b0c00Sdougm }
1787573b0c00Sdougm
178825a68471Sdougm for (group = sa_get_group(handle, NULL);
178925a68471Sdougm group != NULL;
17906185db85Sdougm group = sa_get_next_group(group)) {
179125a68471Sdougm char *name;
179225a68471Sdougm char *proto;
179325a68471Sdougm if (protocol == NULL || has_protocol(group, protocol)) {
179425a68471Sdougm name = sa_get_group_attr(group, "name");
179525a68471Sdougm if (name != NULL && (verbose > 1 || name[0] != '#')) {
179625a68471Sdougm (void) printf("%s", (char *)name);
179725a68471Sdougm if (verbose) {
179825a68471Sdougm /*
179925a68471Sdougm * Need the list of protocols
180025a68471Sdougm * and current status once
180125a68471Sdougm * available. We do want to
180225a68471Sdougm * translate the
180325a68471Sdougm * enabled/disabled text here.
180425a68471Sdougm */
180525a68471Sdougm (void) printf("\t%s", isenabled(group) ?
180625a68471Sdougm gettext("enabled") :
180725a68471Sdougm gettext("disabled"));
180825a68471Sdougm proto = group_proto(group);
180925a68471Sdougm if (proto != NULL) {
181025a68471Sdougm (void) printf("\t%s",
181125a68471Sdougm (char *)proto);
181225a68471Sdougm free(proto);
181325a68471Sdougm }
181425a68471Sdougm }
181525a68471Sdougm (void) printf("\n");
18166185db85Sdougm }
181725a68471Sdougm if (name != NULL)
181825a68471Sdougm sa_free_attr_string(name);
18196185db85Sdougm }
18206185db85Sdougm }
18216185db85Sdougm return (0);
18226185db85Sdougm }
18236185db85Sdougm
18246185db85Sdougm /*
18256185db85Sdougm * out_properties(optionset, proto, sec)
18266185db85Sdougm *
18276185db85Sdougm * Format the properties and encode the protocol and optional named
18286185db85Sdougm * optionset into the string.
18296185db85Sdougm *
18306185db85Sdougm * format is protocol[:name]=(property-list)
18316185db85Sdougm */
18326185db85Sdougm
18336185db85Sdougm static void
out_properties(sa_optionset_t optionset,char * proto,char * sec)18346185db85Sdougm out_properties(sa_optionset_t optionset, char *proto, char *sec)
18356185db85Sdougm {
18366185db85Sdougm char *type;
18376185db85Sdougm char *value;
18386185db85Sdougm int spacer;
18396185db85Sdougm sa_property_t prop;
18406185db85Sdougm
184125a68471Sdougm if (sec == NULL)
184225a68471Sdougm (void) printf(" %s=(", proto ? proto : gettext("all"));
184325a68471Sdougm else
184425a68471Sdougm (void) printf(" %s:%s=(", proto ? proto : gettext("all"), sec);
18456185db85Sdougm
18466185db85Sdougm for (spacer = 0, prop = sa_get_property(optionset, NULL);
184725a68471Sdougm prop != NULL;
184825a68471Sdougm prop = sa_get_next_property(prop)) {
18496185db85Sdougm
18506185db85Sdougm /*
18516185db85Sdougm * extract the property name/value and output with
18526185db85Sdougm * appropriate spacing. I.e. no prefixed space the
18536185db85Sdougm * first time through but a space on subsequent
18546185db85Sdougm * properties.
18556185db85Sdougm */
185625a68471Sdougm type = sa_get_property_attr(prop, "type");
185725a68471Sdougm value = sa_get_property_attr(prop, "value");
185825a68471Sdougm if (type != NULL) {
185925a68471Sdougm (void) printf("%s%s=", spacer ? " " : "", type);
186025a68471Sdougm spacer = 1;
186125a68471Sdougm if (value != NULL)
186225a68471Sdougm (void) printf("\"%s\"", value);
186325a68471Sdougm else
186425a68471Sdougm (void) printf("\"\"");
186525a68471Sdougm }
186625a68471Sdougm if (type != NULL)
186725a68471Sdougm sa_free_attr_string(type);
18686185db85Sdougm if (value != NULL)
186925a68471Sdougm sa_free_attr_string(value);
18706185db85Sdougm }
18716185db85Sdougm (void) printf(")");
18726185db85Sdougm }
18736185db85Sdougm
18746185db85Sdougm /*
18756185db85Sdougm * show_properties(group, protocol, prefix)
18766185db85Sdougm *
18776185db85Sdougm * print the properties for a group. If protocol is NULL, do all
18786185db85Sdougm * protocols otherwise only the specified protocol. All security
18796185db85Sdougm * (named groups specific to the protocol) are included.
18806185db85Sdougm *
18816185db85Sdougm * The "prefix" is always applied. The caller knows whether it wants
18826185db85Sdougm * some type of prefix string (white space) or not. Once the prefix
18836185db85Sdougm * has been output, it is reduced to the zero length string for the
18846185db85Sdougm * remainder of the property output.
18856185db85Sdougm */
18866185db85Sdougm
18876185db85Sdougm static void
show_properties(sa_group_t group,char * protocol,char * prefix)18886185db85Sdougm show_properties(sa_group_t group, char *protocol, char *prefix)
18896185db85Sdougm {
18906185db85Sdougm sa_optionset_t optionset;
18916185db85Sdougm sa_security_t security;
18926185db85Sdougm char *value;
18936185db85Sdougm char *secvalue;
18946185db85Sdougm
18956185db85Sdougm if (protocol != NULL) {
189625a68471Sdougm optionset = sa_get_optionset(group, protocol);
189725a68471Sdougm if (optionset != NULL) {
189825a68471Sdougm (void) printf("%s", prefix);
189925a68471Sdougm prefix = "";
190025a68471Sdougm out_properties(optionset, protocol, NULL);
190125a68471Sdougm }
190225a68471Sdougm security = sa_get_security(group, protocol, NULL);
190325a68471Sdougm if (security != NULL) {
190425a68471Sdougm (void) printf("%s", prefix);
190525a68471Sdougm prefix = "";
190625a68471Sdougm out_properties(security, protocol, NULL);
190725a68471Sdougm }
19086185db85Sdougm } else {
190925a68471Sdougm for (optionset = sa_get_optionset(group, protocol);
191025a68471Sdougm optionset != NULL;
191125a68471Sdougm optionset = sa_get_next_optionset(optionset)) {
191225a68471Sdougm
191325a68471Sdougm value = sa_get_optionset_attr(optionset, "type");
191425a68471Sdougm (void) printf("%s", prefix);
191525a68471Sdougm prefix = "";
191625a68471Sdougm out_properties(optionset, value, 0);
191725a68471Sdougm if (value != NULL)
191825a68471Sdougm sa_free_attr_string(value);
191925a68471Sdougm }
192025a68471Sdougm for (security = sa_get_security(group, NULL, protocol);
192125a68471Sdougm security != NULL;
192225a68471Sdougm security = sa_get_next_security(security)) {
192325a68471Sdougm
192425a68471Sdougm value = sa_get_security_attr(security, "type");
192525a68471Sdougm secvalue = sa_get_security_attr(security, "sectype");
192625a68471Sdougm (void) printf("%s", prefix);
192725a68471Sdougm prefix = "";
192825a68471Sdougm out_properties(security, value, secvalue);
192925a68471Sdougm if (value != NULL)
193025a68471Sdougm sa_free_attr_string(value);
193125a68471Sdougm if (secvalue != NULL)
193225a68471Sdougm sa_free_attr_string(secvalue);
193325a68471Sdougm }
19346185db85Sdougm }
19356185db85Sdougm }
19366185db85Sdougm
1937da6c28aaSamw /*
1938da6c28aaSamw * get_resource(share)
1939da6c28aaSamw *
1940da6c28aaSamw * Get the first resource name, if any, and fix string to be in
1941da6c28aaSamw * current locale and have quotes if it has embedded spaces. Return
1942da6c28aaSamw * an attr string that must be freed.
1943da6c28aaSamw */
1944da6c28aaSamw
1945da6c28aaSamw static char *
get_resource(sa_share_t share)1946da6c28aaSamw get_resource(sa_share_t share)
1947da6c28aaSamw {
1948da6c28aaSamw sa_resource_t resource;
1949da6c28aaSamw char *resstring = NULL;
1950da6c28aaSamw char *retstring;
1951da6c28aaSamw
1952da6c28aaSamw if ((resource = sa_get_share_resource(share, NULL)) != NULL) {
1953da6c28aaSamw resstring = sa_get_resource_attr(resource, "name");
1954da6c28aaSamw if (resstring != NULL) {
1955da6c28aaSamw char *cp;
1956da6c28aaSamw int len;
1957da6c28aaSamw
1958da6c28aaSamw retstring = conv_from_utf8(resstring);
1959da6c28aaSamw if (retstring != resstring) {
1960da6c28aaSamw sa_free_attr_string(resstring);
1961da6c28aaSamw resstring = retstring;
1962da6c28aaSamw }
1963da6c28aaSamw if (strpbrk(resstring, " ") != NULL) {
1964da6c28aaSamw /* account for quotes */
1965da6c28aaSamw len = strlen(resstring) + 3;
1966da6c28aaSamw cp = calloc(len, sizeof (char));
1967da6c28aaSamw if (cp != NULL) {
1968da6c28aaSamw (void) snprintf(cp, len,
1969da6c28aaSamw "\"%s\"", resstring);
1970da6c28aaSamw sa_free_attr_string(resstring);
1971da6c28aaSamw resstring = cp;
1972da6c28aaSamw } else {
1973da6c28aaSamw sa_free_attr_string(resstring);
1974da6c28aaSamw resstring = NULL;
1975da6c28aaSamw }
1976da6c28aaSamw }
1977da6c28aaSamw }
1978da6c28aaSamw }
1979da6c28aaSamw return (resstring);
1980da6c28aaSamw }
1981da6c28aaSamw
1982da6c28aaSamw /*
1983da6c28aaSamw * has_resource_with_opt(share)
1984da6c28aaSamw *
1985da6c28aaSamw * Check to see if the share has any resource names with optionsets
1986da6c28aaSamw * set. Also indicate if multiple resource names since the syntax
1987da6c28aaSamw * would be about the same.
1988da6c28aaSamw */
1989da6c28aaSamw static int
has_resource_with_opt(sa_share_t share)1990da6c28aaSamw has_resource_with_opt(sa_share_t share)
1991da6c28aaSamw {
1992da6c28aaSamw sa_resource_t resource;
1993da6c28aaSamw int ret = B_FALSE;
1994da6c28aaSamw
1995da6c28aaSamw for (resource = sa_get_share_resource(share, NULL);
1996da6c28aaSamw resource != NULL;
1997da6c28aaSamw resource = sa_get_next_resource(resource)) {
1998da6c28aaSamw
1999da6c28aaSamw if (sa_get_optionset(resource, NULL) != NULL) {
2000da6c28aaSamw ret = B_TRUE;
2001da6c28aaSamw break;
2002da6c28aaSamw }
2003da6c28aaSamw }
2004da6c28aaSamw return (ret);
2005da6c28aaSamw }
2006da6c28aaSamw
2007da6c28aaSamw /*
2008da6c28aaSamw * has_multiple_resource(share)
2009da6c28aaSamw *
2010573b0c00Sdougm * Check to see if the share has multiple resource names since
2011573b0c00Sdougm * the syntax would be about the same.
2012da6c28aaSamw */
2013573b0c00Sdougm static boolean_t
has_multiple_resource(sa_share_t share)2014da6c28aaSamw has_multiple_resource(sa_share_t share)
2015da6c28aaSamw {
2016da6c28aaSamw sa_resource_t resource;
2017da6c28aaSamw int num;
2018da6c28aaSamw
2019da6c28aaSamw for (num = 0, resource = sa_get_share_resource(share, NULL);
2020da6c28aaSamw resource != NULL;
2021da6c28aaSamw resource = sa_get_next_resource(resource)) {
2022da6c28aaSamw num++;
2023da6c28aaSamw if (num > 1)
2024da6c28aaSamw return (B_TRUE);
2025da6c28aaSamw }
2026da6c28aaSamw return (B_FALSE);
2027da6c28aaSamw }
2028da6c28aaSamw
2029da6c28aaSamw /*
2030da6c28aaSamw * show_share(share, verbose, properties, proto, iszfs, sharepath)
2031da6c28aaSamw *
2032da6c28aaSamw * print out the share information. With the addition of resource as a
2033da6c28aaSamw * full object that can have multiple instances below the share, we
2034da6c28aaSamw * need to display that as well.
2035da6c28aaSamw */
2036da6c28aaSamw
2037da6c28aaSamw static void
show_share(sa_share_t share,int verbose,int properties,char * proto,int iszfs,char * sharepath)2038da6c28aaSamw show_share(sa_share_t share, int verbose, int properties, char *proto,
2039da6c28aaSamw int iszfs, char *sharepath)
2040da6c28aaSamw {
2041da6c28aaSamw char *drive;
2042da6c28aaSamw char *exclude;
2043da6c28aaSamw sa_resource_t resource = NULL;
2044da6c28aaSamw char *description;
2045da6c28aaSamw char *rsrcname;
2046da6c28aaSamw int rsrcwithopt;
2047573b0c00Sdougm boolean_t multiple;
2048da6c28aaSamw char *type;
2049da6c28aaSamw
2050da6c28aaSamw rsrcwithopt = has_resource_with_opt(share);
2051da6c28aaSamw
2052da6c28aaSamw if (verbose || (properties && rsrcwithopt)) {
2053da6c28aaSamw /* First, indicate if transient */
2054da6c28aaSamw type = sa_get_share_attr(share, "type");
2055da6c28aaSamw if (type != NULL && !iszfs && verbose &&
2056da6c28aaSamw strcmp(type, "transient") == 0)
2057da6c28aaSamw (void) printf("\t* ");
2058da6c28aaSamw else
2059da6c28aaSamw (void) printf("\t ");
2060da6c28aaSamw
2061da6c28aaSamw if (type != NULL)
2062da6c28aaSamw sa_free_attr_string(type);
2063da6c28aaSamw
2064da6c28aaSamw /*
2065da6c28aaSamw * If we came in with verbose, we want to handle the case of
2066da6c28aaSamw * multiple resources as though they had properties set.
2067da6c28aaSamw */
2068da6c28aaSamw multiple = has_multiple_resource(share);
2069da6c28aaSamw
2070573b0c00Sdougm /*
2071573b0c00Sdougm * if there is a description on the share and there
2072573b0c00Sdougm * are resources, treat as multiple resources in order
2073573b0c00Sdougm * to get all descriptions displayed.
2074573b0c00Sdougm */
2075573b0c00Sdougm description = sa_get_share_description(share);
2076573b0c00Sdougm resource = sa_get_share_resource(share, NULL);
2077573b0c00Sdougm
2078573b0c00Sdougm if (description != NULL && resource != NULL)
2079573b0c00Sdougm multiple = B_TRUE;
2080573b0c00Sdougm
2081da6c28aaSamw /* Next, if not multiple follow old model */
2082da6c28aaSamw if (!multiple && !rsrcwithopt) {
2083da6c28aaSamw rsrcname = get_resource(share);
2084da6c28aaSamw if (rsrcname != NULL && strlen(rsrcname) > 0) {
2085da6c28aaSamw (void) printf("%s=%s", rsrcname, sharepath);
2086da6c28aaSamw } else {
2087da6c28aaSamw (void) printf("%s", sharepath);
2088da6c28aaSamw }
2089da6c28aaSamw if (rsrcname != NULL)
2090da6c28aaSamw sa_free_attr_string(rsrcname);
2091573b0c00Sdougm /* Print the description string if there is one. */
2092573b0c00Sdougm print_rsrc_desc(resource, description);
2093da6c28aaSamw } else {
2094da6c28aaSamw /* Treat as simple and then resources come later */
2095da6c28aaSamw (void) printf("%s", sharepath);
2096da6c28aaSamw }
2097da6c28aaSamw drive = sa_get_share_attr(share, "drive-letter");
2098da6c28aaSamw if (drive != NULL) {
2099da6c28aaSamw if (strlen(drive) > 0)
2100da6c28aaSamw (void) printf(gettext("\tdrive-letter=\"%s:\""),
2101da6c28aaSamw drive);
2102da6c28aaSamw sa_free_attr_string(drive);
2103da6c28aaSamw }
2104da6c28aaSamw if (properties)
2105da6c28aaSamw show_properties(share, proto, "\t");
2106da6c28aaSamw exclude = sa_get_share_attr(share, "exclude");
2107da6c28aaSamw if (exclude != NULL) {
2108da6c28aaSamw (void) printf(gettext("\tnot-shared-with=[%s]"),
2109da6c28aaSamw exclude);
2110da6c28aaSamw sa_free_attr_string(exclude);
2111da6c28aaSamw }
2112573b0c00Sdougm
2113da6c28aaSamw if (description != NULL) {
2114573b0c00Sdougm print_rsrc_desc((sa_resource_t)share, description);
2115da6c28aaSamw }
2116da6c28aaSamw /*
2117da6c28aaSamw * If there are resource names with options, show them
2118da6c28aaSamw * here, with one line per resource. Resource specific
2119da6c28aaSamw * options are at the end of the line followed by
2120da6c28aaSamw * description, if any.
2121da6c28aaSamw */
2122da6c28aaSamw if (rsrcwithopt || multiple) {
2123da6c28aaSamw for (resource = sa_get_share_resource(share, NULL);
2124da6c28aaSamw resource != NULL;
2125da6c28aaSamw resource = sa_get_next_resource(resource)) {
2126da6c28aaSamw int has_space;
2127da6c28aaSamw char *rsrc;
2128da6c28aaSamw
2129da6c28aaSamw (void) printf("\n\t\t ");
2130da6c28aaSamw rsrcname = sa_get_resource_attr(resource,
2131da6c28aaSamw "name");
2132da6c28aaSamw if (rsrcname == NULL)
2133da6c28aaSamw continue;
2134da6c28aaSamw
2135da6c28aaSamw rsrc = conv_from_utf8(rsrcname);
2136da6c28aaSamw has_space = strpbrk(rsrc, " ") != NULL;
2137da6c28aaSamw
2138da6c28aaSamw if (has_space)
2139da6c28aaSamw (void) printf("\"%s\"=%s", rsrc,
2140da6c28aaSamw sharepath);
2141da6c28aaSamw else
2142da6c28aaSamw (void) printf("%s=%s", rsrc,
2143da6c28aaSamw sharepath);
2144da6c28aaSamw if (rsrc != rsrcname)
2145da6c28aaSamw sa_free_attr_string(rsrc);
2146da6c28aaSamw sa_free_attr_string(rsrcname);
2147da6c28aaSamw if (properties || rsrcwithopt)
2148da6c28aaSamw show_properties(resource, proto, "\t");
2149da6c28aaSamw
2150da6c28aaSamw /* Get description string if any */
2151573b0c00Sdougm print_rsrc_desc(resource, description);
2152da6c28aaSamw }
2153da6c28aaSamw }
2154573b0c00Sdougm if (description != NULL)
2155573b0c00Sdougm sa_free_share_description(description);
2156da6c28aaSamw } else {
2157da6c28aaSamw (void) printf("\t %s", sharepath);
2158da6c28aaSamw if (properties)
2159da6c28aaSamw show_properties(share, proto, "\t");
2160da6c28aaSamw }
2161da6c28aaSamw (void) printf("\n");
2162da6c28aaSamw }
2163da6c28aaSamw
21646185db85Sdougm /*
21656185db85Sdougm * show_group(group, verbose, properties, proto, subgroup)
21666185db85Sdougm *
21676185db85Sdougm * helper function to show the contents of a group.
21686185db85Sdougm */
21696185db85Sdougm
21706185db85Sdougm static void
show_group(sa_group_t group,int verbose,int properties,char * proto,char * subgroup)21716185db85Sdougm show_group(sa_group_t group, int verbose, int properties, char *proto,
2172da6c28aaSamw char *subgroup)
21736185db85Sdougm {
21746185db85Sdougm char *groupname;
21756185db85Sdougm char *zfs = NULL;
21766185db85Sdougm int iszfs = 0;
2177da6c28aaSamw char *sharepath;
21786185db85Sdougm
21796185db85Sdougm groupname = sa_get_group_attr(group, "name");
21806185db85Sdougm if (groupname != NULL) {
2181*0dfe541eSEvan Layton sa_share_t share;
2182*0dfe541eSEvan Layton
218325a68471Sdougm if (proto != NULL && !has_protocol(group, proto)) {
218425a68471Sdougm sa_free_attr_string(groupname);
218525a68471Sdougm return;
218625a68471Sdougm }
21876185db85Sdougm /*
21886185db85Sdougm * check to see if the group is managed by ZFS. If
21896185db85Sdougm * there is an attribute, then it is. A non-NULL zfs
21906185db85Sdougm * variable will trigger the different way to display
21916185db85Sdougm * and will remove the transient property indicator
21926185db85Sdougm * from the output.
21936185db85Sdougm */
219425a68471Sdougm zfs = sa_get_group_attr(group, "zfs");
219525a68471Sdougm if (zfs != NULL) {
219625a68471Sdougm iszfs = 1;
219725a68471Sdougm sa_free_attr_string(zfs);
219825a68471Sdougm }
2199*0dfe541eSEvan Layton
220025a68471Sdougm if (subgroup == NULL)
220125a68471Sdougm (void) printf("%s", groupname);
220225a68471Sdougm else
220325a68471Sdougm (void) printf(" %s/%s", subgroup, groupname);
220425a68471Sdougm if (properties)
220525a68471Sdougm show_properties(group, proto, "");
220625a68471Sdougm (void) printf("\n");
220725a68471Sdougm if (strcmp(groupname, "zfs") == 0) {
220825a68471Sdougm sa_group_t zgroup;
220925a68471Sdougm
221025a68471Sdougm for (zgroup = sa_get_sub_group(group);
221125a68471Sdougm zgroup != NULL;
221225a68471Sdougm zgroup = sa_get_next_group(zgroup)) {
221325a68471Sdougm show_group(zgroup, verbose, properties, proto,
221425a68471Sdougm "zfs");
221525a68471Sdougm }
221625a68471Sdougm sa_free_attr_string(groupname);
221725a68471Sdougm return;
22186185db85Sdougm }
22196185db85Sdougm /*
222025a68471Sdougm * Have a group, so list the contents. Resource and
22216185db85Sdougm * description are only listed if verbose is set.
22226185db85Sdougm */
222325a68471Sdougm for (share = sa_get_share(group, NULL);
222425a68471Sdougm share != NULL;
222525a68471Sdougm share = sa_get_next_share(share)) {
222625a68471Sdougm sharepath = sa_get_share_attr(share, "path");
222725a68471Sdougm if (sharepath != NULL) {
2228da6c28aaSamw show_share(share, verbose, properties, proto,
2229da6c28aaSamw iszfs, sharepath);
223025a68471Sdougm sa_free_attr_string(sharepath);
223125a68471Sdougm }
223225a68471Sdougm }
22336185db85Sdougm }
22346185db85Sdougm if (groupname != NULL) {
22356185db85Sdougm sa_free_attr_string(groupname);
22366185db85Sdougm }
22376185db85Sdougm }
22386185db85Sdougm
22396185db85Sdougm /*
22406185db85Sdougm * show_group_xml_init()
22416185db85Sdougm *
22426185db85Sdougm * Create an XML document that will be used to display config info via
22436185db85Sdougm * XML format.
22446185db85Sdougm */
22456185db85Sdougm
22466185db85Sdougm xmlDocPtr
show_group_xml_init()22476185db85Sdougm show_group_xml_init()
22486185db85Sdougm {
22496185db85Sdougm xmlDocPtr doc;
22506185db85Sdougm xmlNodePtr root;
22516185db85Sdougm
22526185db85Sdougm doc = xmlNewDoc((xmlChar *)"1.0");
22536185db85Sdougm if (doc != NULL) {
225425a68471Sdougm root = xmlNewNode(NULL, (xmlChar *)"sharecfg");
225525a68471Sdougm if (root != NULL)
22560b4fd3b1SSurya Prakki (void) xmlDocSetRootElement(doc, root);
22576185db85Sdougm }
22586185db85Sdougm return (doc);
22596185db85Sdougm }
22606185db85Sdougm
22616185db85Sdougm /*
22626185db85Sdougm * show_group_xml(doc, group)
22636185db85Sdougm *
22646185db85Sdougm * Copy the group info into the XML doc.
22656185db85Sdougm */
22666185db85Sdougm
22676185db85Sdougm static void
show_group_xml(xmlDocPtr doc,sa_group_t group)22686185db85Sdougm show_group_xml(xmlDocPtr doc, sa_group_t group)
22696185db85Sdougm {
22706185db85Sdougm xmlNodePtr node;
22716185db85Sdougm xmlNodePtr root;
22726185db85Sdougm
22736185db85Sdougm root = xmlDocGetRootElement(doc);
22746185db85Sdougm node = xmlCopyNode((xmlNodePtr)group, 1);
22756185db85Sdougm if (node != NULL && root != NULL) {
22760b4fd3b1SSurya Prakki (void) xmlAddChild(root, node);
22776185db85Sdougm /*
22786185db85Sdougm * In the future, we may have interally used tags that
22796185db85Sdougm * should not appear in the XML output. Remove
22806185db85Sdougm * anything we don't want to show here.
22816185db85Sdougm */
22826185db85Sdougm }
22836185db85Sdougm }
22846185db85Sdougm
22856185db85Sdougm /*
22866185db85Sdougm * sa_show(flags, argc, argv)
22876185db85Sdougm *
22886185db85Sdougm * Implements the show subcommand.
22896185db85Sdougm */
22906185db85Sdougm
22916185db85Sdougm int
sa_show(sa_handle_t handle,int flags,int argc,char * argv[])2292549ec3ffSdougm sa_show(sa_handle_t handle, int flags, int argc, char *argv[])
22936185db85Sdougm {
22946185db85Sdougm sa_group_t group;
22956185db85Sdougm int verbose = 0;
22966185db85Sdougm int properties = 0;
22976185db85Sdougm int c;
22986185db85Sdougm int ret = SA_OK;
22996185db85Sdougm char *protocol = NULL;
23006185db85Sdougm int xml = 0;
23016185db85Sdougm xmlDocPtr doc;
2302da6c28aaSamw #ifdef lint
2303da6c28aaSamw flags = flags;
2304da6c28aaSamw #endif
23056185db85Sdougm
23066185db85Sdougm while ((c = getopt(argc, argv, "?hvP:px")) != EOF) {
230725a68471Sdougm switch (c) {
230825a68471Sdougm case 'v':
230925a68471Sdougm verbose++;
231025a68471Sdougm break;
231125a68471Sdougm case 'p':
231225a68471Sdougm properties++;
231325a68471Sdougm break;
231425a68471Sdougm case 'P':
2315da6c28aaSamw if (protocol != NULL) {
2316da6c28aaSamw (void) printf(gettext(
2317da6c28aaSamw "Specifying multiple protocols "
2318da6c28aaSamw "not supported: %s\n"),
2319da6c28aaSamw protocol);
2320da6c28aaSamw return (SA_SYNTAX_ERR);
2321da6c28aaSamw }
232225a68471Sdougm protocol = optarg;
232325a68471Sdougm if (!sa_valid_protocol(protocol)) {
232425a68471Sdougm (void) printf(gettext(
232525a68471Sdougm "Invalid protocol specified: %s\n"),
232625a68471Sdougm protocol);
232725a68471Sdougm return (SA_INVALID_PROTOCOL);
232825a68471Sdougm }
232925a68471Sdougm break;
233025a68471Sdougm case 'x':
233125a68471Sdougm xml++;
233225a68471Sdougm break;
233325a68471Sdougm case 'h':
2334e7bab347Sdougm /* optopt on valid arg isn't defined */
2335e7bab347Sdougm optopt = c;
2336e7bab347Sdougm /*FALLTHROUGH*/
233725a68471Sdougm case '?':
2338e7bab347Sdougm default:
2339e7bab347Sdougm /*
2340e7bab347Sdougm * Since a bad option gets to here, sort it
2341e7bab347Sdougm * out and return a syntax error return value
2342e7bab347Sdougm * if necessary.
2343e7bab347Sdougm */
2344e7bab347Sdougm switch (optopt) {
2345e7bab347Sdougm default:
2346e7bab347Sdougm ret = SA_SYNTAX_ERR;
2347e7bab347Sdougm break;
2348e7bab347Sdougm case 'h':
2349e7bab347Sdougm case '?':
2350e7bab347Sdougm break;
2351e7bab347Sdougm }
235225a68471Sdougm (void) printf(gettext("usage: %s\n"),
235325a68471Sdougm sa_get_usage(USAGE_SHOW));
2354e7bab347Sdougm return (ret);
23556185db85Sdougm }
23566185db85Sdougm }
23576185db85Sdougm
23586185db85Sdougm if (xml) {
235925a68471Sdougm doc = show_group_xml_init();
236025a68471Sdougm if (doc == NULL)
236125a68471Sdougm ret = SA_NO_MEMORY;
23626185db85Sdougm }
23636185db85Sdougm
23646185db85Sdougm if (optind == argc) {
236525a68471Sdougm /* No group specified so go through them all */
236625a68471Sdougm for (group = sa_get_group(handle, NULL);
236725a68471Sdougm group != NULL;
236825a68471Sdougm group = sa_get_next_group(group)) {
236925a68471Sdougm /*
237025a68471Sdougm * Have a group so check if one we want and then list
237125a68471Sdougm * contents with appropriate options.
237225a68471Sdougm */
237325a68471Sdougm if (xml)
237425a68471Sdougm show_group_xml(doc, group);
237525a68471Sdougm else
237625a68471Sdougm show_group(group, verbose, properties, protocol,
237725a68471Sdougm NULL);
237825a68471Sdougm }
23796185db85Sdougm } else {
238025a68471Sdougm /* Have a specified list of groups */
238125a68471Sdougm for (; optind < argc; optind++) {
238225a68471Sdougm group = sa_get_group(handle, argv[optind]);
238325a68471Sdougm if (group != NULL) {
238425a68471Sdougm if (xml)
238525a68471Sdougm show_group_xml(doc, group);
238625a68471Sdougm else
238725a68471Sdougm show_group(group, verbose, properties,
238825a68471Sdougm protocol, NULL);
238925a68471Sdougm } else {
239025a68471Sdougm (void) printf(gettext("%s: not found\n"),
239125a68471Sdougm argv[optind]);
239225a68471Sdougm ret = SA_NO_SUCH_GROUP;
239325a68471Sdougm }
23946185db85Sdougm }
23956185db85Sdougm }
23966185db85Sdougm if (xml && ret == SA_OK) {
23970b4fd3b1SSurya Prakki (void) xmlDocFormatDump(stdout, doc, 1);
239825a68471Sdougm xmlFreeDoc(doc);
23996185db85Sdougm }
24006185db85Sdougm return (ret);
24016185db85Sdougm
24026185db85Sdougm }
24036185db85Sdougm
24046185db85Sdougm /*
24056185db85Sdougm * enable_share(group, share, update_legacy)
24066185db85Sdougm *
24076185db85Sdougm * helper function to enable a share if the group is enabled.
24086185db85Sdougm */
24096185db85Sdougm
24106185db85Sdougm static int
enable_share(sa_handle_t handle,sa_group_t group,sa_share_t share,int update_legacy)2411549ec3ffSdougm enable_share(sa_handle_t handle, sa_group_t group, sa_share_t share,
2412da6c28aaSamw int update_legacy)
24136185db85Sdougm {
24146185db85Sdougm char *value;
24156185db85Sdougm int enabled;
24166185db85Sdougm sa_optionset_t optionset;
2417da6c28aaSamw int err;
24186185db85Sdougm int ret = SA_OK;
24196185db85Sdougm char *zfs = NULL;
24206185db85Sdougm int iszfs = 0;
2421da6c28aaSamw int isshare;
24226185db85Sdougm
24236185db85Sdougm /*
24246185db85Sdougm * need to enable this share if the group is enabled but not
24256185db85Sdougm * otherwise. The enable is also done on each protocol
24266185db85Sdougm * represented in the group.
24276185db85Sdougm */
24286185db85Sdougm value = sa_get_group_attr(group, "state");
24296185db85Sdougm enabled = value != NULL && strcmp(value, "enabled") == 0;
24306185db85Sdougm if (value != NULL)
243125a68471Sdougm sa_free_attr_string(value);
24326185db85Sdougm /* remove legacy config if necessary */
24336185db85Sdougm if (update_legacy)
2434da6c28aaSamw ret = sa_delete_legacy(share, NULL);
24356185db85Sdougm zfs = sa_get_group_attr(group, "zfs");
24366185db85Sdougm if (zfs != NULL) {
243725a68471Sdougm iszfs++;
243825a68471Sdougm sa_free_attr_string(zfs);
24396185db85Sdougm }
24406185db85Sdougm
24416185db85Sdougm /*
24426185db85Sdougm * Step through each optionset at the group level and
24436185db85Sdougm * enable the share based on the protocol type. This
24446185db85Sdougm * works because protocols must be set on the group
24456185db85Sdougm * for the protocol to be enabled.
24466185db85Sdougm */
2447da6c28aaSamw isshare = sa_is_share(share);
24486185db85Sdougm for (optionset = sa_get_optionset(group, NULL);
24496185db85Sdougm optionset != NULL && ret == SA_OK;
24506185db85Sdougm optionset = sa_get_next_optionset(optionset)) {
245125a68471Sdougm value = sa_get_optionset_attr(optionset, "type");
245225a68471Sdougm if (value != NULL) {
2453da6c28aaSamw if (enabled) {
2454da6c28aaSamw if (isshare) {
2455da6c28aaSamw err = sa_enable_share(share, value);
2456da6c28aaSamw } else {
2457da6c28aaSamw err = sa_enable_resource(share, value);
2458da6c28aaSamw if (err == SA_NOT_SUPPORTED) {
2459da6c28aaSamw sa_share_t parent;
2460da6c28aaSamw parent = sa_get_resource_parent(
2461da6c28aaSamw share);
2462da6c28aaSamw if (parent != NULL)
2463da6c28aaSamw err = sa_enable_share(
2464da6c28aaSamw parent, value);
2465da6c28aaSamw }
2466da6c28aaSamw }
2467da6c28aaSamw if (err != SA_OK) {
2468da6c28aaSamw ret = err;
2469da6c28aaSamw (void) printf(gettext(
2470da6c28aaSamw "Failed to enable share for "
2471da6c28aaSamw "\"%s\": %s\n"),
2472da6c28aaSamw value, sa_errorstr(ret));
2473da6c28aaSamw }
2474da6c28aaSamw }
2475da6c28aaSamw /*
2476da6c28aaSamw * If we want to update the legacy, use a copy of
2477da6c28aaSamw * share so we can avoid breaking the loop we are in
2478da6c28aaSamw * since we might also need to go up the tree to the
2479da6c28aaSamw * parent.
2480da6c28aaSamw */
2481da6c28aaSamw if (update_legacy && !iszfs) {
2482da6c28aaSamw sa_share_t update = share;
2483da6c28aaSamw if (!sa_is_share(share)) {
2484da6c28aaSamw update = sa_get_resource_parent(share);
2485da6c28aaSamw }
2486da6c28aaSamw (void) sa_update_legacy(update, value);
2487da6c28aaSamw }
248825a68471Sdougm sa_free_attr_string(value);
248925a68471Sdougm }
24906185db85Sdougm }
24916185db85Sdougm if (ret == SA_OK)
249225a68471Sdougm (void) sa_update_config(handle);
24936185db85Sdougm return (ret);
24946185db85Sdougm }
24956185db85Sdougm
2496da6c28aaSamw /*
2497da6c28aaSamw * sa_require_resource(group)
2498da6c28aaSamw *
2499da6c28aaSamw * if any of the defined protocols on the group require resource
2500da6c28aaSamw * names, then all shares must have them.
2501da6c28aaSamw */
2502da6c28aaSamw
2503da6c28aaSamw static int
sa_require_resource(sa_group_t group)2504da6c28aaSamw sa_require_resource(sa_group_t group)
2505da6c28aaSamw {
2506da6c28aaSamw sa_optionset_t optionset;
2507da6c28aaSamw
2508da6c28aaSamw for (optionset = sa_get_optionset(group, NULL);
2509da6c28aaSamw optionset != NULL;
2510da6c28aaSamw optionset = sa_get_next_optionset(optionset)) {
2511da6c28aaSamw char *proto;
2512da6c28aaSamw
2513da6c28aaSamw proto = sa_get_optionset_attr(optionset, "type");
2514da6c28aaSamw if (proto != NULL) {
2515da6c28aaSamw uint64_t features;
2516da6c28aaSamw
2517da6c28aaSamw features = sa_proto_get_featureset(proto);
2518da6c28aaSamw if (features & SA_FEATURE_RESOURCE) {
2519da6c28aaSamw sa_free_attr_string(proto);
2520da6c28aaSamw return (B_TRUE);
2521da6c28aaSamw }
2522da6c28aaSamw sa_free_attr_string(proto);
2523da6c28aaSamw }
2524da6c28aaSamw }
2525da6c28aaSamw return (B_FALSE);
2526da6c28aaSamw }
2527da6c28aaSamw
25286185db85Sdougm /*
25296185db85Sdougm * sa_addshare(flags, argc, argv)
25306185db85Sdougm *
25316185db85Sdougm * implements add-share subcommand.
25326185db85Sdougm */
25336185db85Sdougm
2534da6c28aaSamw static int
sa_addshare(sa_handle_t handle,int flags,int argc,char * argv[])2535549ec3ffSdougm sa_addshare(sa_handle_t handle, int flags, int argc, char *argv[])
25366185db85Sdougm {
25376185db85Sdougm int verbose = 0;
25386185db85Sdougm int dryrun = 0;
25396185db85Sdougm int c;
25406185db85Sdougm int ret = SA_OK;
25416185db85Sdougm sa_group_t group;
25426185db85Sdougm sa_share_t share;
2543da6c28aaSamw sa_resource_t resource = NULL;
25446185db85Sdougm char *sharepath = NULL;
25456185db85Sdougm char *description = NULL;
2546da6c28aaSamw char *rsrcname = NULL;
2547da6c28aaSamw char *rsrc = NULL;
25486185db85Sdougm int persist = SA_SHARE_PERMANENT; /* default to persist */
25496185db85Sdougm int auth;
25506185db85Sdougm char dir[MAXPATHLEN];
25516185db85Sdougm
25526185db85Sdougm while ((c = getopt(argc, argv, "?hvns:d:r:t")) != EOF) {
255325a68471Sdougm switch (c) {
255425a68471Sdougm case 'n':
255525a68471Sdougm dryrun++;
255625a68471Sdougm break;
255725a68471Sdougm case 'v':
255825a68471Sdougm verbose++;
255925a68471Sdougm break;
256025a68471Sdougm case 'd':
256125a68471Sdougm description = optarg;
256225a68471Sdougm break;
256325a68471Sdougm case 'r':
2564da6c28aaSamw if (rsrcname != NULL) {
2565da6c28aaSamw (void) printf(gettext("Adding multiple "
2566da6c28aaSamw "resource names not"
2567da6c28aaSamw " supported\n"));
2568da6c28aaSamw return (SA_SYNTAX_ERR);
2569da6c28aaSamw }
2570da6c28aaSamw rsrcname = optarg;
257125a68471Sdougm break;
257225a68471Sdougm case 's':
257325a68471Sdougm /*
257425a68471Sdougm * Save share path into group. Currently limit
257525a68471Sdougm * to one share per command.
257625a68471Sdougm */
257725a68471Sdougm if (sharepath != NULL) {
257825a68471Sdougm (void) printf(gettext(
257925a68471Sdougm "Adding multiple shares not supported\n"));
2580da6c28aaSamw return (SA_SYNTAX_ERR);
258125a68471Sdougm }
258225a68471Sdougm sharepath = optarg;
258325a68471Sdougm break;
258425a68471Sdougm case 't':
258525a68471Sdougm persist = SA_SHARE_TRANSIENT;
258625a68471Sdougm break;
258725a68471Sdougm case 'h':
2588e7bab347Sdougm /* optopt on valid arg isn't defined */
2589e7bab347Sdougm optopt = c;
2590e7bab347Sdougm /*FALLTHROUGH*/
259125a68471Sdougm case '?':
2592e7bab347Sdougm default:
2593e7bab347Sdougm /*
2594e7bab347Sdougm * Since a bad option gets to here, sort it
2595e7bab347Sdougm * out and return a syntax error return value
2596e7bab347Sdougm * if necessary.
2597e7bab347Sdougm */
2598e7bab347Sdougm switch (optopt) {
2599e7bab347Sdougm default:
2600e7bab347Sdougm ret = SA_SYNTAX_ERR;
2601e7bab347Sdougm break;
2602e7bab347Sdougm case 'h':
2603e7bab347Sdougm case '?':
2604e7bab347Sdougm break;
2605e7bab347Sdougm }
260625a68471Sdougm (void) printf(gettext("usage: %s\n"),
260725a68471Sdougm sa_get_usage(USAGE_ADD_SHARE));
2608e7bab347Sdougm return (ret);
26096185db85Sdougm }
26106185db85Sdougm }
26116185db85Sdougm
26126185db85Sdougm if (optind >= argc) {
26136185db85Sdougm (void) printf(gettext("usage: %s\n"),
261425a68471Sdougm sa_get_usage(USAGE_ADD_SHARE));
261525a68471Sdougm if (dryrun || sharepath != NULL || description != NULL ||
2616da6c28aaSamw rsrcname != NULL || verbose || persist) {
261725a68471Sdougm (void) printf(gettext("\tgroup must be specified\n"));
261825a68471Sdougm ret = SA_NO_SUCH_GROUP;
261925a68471Sdougm } else {
262025a68471Sdougm ret = SA_OK;
262125a68471Sdougm }
262225a68471Sdougm } else {
262325a68471Sdougm if (sharepath == NULL) {
262425a68471Sdougm (void) printf(gettext("usage: %s\n"),
262525a68471Sdougm sa_get_usage(USAGE_ADD_SHARE));
262625a68471Sdougm (void) printf(gettext(
262725a68471Sdougm "\t-s sharepath must be specified\n"));
2628da6c28aaSamw ret = SA_BAD_PATH;
262925a68471Sdougm }
2630da6c28aaSamw if (ret == SA_OK) {
2631da6c28aaSamw if (realpath(sharepath, dir) == NULL) {
2632da6c28aaSamw ret = SA_BAD_PATH;
2633da6c28aaSamw (void) printf(gettext("Path "
2634da6c28aaSamw "is not valid: %s\n"),
2635da6c28aaSamw sharepath);
2636da6c28aaSamw } else {
2637da6c28aaSamw sharepath = dir;
2638da6c28aaSamw }
263925a68471Sdougm }
2640da6c28aaSamw if (ret == SA_OK && rsrcname != NULL) {
2641da6c28aaSamw /* check for valid syntax */
2642da6c28aaSamw if (validresource(rsrcname)) {
2643da6c28aaSamw rsrc = conv_to_utf8(rsrcname);
2644da6c28aaSamw resource = sa_find_resource(handle, rsrc);
2645da6c28aaSamw if (resource != NULL) {
2646da6c28aaSamw /*
2647da6c28aaSamw * Resource names must be
2648da6c28aaSamw * unique in the system
2649da6c28aaSamw */
2650da6c28aaSamw ret = SA_DUPLICATE_NAME;
2651da6c28aaSamw (void) printf(gettext("usage: %s\n"),
2652da6c28aaSamw sa_get_usage(USAGE_ADD_SHARE));
2653da6c28aaSamw (void) printf(gettext(
2654da6c28aaSamw "\tresource names must be unique "
2655da6c28aaSamw "in the system\n"));
2656da6c28aaSamw }
2657da6c28aaSamw } else {
2658da6c28aaSamw (void) printf(gettext("usage: %s\n"),
2659da6c28aaSamw sa_get_usage(USAGE_ADD_SHARE));
2660da6c28aaSamw (void) printf(gettext(
2661da6c28aaSamw "\tresource names use restricted "
2662da6c28aaSamw "character set\n"));
2663da6c28aaSamw ret = SA_INVALID_NAME;
2664da6c28aaSamw }
266525a68471Sdougm }
2666da6c28aaSamw
2667da6c28aaSamw if (ret != SA_OK) {
2668da6c28aaSamw if (rsrc != NULL && rsrcname != rsrc)
2669da6c28aaSamw sa_free_attr_string(rsrc);
2670da6c28aaSamw return (ret);
267125a68471Sdougm }
2672da6c28aaSamw
267325a68471Sdougm share = sa_find_share(handle, sharepath);
267425a68471Sdougm if (share != NULL) {
2675da6c28aaSamw if (rsrcname == NULL) {
2676da6c28aaSamw /*
2677da6c28aaSamw * Can only have a duplicate share if a new
2678da6c28aaSamw * resource name is being added.
2679da6c28aaSamw */
2680da6c28aaSamw ret = SA_DUPLICATE_NAME;
2681da6c28aaSamw (void) printf(gettext("Share path already "
2682da6c28aaSamw "shared: %s\n"), sharepath);
2683da6c28aaSamw }
2684da6c28aaSamw }
2685da6c28aaSamw if (ret != SA_OK)
2686da6c28aaSamw return (ret);
2687da6c28aaSamw
2688da6c28aaSamw group = sa_get_group(handle, argv[optind]);
2689da6c28aaSamw if (group != NULL) {
2690da6c28aaSamw if (sa_require_resource(group) == B_TRUE &&
2691da6c28aaSamw rsrcname == NULL) {
269225a68471Sdougm (void) printf(gettext(
2693da6c28aaSamw "Resource name is required "
2694da6c28aaSamw "by at least one enabled protocol "
2695da6c28aaSamw "in group\n"));
2696da6c28aaSamw return (SA_RESOURCE_REQUIRED);
2697da6c28aaSamw }
2698da6c28aaSamw if (share == NULL && ret == SA_OK) {
2699da6c28aaSamw if (dryrun)
2700da6c28aaSamw ret = sa_check_path(group, sharepath,
2701da6c28aaSamw SA_CHECK_NORMAL);
2702da6c28aaSamw else
2703da6c28aaSamw share = sa_add_share(group, sharepath,
2704da6c28aaSamw persist, &ret);
27056185db85Sdougm }
27066185db85Sdougm /*
2707da6c28aaSamw * Make sure this isn't an attempt to put a resourced
2708da6c28aaSamw * share into a different group than it already is in.
27096185db85Sdougm */
2710da6c28aaSamw if (share != NULL) {
2711da6c28aaSamw sa_group_t parent;
2712da6c28aaSamw parent = sa_get_parent_group(share);
2713da6c28aaSamw if (parent != group) {
2714da6c28aaSamw ret = SA_DUPLICATE_NAME;
2715da6c28aaSamw (void) printf(gettext(
2716da6c28aaSamw "Share path already "
2717da6c28aaSamw "shared: %s\n"), sharepath);
2718da6c28aaSamw }
2719da6c28aaSamw }
27206185db85Sdougm if (!dryrun && share == NULL) {
272125a68471Sdougm (void) printf(gettext(
272225a68471Sdougm "Could not add share: %s\n"),
272325a68471Sdougm sa_errorstr(ret));
27246185db85Sdougm } else {
2725da6c28aaSamw auth = check_authorizations(argv[optind],
2726da6c28aaSamw flags);
272725a68471Sdougm if (!dryrun && ret == SA_OK) {
2728da6c28aaSamw if (rsrcname != NULL) {
2729da6c28aaSamw resource = sa_add_resource(
2730da6c28aaSamw share,
2731da6c28aaSamw rsrc,
2732da6c28aaSamw SA_SHARE_PERMANENT,
2733da6c28aaSamw &ret);
273425a68471Sdougm }
273525a68471Sdougm if (ret == SA_OK &&
273625a68471Sdougm description != NULL) {
2737573b0c00Sdougm if (resource != NULL)
2738573b0c00Sdougm ret =
2739573b0c00Sdougm set_resource_desc(
2740573b0c00Sdougm resource,
2741573b0c00Sdougm description);
2742573b0c00Sdougm else
2743da6c28aaSamw ret =
2744da6c28aaSamw set_share_desc(
2745da6c28aaSamw share,
2746da6c28aaSamw description);
274725a68471Sdougm }
274825a68471Sdougm if (ret == SA_OK) {
2749da6c28aaSamw /* now enable the share(s) */
2750da6c28aaSamw if (resource != NULL) {
2751da6c28aaSamw ret = enable_share(
2752da6c28aaSamw handle,
2753da6c28aaSamw group,
2754da6c28aaSamw resource,
2755da6c28aaSamw 1);
2756da6c28aaSamw } else {
2757da6c28aaSamw ret = enable_share(
2758da6c28aaSamw handle,
2759da6c28aaSamw group,
2760da6c28aaSamw share,
2761da6c28aaSamw 1);
2762da6c28aaSamw }
276325a68471Sdougm ret = sa_update_config(handle);
276425a68471Sdougm }
276525a68471Sdougm switch (ret) {
276625a68471Sdougm case SA_DUPLICATE_NAME:
276725a68471Sdougm (void) printf(gettext(
276825a68471Sdougm "Resource name in"
2769da6c28aaSamw "use: %s\n"),
2770da6c28aaSamw rsrcname);
277125a68471Sdougm break;
277225a68471Sdougm default:
2773da6c28aaSamw (void) printf(gettext(
2774da6c28aaSamw "Could not set "
27756185db85Sdougm "attribute: %s\n"),
277625a68471Sdougm sa_errorstr(ret));
277725a68471Sdougm break;
277825a68471Sdougm case SA_OK:
277925a68471Sdougm break;
278025a68471Sdougm }
2781da6c28aaSamw } else if (dryrun && ret == SA_OK &&
2782da6c28aaSamw !auth && verbose) {
278325a68471Sdougm (void) printf(gettext(
278425a68471Sdougm "Command would fail: %s\n"),
278525a68471Sdougm sa_errorstr(SA_NO_PERMISSION));
278625a68471Sdougm ret = SA_NO_PERMISSION;
27876185db85Sdougm }
278825a68471Sdougm }
2789da6c28aaSamw } else {
2790da6c28aaSamw switch (ret) {
2791da6c28aaSamw default:
2792da6c28aaSamw (void) printf(gettext(
2793da6c28aaSamw "Group \"%s\" not found\n"), argv[optind]);
2794da6c28aaSamw ret = SA_NO_SUCH_GROUP;
2795da6c28aaSamw break;
2796da6c28aaSamw case SA_BAD_PATH:
2797da6c28aaSamw case SA_DUPLICATE_NAME:
2798da6c28aaSamw break;
2799da6c28aaSamw }
28006185db85Sdougm }
28016185db85Sdougm }
28026185db85Sdougm return (ret);
28036185db85Sdougm }
28046185db85Sdougm
28056185db85Sdougm /*
28066185db85Sdougm * sa_moveshare(flags, argc, argv)
28076185db85Sdougm *
28086185db85Sdougm * implements move-share subcommand.
28096185db85Sdougm */
28106185db85Sdougm
28116185db85Sdougm int
sa_moveshare(sa_handle_t handle,int flags,int argc,char * argv[])2812549ec3ffSdougm sa_moveshare(sa_handle_t handle, int flags, int argc, char *argv[])
28136185db85Sdougm {
28146185db85Sdougm int verbose = 0;
28156185db85Sdougm int dryrun = 0;
28166185db85Sdougm int c;
28176185db85Sdougm int ret = SA_OK;
28186185db85Sdougm sa_group_t group;
28196185db85Sdougm sa_share_t share;
2820da6c28aaSamw char *rsrcname = NULL;
28216185db85Sdougm char *sharepath = NULL;
28226185db85Sdougm int authsrc = 0, authdst = 0;
2823573b0c00Sdougm char dir[MAXPATHLEN];
28246185db85Sdougm
2825da6c28aaSamw while ((c = getopt(argc, argv, "?hvnr:s:")) != EOF) {
282625a68471Sdougm switch (c) {
282725a68471Sdougm case 'n':
282825a68471Sdougm dryrun++;
282925a68471Sdougm break;
283025a68471Sdougm case 'v':
283125a68471Sdougm verbose++;
283225a68471Sdougm break;
2833da6c28aaSamw case 'r':
2834da6c28aaSamw if (rsrcname != NULL) {
2835da6c28aaSamw (void) printf(gettext(
2836da6c28aaSamw "Moving multiple resource names not"
2837da6c28aaSamw " supported\n"));
2838da6c28aaSamw return (SA_SYNTAX_ERR);
2839da6c28aaSamw }
2840da6c28aaSamw rsrcname = optarg;
2841da6c28aaSamw break;
284225a68471Sdougm case 's':
284325a68471Sdougm /*
284425a68471Sdougm * Remove share path from group. Currently limit
284525a68471Sdougm * to one share per command.
284625a68471Sdougm */
284725a68471Sdougm if (sharepath != NULL) {
284825a68471Sdougm (void) printf(gettext("Moving multiple shares"
2849da6c28aaSamw " not supported\n"));
2850da6c28aaSamw return (SA_SYNTAX_ERR);
285125a68471Sdougm }
285225a68471Sdougm sharepath = optarg;
285325a68471Sdougm break;
285425a68471Sdougm case 'h':
2855e7bab347Sdougm /* optopt on valid arg isn't defined */
2856e7bab347Sdougm optopt = c;
2857e7bab347Sdougm /*FALLTHROUGH*/
285825a68471Sdougm case '?':
2859e7bab347Sdougm default:
2860e7bab347Sdougm /*
2861e7bab347Sdougm * Since a bad option gets to here, sort it
2862e7bab347Sdougm * out and return a syntax error return value
2863e7bab347Sdougm * if necessary.
2864e7bab347Sdougm */
2865e7bab347Sdougm switch (optopt) {
2866e7bab347Sdougm default:
2867e7bab347Sdougm ret = SA_SYNTAX_ERR;
2868e7bab347Sdougm break;
2869e7bab347Sdougm case 'h':
2870e7bab347Sdougm case '?':
2871e7bab347Sdougm break;
2872e7bab347Sdougm }
287325a68471Sdougm (void) printf(gettext("usage: %s\n"),
287425a68471Sdougm sa_get_usage(USAGE_MOVE_SHARE));
2875e7bab347Sdougm return (ret);
28766185db85Sdougm }
28776185db85Sdougm }
28786185db85Sdougm
28796185db85Sdougm if (optind >= argc || sharepath == NULL) {
2880da6c28aaSamw (void) printf(gettext("usage: %s\n"),
2881da6c28aaSamw sa_get_usage(USAGE_MOVE_SHARE));
2882da6c28aaSamw if (dryrun || verbose || sharepath != NULL) {
2883da6c28aaSamw (void) printf(gettext("\tgroup must be specified\n"));
2884da6c28aaSamw ret = SA_NO_SUCH_GROUP;
2885da6c28aaSamw } else {
2886da6c28aaSamw if (sharepath == NULL) {
2887da6c28aaSamw ret = SA_SYNTAX_ERR;
288825a68471Sdougm (void) printf(gettext(
2889da6c28aaSamw "\tsharepath must be specified\n"));
289025a68471Sdougm } else {
2891da6c28aaSamw ret = SA_OK;
289225a68471Sdougm }
2893da6c28aaSamw }
28946185db85Sdougm } else {
289525a68471Sdougm sa_group_t parent;
289625a68471Sdougm char *zfsold;
289725a68471Sdougm char *zfsnew;
289825a68471Sdougm
289925a68471Sdougm if (sharepath == NULL) {
290025a68471Sdougm (void) printf(gettext(
290125a68471Sdougm "sharepath must be specified with the -s "
290225a68471Sdougm "option\n"));
290325a68471Sdougm return (SA_BAD_PATH);
290425a68471Sdougm }
2905549ec3ffSdougm group = sa_get_group(handle, argv[optind]);
290625a68471Sdougm if (group == NULL) {
290725a68471Sdougm (void) printf(gettext("Group \"%s\" not found\n"),
290825a68471Sdougm argv[optind]);
290925a68471Sdougm return (SA_NO_SUCH_GROUP);
291025a68471Sdougm }
291125a68471Sdougm share = sa_find_share(handle, sharepath);
2912573b0c00Sdougm /*
2913573b0c00Sdougm * If a share wasn't found, it may have been a symlink
2914573b0c00Sdougm * or has a trailing '/'. Try again after resolving
2915573b0c00Sdougm * with realpath().
2916573b0c00Sdougm */
2917573b0c00Sdougm if (share == NULL) {
2918573b0c00Sdougm if (realpath(sharepath, dir) == NULL) {
2919573b0c00Sdougm (void) printf(gettext("Path "
2920573b0c00Sdougm "is not valid: %s\n"),
2921573b0c00Sdougm sharepath);
2922573b0c00Sdougm return (SA_BAD_PATH);
2923573b0c00Sdougm }
2924573b0c00Sdougm sharepath = dir;
2925573b0c00Sdougm share = sa_find_share(handle, sharepath);
2926573b0c00Sdougm }
292725a68471Sdougm if (share == NULL) {
29286185db85Sdougm (void) printf(gettext("Share not found: %s\n"),
292925a68471Sdougm sharepath);
293025a68471Sdougm return (SA_NO_SUCH_PATH);
293125a68471Sdougm }
2932573b0c00Sdougm authdst = check_authorizations(argv[optind], flags);
293325a68471Sdougm
293425a68471Sdougm parent = sa_get_parent_group(share);
293525a68471Sdougm if (parent != NULL) {
293625a68471Sdougm char *pname;
293725a68471Sdougm pname = sa_get_group_attr(parent, "name");
293825a68471Sdougm if (pname != NULL) {
29396185db85Sdougm authsrc = check_authorizations(pname, flags);
29406185db85Sdougm sa_free_attr_string(pname);
294125a68471Sdougm }
294225a68471Sdougm zfsold = sa_get_group_attr(parent, "zfs");
294325a68471Sdougm zfsnew = sa_get_group_attr(group, "zfs");
294425a68471Sdougm if ((zfsold != NULL && zfsnew == NULL) ||
294525a68471Sdougm (zfsold == NULL && zfsnew != NULL)) {
29466185db85Sdougm ret = SA_NOT_ALLOWED;
294725a68471Sdougm }
294825a68471Sdougm if (zfsold != NULL)
29496185db85Sdougm sa_free_attr_string(zfsold);
295025a68471Sdougm if (zfsnew != NULL)
29516185db85Sdougm sa_free_attr_string(zfsnew);
295225a68471Sdougm }
295325a68471Sdougm
295425a68471Sdougm if (ret == SA_OK && parent != group && !dryrun) {
295525a68471Sdougm char *oldstate;
295625a68471Sdougm /*
295725a68471Sdougm * Note that the share may need to be
2958da6c28aaSamw * "unshared" if the new group is disabled and
2959da6c28aaSamw * the old was enabled or it may need to be
2960da6c28aaSamw * share to update if the new group is
2961da6c28aaSamw * enabled. We disable before the move and
2962da6c28aaSamw * will have to enable after the move in order
2963da6c28aaSamw * to cleanup entries for protocols that
2964da6c28aaSamw * aren't in the new group.
296525a68471Sdougm */
296625a68471Sdougm oldstate = sa_get_group_attr(parent, "state");
2967fe1c642dSBill Krier if (oldstate != NULL) {
2968fe1c642dSBill Krier /* enable_share determines what to do */
2969fe1c642dSBill Krier if (strcmp(oldstate, "enabled") == 0)
2970fe1c642dSBill Krier (void) sa_disable_share(share, NULL);
297125a68471Sdougm sa_free_attr_string(oldstate);
2972fe1c642dSBill Krier }
297325a68471Sdougm }
297425a68471Sdougm
2975da6c28aaSamw if (!dryrun && ret == SA_OK)
2976da6c28aaSamw ret = sa_move_share(group, share);
2977da6c28aaSamw
2978da6c28aaSamw /*
2979da6c28aaSamw * Reenable and update any config information.
2980da6c28aaSamw */
2981da6c28aaSamw if (ret == SA_OK && parent != group && !dryrun) {
2982da6c28aaSamw ret = sa_update_config(handle);
2983da6c28aaSamw
2984da6c28aaSamw (void) enable_share(handle, group, share, 1);
2985da6c28aaSamw }
2986da6c28aaSamw
298725a68471Sdougm if (ret != SA_OK)
298825a68471Sdougm (void) printf(gettext("Could not move share: %s\n"),
298925a68471Sdougm sa_errorstr(ret));
299025a68471Sdougm
299125a68471Sdougm if (dryrun && ret == SA_OK && !(authsrc & authdst) &&
299225a68471Sdougm verbose) {
299325a68471Sdougm (void) printf(gettext("Command would fail: %s\n"),
299425a68471Sdougm sa_errorstr(SA_NO_PERMISSION));
29956185db85Sdougm }
29966185db85Sdougm }
29976185db85Sdougm return (ret);
29986185db85Sdougm }
29996185db85Sdougm
30006185db85Sdougm /*
30016185db85Sdougm * sa_removeshare(flags, argc, argv)
30026185db85Sdougm *
30036185db85Sdougm * implements remove-share subcommand.
30046185db85Sdougm */
30056185db85Sdougm
30066185db85Sdougm int
sa_removeshare(sa_handle_t handle,int flags,int argc,char * argv[])3007549ec3ffSdougm sa_removeshare(sa_handle_t handle, int flags, int argc, char *argv[])
30086185db85Sdougm {
30096185db85Sdougm int verbose = 0;
30106185db85Sdougm int dryrun = 0;
30116185db85Sdougm int force = 0;
30126185db85Sdougm int c;
30136185db85Sdougm int ret = SA_OK;
30146185db85Sdougm sa_group_t group;
3015da6c28aaSamw sa_resource_t resource = NULL;
3016da6c28aaSamw sa_share_t share = NULL;
3017da6c28aaSamw char *rsrcname = NULL;
30186185db85Sdougm char *sharepath = NULL;
30196185db85Sdougm char dir[MAXPATHLEN];
30206185db85Sdougm int auth;
30216185db85Sdougm
3022da6c28aaSamw while ((c = getopt(argc, argv, "?hfnr:s:v")) != EOF) {
302325a68471Sdougm switch (c) {
302425a68471Sdougm case 'n':
302525a68471Sdougm dryrun++;
302625a68471Sdougm break;
302725a68471Sdougm case 'v':
302825a68471Sdougm verbose++;
302925a68471Sdougm break;
303025a68471Sdougm case 'f':
303125a68471Sdougm force++;
303225a68471Sdougm break;
303325a68471Sdougm case 's':
303425a68471Sdougm /*
303525a68471Sdougm * Remove share path from group. Currently limit
303625a68471Sdougm * to one share per command.
303725a68471Sdougm */
303825a68471Sdougm if (sharepath != NULL) {
303925a68471Sdougm (void) printf(gettext(
304025a68471Sdougm "Removing multiple shares not "
30416185db85Sdougm "supported\n"));
304225a68471Sdougm return (SA_SYNTAX_ERR);
304325a68471Sdougm }
304425a68471Sdougm sharepath = optarg;
304525a68471Sdougm break;
3046da6c28aaSamw case 'r':
3047da6c28aaSamw /*
3048da6c28aaSamw * Remove share from group if last resource or remove
3049da6c28aaSamw * resource from share if multiple resources.
3050da6c28aaSamw */
3051da6c28aaSamw if (rsrcname != NULL) {
3052da6c28aaSamw (void) printf(gettext(
3053da6c28aaSamw "Removing multiple resource names not "
3054da6c28aaSamw "supported\n"));
3055da6c28aaSamw return (SA_SYNTAX_ERR);
3056da6c28aaSamw }
3057da6c28aaSamw rsrcname = optarg;
3058da6c28aaSamw break;
305925a68471Sdougm case 'h':
3060e7bab347Sdougm /* optopt on valid arg isn't defined */
3061e7bab347Sdougm optopt = c;
3062e7bab347Sdougm /*FALLTHROUGH*/
306325a68471Sdougm case '?':
3064e7bab347Sdougm default:
3065e7bab347Sdougm /*
3066e7bab347Sdougm * Since a bad option gets to here, sort it
3067e7bab347Sdougm * out and return a syntax error return value
3068e7bab347Sdougm * if necessary.
3069e7bab347Sdougm */
3070e7bab347Sdougm switch (optopt) {
3071e7bab347Sdougm default:
3072e7bab347Sdougm ret = SA_SYNTAX_ERR;
3073e7bab347Sdougm break;
3074e7bab347Sdougm case 'h':
3075e7bab347Sdougm case '?':
3076e7bab347Sdougm break;
3077e7bab347Sdougm }
307825a68471Sdougm (void) printf(gettext("usage: %s\n"),
307925a68471Sdougm sa_get_usage(USAGE_REMOVE_SHARE));
3080e7bab347Sdougm return (ret);
30816185db85Sdougm }
30826185db85Sdougm }
30836185db85Sdougm
3084da6c28aaSamw if (optind >= argc || (rsrcname == NULL && sharepath == NULL)) {
3085da6c28aaSamw if (sharepath == NULL && rsrcname == NULL) {
30866185db85Sdougm (void) printf(gettext("usage: %s\n"),
308725a68471Sdougm sa_get_usage(USAGE_REMOVE_SHARE));
3088da6c28aaSamw (void) printf(gettext("\t-s sharepath or -r resource"
3089da6c28aaSamw " must be specified\n"));
309025a68471Sdougm ret = SA_BAD_PATH;
309125a68471Sdougm } else {
309225a68471Sdougm ret = SA_OK;
309325a68471Sdougm }
30946185db85Sdougm }
309525a68471Sdougm if (ret != SA_OK) {
309625a68471Sdougm return (ret);
309725a68471Sdougm }
309825a68471Sdougm
309925a68471Sdougm if (optind < argc) {
31006185db85Sdougm if ((optind + 1) < argc) {
310125a68471Sdougm (void) printf(gettext("Extraneous group(s) at end of "
310225a68471Sdougm "command\n"));
310325a68471Sdougm ret = SA_SYNTAX_ERR;
31046185db85Sdougm } else {
310525a68471Sdougm group = sa_get_group(handle, argv[optind]);
310625a68471Sdougm if (group == NULL) {
310725a68471Sdougm (void) printf(gettext(
310825a68471Sdougm "Group \"%s\" not found\n"), argv[optind]);
310925a68471Sdougm ret = SA_NO_SUCH_GROUP;
311025a68471Sdougm }
31116185db85Sdougm }
311225a68471Sdougm } else {
31136185db85Sdougm group = NULL;
311425a68471Sdougm }
3115a99982a7Sdougm
3116da6c28aaSamw if (rsrcname != NULL) {
3117da6c28aaSamw resource = sa_find_resource(handle, rsrcname);
3118da6c28aaSamw if (resource == NULL) {
3119da6c28aaSamw ret = SA_NO_SUCH_RESOURCE;
3120da6c28aaSamw (void) printf(gettext(
3121da6c28aaSamw "Resource name not found for share: %s\n"),
3122da6c28aaSamw rsrcname);
3123da6c28aaSamw }
3124da6c28aaSamw }
3125da6c28aaSamw
312625a68471Sdougm /*
312725a68471Sdougm * Lookup the path in the internal configuration. Care
312825a68471Sdougm * must be taken to handle the case where the
312925a68471Sdougm * underlying path has been removed since we need to
313025a68471Sdougm * be able to deal with that as well.
313125a68471Sdougm */
313225a68471Sdougm if (ret == SA_OK) {
3133da6c28aaSamw if (sharepath != NULL) {
3134da6c28aaSamw if (group != NULL)
3135da6c28aaSamw share = sa_get_share(group, sharepath);
3136da6c28aaSamw else
3137da6c28aaSamw share = sa_find_share(handle, sharepath);
3138da6c28aaSamw }
3139da6c28aaSamw
3140da6c28aaSamw if (resource != NULL) {
3141da6c28aaSamw sa_share_t rsrcshare;
3142da6c28aaSamw rsrcshare = sa_get_resource_parent(resource);
3143da6c28aaSamw if (share == NULL)
3144da6c28aaSamw share = rsrcshare;
3145da6c28aaSamw else if (share != rsrcshare) {
3146da6c28aaSamw ret = SA_NO_SUCH_RESOURCE;
3147da6c28aaSamw (void) printf(gettext(
3148da6c28aaSamw "Bad resource name for share: %s\n"),
3149da6c28aaSamw rsrcname);
3150da6c28aaSamw share = NULL;
3151da6c28aaSamw }
3152da6c28aaSamw }
3153da6c28aaSamw
3154a99982a7Sdougm /*
3155a99982a7Sdougm * If we didn't find the share with the provided path,
3156a99982a7Sdougm * it may be a symlink so attempt to resolve it using
3157a99982a7Sdougm * realpath and try again. Realpath will resolve any
3158a99982a7Sdougm * symlinks and place them in "dir". Note that
3159a99982a7Sdougm * sharepath is only used for the lookup the first
3160a99982a7Sdougm * time and later for error messages. dir will be used
3161a99982a7Sdougm * on the second attempt. Once a share is found, all
3162a99982a7Sdougm * operations are based off of the share variable.
3163a99982a7Sdougm */
3164a99982a7Sdougm if (share == NULL) {
316525a68471Sdougm if (realpath(sharepath, dir) == NULL) {
316625a68471Sdougm ret = SA_BAD_PATH;
316725a68471Sdougm (void) printf(gettext(
316825a68471Sdougm "Path is not valid: %s\n"), sharepath);
316925a68471Sdougm } else {
317025a68471Sdougm if (group != NULL)
317125a68471Sdougm share = sa_get_share(group, dir);
317225a68471Sdougm else
317325a68471Sdougm share = sa_find_share(handle, dir);
317425a68471Sdougm }
3175a99982a7Sdougm }
317625a68471Sdougm }
3177a99982a7Sdougm
317825a68471Sdougm /*
317925a68471Sdougm * If there hasn't been an error, there was likely a
318025a68471Sdougm * path found. If not, give the appropriate error
318125a68471Sdougm * message and set the return error. If it was found,
318225a68471Sdougm * then disable the share and then remove it from the
318325a68471Sdougm * configuration.
318425a68471Sdougm */
318525a68471Sdougm if (ret != SA_OK) {
318625a68471Sdougm return (ret);
318725a68471Sdougm }
318825a68471Sdougm if (share == NULL) {
318925a68471Sdougm if (group != NULL)
31906185db85Sdougm (void) printf(gettext("Share not found in group %s:"
319125a68471Sdougm " %s\n"), argv[optind], sharepath);
319225a68471Sdougm else
31936185db85Sdougm (void) printf(gettext("Share not found: %s\n"),
319425a68471Sdougm sharepath);
3195da6c28aaSamw ret = SA_NO_SUCH_PATH;
319625a68471Sdougm } else {
319725a68471Sdougm if (group == NULL)
31986185db85Sdougm group = sa_get_parent_group(share);
319925a68471Sdougm if (!dryrun) {
32006185db85Sdougm if (ret == SA_OK) {
3201da6c28aaSamw if (resource != NULL)
3202da6c28aaSamw ret = sa_disable_resource(resource,
3203da6c28aaSamw NULL);
3204da6c28aaSamw else
3205da6c28aaSamw ret = sa_disable_share(share, NULL);
32066185db85Sdougm /*
320725a68471Sdougm * We don't care if it fails since it
3208a99982a7Sdougm * could be disabled already. Some
3209a99982a7Sdougm * unexpected errors could occur that
3210a99982a7Sdougm * prevent removal, so also check for
3211a99982a7Sdougm * force being set.
32126185db85Sdougm */
3213da6c28aaSamw if ((ret == SA_OK || ret == SA_NO_SUCH_PATH ||
321425a68471Sdougm ret == SA_NOT_SUPPORTED ||
3215da6c28aaSamw ret == SA_SYSTEM_ERR || force) &&
3216da6c28aaSamw resource == NULL)
321725a68471Sdougm ret = sa_remove_share(share);
3218da6c28aaSamw
3219da6c28aaSamw if ((ret == SA_OK || ret == SA_NO_SUCH_PATH ||
3220da6c28aaSamw ret == SA_NOT_SUPPORTED ||
3221da6c28aaSamw ret == SA_SYSTEM_ERR || force) &&
3222da6c28aaSamw resource != NULL) {
3223da6c28aaSamw ret = sa_remove_resource(resource);
3224da6c28aaSamw if (ret == SA_OK) {
3225da6c28aaSamw /*
3226da6c28aaSamw * If this was the
3227da6c28aaSamw * last one, remove
3228da6c28aaSamw * the share as well.
3229da6c28aaSamw */
3230da6c28aaSamw resource =
3231da6c28aaSamw sa_get_share_resource(
3232da6c28aaSamw share, NULL);
3233da6c28aaSamw if (resource == NULL)
3234da6c28aaSamw ret = sa_remove_share(
3235da6c28aaSamw share);
3236da6c28aaSamw }
323725a68471Sdougm }
323825a68471Sdougm if (ret == SA_OK)
323925a68471Sdougm ret = sa_update_config(handle);
32406185db85Sdougm }
324125a68471Sdougm if (ret != SA_OK)
3242da6c28aaSamw (void) printf(gettext("Could not remove share:"
3243da6c28aaSamw " %s\n"), sa_errorstr(ret));
324425a68471Sdougm } else if (ret == SA_OK) {
32456185db85Sdougm char *pname;
32466185db85Sdougm pname = sa_get_group_attr(group, "name");
32476185db85Sdougm if (pname != NULL) {
324825a68471Sdougm auth = check_authorizations(pname, flags);
324925a68471Sdougm sa_free_attr_string(pname);
32506185db85Sdougm }
32516185db85Sdougm if (!auth && verbose) {
325225a68471Sdougm (void) printf(gettext(
325325a68471Sdougm "Command would fail: %s\n"),
325425a68471Sdougm sa_errorstr(SA_NO_PERMISSION));
32556185db85Sdougm }
32566185db85Sdougm }
32576185db85Sdougm }
32586185db85Sdougm return (ret);
32596185db85Sdougm }
32606185db85Sdougm
32616185db85Sdougm /*
32626185db85Sdougm * sa_set_share(flags, argc, argv)
32636185db85Sdougm *
32646185db85Sdougm * implements set-share subcommand.
32656185db85Sdougm */
32666185db85Sdougm
32676185db85Sdougm int
sa_set_share(sa_handle_t handle,int flags,int argc,char * argv[])3268549ec3ffSdougm sa_set_share(sa_handle_t handle, int flags, int argc, char *argv[])
32696185db85Sdougm {
32706185db85Sdougm int dryrun = 0;
32716185db85Sdougm int c;
32726185db85Sdougm int ret = SA_OK;
32736185db85Sdougm sa_group_t group, sharegroup;
3274dc20a302Sas sa_share_t share = NULL;
3275da6c28aaSamw sa_resource_t resource = NULL;
32766185db85Sdougm char *sharepath = NULL;
32776185db85Sdougm char *description = NULL;
3278da6c28aaSamw char *rsrcname = NULL;
3279da6c28aaSamw char *rsrc = NULL;
3280da6c28aaSamw char *newname = NULL;
3281da6c28aaSamw char *newrsrc;
3282da6c28aaSamw char *groupname = NULL;
32836185db85Sdougm int auth;
32846185db85Sdougm int verbose = 0;
32856185db85Sdougm
32866185db85Sdougm while ((c = getopt(argc, argv, "?hnd:r:s:")) != EOF) {
328725a68471Sdougm switch (c) {
328825a68471Sdougm case 'n':
328925a68471Sdougm dryrun++;
329025a68471Sdougm break;
329125a68471Sdougm case 'd':
329225a68471Sdougm description = optarg;
329325a68471Sdougm break;
329425a68471Sdougm case 'v':
329525a68471Sdougm verbose++;
329625a68471Sdougm break;
3297da6c28aaSamw case 'r':
3298da6c28aaSamw /*
3299da6c28aaSamw * Update share by resource name
3300da6c28aaSamw */
3301da6c28aaSamw if (rsrcname != NULL) {
3302da6c28aaSamw (void) printf(gettext(
3303da6c28aaSamw "Updating multiple resource names not "
3304da6c28aaSamw "supported\n"));
3305da6c28aaSamw return (SA_SYNTAX_ERR);
3306da6c28aaSamw }
3307da6c28aaSamw rsrcname = optarg;
3308da6c28aaSamw break;
330925a68471Sdougm case 's':
331025a68471Sdougm /*
331125a68471Sdougm * Save share path into group. Currently limit
331225a68471Sdougm * to one share per command.
331325a68471Sdougm */
331425a68471Sdougm if (sharepath != NULL) {
331525a68471Sdougm (void) printf(gettext(
331625a68471Sdougm "Updating multiple shares not "
33176185db85Sdougm "supported\n"));
3318da6c28aaSamw return (SA_SYNTAX_ERR);
331925a68471Sdougm }
332025a68471Sdougm sharepath = optarg;
332125a68471Sdougm break;
332225a68471Sdougm case 'h':
3323e7bab347Sdougm /* optopt on valid arg isn't defined */
3324e7bab347Sdougm optopt = c;
3325e7bab347Sdougm /*FALLTHROUGH*/
332625a68471Sdougm case '?':
3327e7bab347Sdougm default:
3328e7bab347Sdougm /*
3329e7bab347Sdougm * Since a bad option gets to here, sort it
3330e7bab347Sdougm * out and return a syntax error return value
3331e7bab347Sdougm * if necessary.
3332e7bab347Sdougm */
3333e7bab347Sdougm switch (optopt) {
3334e7bab347Sdougm default:
3335e7bab347Sdougm ret = SA_SYNTAX_ERR;
3336e7bab347Sdougm break;
3337e7bab347Sdougm case 'h':
3338e7bab347Sdougm case '?':
3339e7bab347Sdougm break;
3340e7bab347Sdougm }
334125a68471Sdougm (void) printf(gettext("usage: %s\n"),
334225a68471Sdougm sa_get_usage(USAGE_SET_SHARE));
3343e7bab347Sdougm return (ret);
33446185db85Sdougm }
33456185db85Sdougm }
334625a68471Sdougm
3347da6c28aaSamw if (optind >= argc && sharepath == NULL && rsrcname == NULL) {
334825a68471Sdougm if (sharepath == NULL) {
334925a68471Sdougm (void) printf(gettext("usage: %s\n"),
335025a68471Sdougm sa_get_usage(USAGE_SET_SHARE));
335125a68471Sdougm (void) printf(gettext("\tgroup must be specified\n"));
335225a68471Sdougm ret = SA_BAD_PATH;
335325a68471Sdougm } else {
335425a68471Sdougm ret = SA_OK;
335525a68471Sdougm }
33566185db85Sdougm }
33576185db85Sdougm if ((optind + 1) < argc) {
335825a68471Sdougm (void) printf(gettext("usage: %s\n"),
335925a68471Sdougm sa_get_usage(USAGE_SET_SHARE));
3360da6c28aaSamw (void) printf(gettext("\tExtraneous group(s) at end\n"));
3361da6c28aaSamw ret = SA_SYNTAX_ERR;
3362da6c28aaSamw }
3363da6c28aaSamw
3364da6c28aaSamw /*
3365da6c28aaSamw * Must have at least one of sharepath and rsrcrname.
3366da6c28aaSamw * It is a syntax error to be missing both.
3367da6c28aaSamw */
3368da6c28aaSamw if (sharepath == NULL && rsrcname == NULL) {
3369da6c28aaSamw (void) printf(gettext("usage: %s\n"),
3370da6c28aaSamw sa_get_usage(USAGE_SET_SHARE));
337125a68471Sdougm ret = SA_SYNTAX_ERR;
33726185db85Sdougm }
337325a68471Sdougm
337425a68471Sdougm if (ret != SA_OK)
337525a68471Sdougm return (ret);
337625a68471Sdougm
337725a68471Sdougm if (optind < argc) {
33786185db85Sdougm groupname = argv[optind];
3379549ec3ffSdougm group = sa_get_group(handle, groupname);
338025a68471Sdougm } else {
33816185db85Sdougm group = NULL;
33826185db85Sdougm groupname = NULL;
338325a68471Sdougm }
3384da6c28aaSamw if (rsrcname != NULL) {
3385da6c28aaSamw /*
3386da6c28aaSamw * If rsrcname exists, split rename syntax and then
3387da6c28aaSamw * convert to utf 8 if no errors.
3388da6c28aaSamw */
3389da6c28aaSamw newname = strchr(rsrcname, '=');
3390da6c28aaSamw if (newname != NULL) {
3391da6c28aaSamw *newname++ = '\0';
3392da6c28aaSamw }
3393da6c28aaSamw if (!validresource(rsrcname)) {
3394da6c28aaSamw ret = SA_INVALID_NAME;
3395da6c28aaSamw (void) printf(gettext("Invalid resource name: "
3396da6c28aaSamw "\"%s\"\n"), rsrcname);
339725a68471Sdougm } else {
3398da6c28aaSamw rsrc = conv_to_utf8(rsrcname);
339925a68471Sdougm }
3400da6c28aaSamw if (newname != NULL) {
3401da6c28aaSamw if (!validresource(newname)) {
3402da6c28aaSamw ret = SA_INVALID_NAME;
3403da6c28aaSamw (void) printf(gettext("Invalid resource name: "
3404da6c28aaSamw "%s\n"), newname);
3405ef18c5ecSDoug McCallum newname = NULL;
34066185db85Sdougm } else {
3407da6c28aaSamw newrsrc = conv_to_utf8(newname);
34086185db85Sdougm }
34096185db85Sdougm }
341025a68471Sdougm }
341125a68471Sdougm
3412da6c28aaSamw if (ret != SA_OK) {
3413da6c28aaSamw if (rsrcname != NULL && rsrcname != rsrc)
3414da6c28aaSamw sa_free_attr_string(rsrc);
3415da6c28aaSamw if (newname != NULL && newname != newrsrc)
3416da6c28aaSamw sa_free_attr_string(newrsrc);
3417da6c28aaSamw return (ret);
3418da6c28aaSamw }
3419da6c28aaSamw
3420da6c28aaSamw if (sharepath != NULL) {
3421da6c28aaSamw share = sa_find_share(handle, sharepath);
3422da6c28aaSamw } else if (rsrcname != NULL) {
3423da6c28aaSamw resource = sa_find_resource(handle, rsrc);
3424dc20a302Sas if (resource != NULL)
3425da6c28aaSamw share = sa_get_resource_parent(resource);
3426dc20a302Sas else
3427dc20a302Sas ret = SA_NO_SUCH_RESOURCE;
3428da6c28aaSamw }
3429da6c28aaSamw if (share != NULL) {
3430da6c28aaSamw sharegroup = sa_get_parent_group(share);
3431da6c28aaSamw if (group != NULL && group != sharegroup) {
3432da6c28aaSamw (void) printf(gettext("Group \"%s\" does not contain "
3433da6c28aaSamw "share %s\n"),
3434da6c28aaSamw argv[optind], sharepath);
3435da6c28aaSamw ret = SA_BAD_PATH;
3436da6c28aaSamw } else {
3437da6c28aaSamw int delgroupname = 0;
3438da6c28aaSamw if (groupname == NULL) {
3439da6c28aaSamw groupname = sa_get_group_attr(sharegroup,
3440da6c28aaSamw "name");
3441da6c28aaSamw delgroupname = 1;
3442da6c28aaSamw }
3443da6c28aaSamw if (groupname != NULL) {
3444da6c28aaSamw auth = check_authorizations(groupname, flags);
3445da6c28aaSamw if (delgroupname) {
3446da6c28aaSamw sa_free_attr_string(groupname);
3447da6c28aaSamw groupname = NULL;
3448da6c28aaSamw }
3449da6c28aaSamw } else {
3450da6c28aaSamw ret = SA_NO_MEMORY;
3451da6c28aaSamw }
3452da6c28aaSamw if (rsrcname != NULL) {
3453da6c28aaSamw resource = sa_find_resource(handle, rsrc);
3454da6c28aaSamw if (!dryrun) {
3455da6c28aaSamw if (newname != NULL &&
3456da6c28aaSamw resource != NULL)
3457da6c28aaSamw ret = sa_rename_resource(
3458da6c28aaSamw resource, newrsrc);
3459da6c28aaSamw else if (newname != NULL)
3460da6c28aaSamw ret = SA_NO_SUCH_RESOURCE;
3461da6c28aaSamw if (newname != NULL &&
3462da6c28aaSamw newname != newrsrc)
3463da6c28aaSamw sa_free_attr_string(newrsrc);
3464da6c28aaSamw }
3465da6c28aaSamw if (rsrc != rsrcname)
3466da6c28aaSamw sa_free_attr_string(rsrc);
3467da6c28aaSamw }
3468da6c28aaSamw
3469da6c28aaSamw /*
3470da6c28aaSamw * If the user has set a description, it will be
3471da6c28aaSamw * on the resource if -r was used otherwise it
3472da6c28aaSamw * must be on the share.
3473da6c28aaSamw */
3474cbfb650aScp if (!dryrun && ret == SA_OK && description != NULL) {
3475cbfb650aScp char *desc;
3476cbfb650aScp desc = conv_to_utf8(description);
3477da6c28aaSamw if (resource != NULL)
3478cbfb650aScp ret = sa_set_resource_description(
3479cbfb650aScp resource, desc);
3480da6c28aaSamw else
3481cbfb650aScp ret = sa_set_share_description(share,
3482cbfb650aScp desc);
3483cbfb650aScp if (desc != description)
3484cbfb650aScp sa_free_share_description(desc);
3485da6c28aaSamw }
3486da6c28aaSamw }
3487da6c28aaSamw if (!dryrun && ret == SA_OK) {
3488da6c28aaSamw if (resource != NULL)
3489da6c28aaSamw (void) sa_enable_resource(resource, NULL);
3490da6c28aaSamw ret = sa_update_config(handle);
3491da6c28aaSamw }
3492da6c28aaSamw switch (ret) {
3493da6c28aaSamw case SA_DUPLICATE_NAME:
3494da6c28aaSamw (void) printf(gettext("Resource name in use: %s\n"),
3495da6c28aaSamw rsrcname);
3496da6c28aaSamw break;
3497da6c28aaSamw default:
3498da6c28aaSamw (void) printf(gettext("Could not set: %s\n"),
3499da6c28aaSamw sa_errorstr(ret));
3500da6c28aaSamw break;
3501da6c28aaSamw case SA_OK:
3502da6c28aaSamw if (dryrun && !auth && verbose) {
3503da6c28aaSamw (void) printf(gettext(
3504da6c28aaSamw "Command would fail: %s\n"),
3505da6c28aaSamw sa_errorstr(SA_NO_PERMISSION));
3506da6c28aaSamw }
3507da6c28aaSamw break;
3508da6c28aaSamw }
3509da6c28aaSamw } else {
3510dc20a302Sas switch (ret) {
3511dc20a302Sas case SA_NO_SUCH_RESOURCE:
3512dc20a302Sas (void) printf(gettext("Resource \"%s\" not found\n"),
3513dc20a302Sas rsrcname);
3514dc20a302Sas break;
3515dc20a302Sas default:
3516dc20a302Sas if (sharepath != NULL) {
3517dc20a302Sas (void) printf(
3518dc20a302Sas gettext("Share path \"%s\" not found\n"),
3519dc20a302Sas sharepath);
3520dc20a302Sas ret = SA_NO_SUCH_PATH;
3521dc20a302Sas } else {
3522dc20a302Sas (void) printf(gettext("Set failed: %s\n"),
3523dc20a302Sas sa_errorstr(ret));
3524dc20a302Sas }
3525dc20a302Sas }
35266185db85Sdougm }
352725a68471Sdougm
35286185db85Sdougm return (ret);
35296185db85Sdougm }
35306185db85Sdougm
35316185db85Sdougm /*
35326185db85Sdougm * add_security(group, sectype, optlist, proto, *err)
35336185db85Sdougm *
35346185db85Sdougm * Helper function to add a security option (named optionset) to the
35356185db85Sdougm * group.
35366185db85Sdougm */
35376185db85Sdougm
35386185db85Sdougm static int
add_security(sa_group_t group,char * sectype,struct options * optlist,char * proto,int * err)35396185db85Sdougm add_security(sa_group_t group, char *sectype,
3540da6c28aaSamw struct options *optlist, char *proto, int *err)
35416185db85Sdougm {
35426185db85Sdougm sa_security_t security;
35436185db85Sdougm int ret = SA_OK;
35446185db85Sdougm int result = 0;
3545687915e9Sdougm sa_handle_t handle;
35466185db85Sdougm
35476185db85Sdougm sectype = sa_proto_space_alias(proto, sectype);
35486185db85Sdougm security = sa_get_security(group, sectype, proto);
354925a68471Sdougm if (security == NULL)
355025a68471Sdougm security = sa_create_security(group, sectype, proto);
355125a68471Sdougm
35526185db85Sdougm if (sectype != NULL)
355325a68471Sdougm sa_free_attr_string(sectype);
355425a68471Sdougm
355525a68471Sdougm if (security == NULL)
3556687915e9Sdougm goto done;
355725a68471Sdougm
3558687915e9Sdougm handle = sa_find_group_handle(group);
3559687915e9Sdougm if (handle == NULL) {
3560687915e9Sdougm ret = SA_CONFIG_ERR;
3561687915e9Sdougm goto done;
3562687915e9Sdougm }
356325a68471Sdougm while (optlist != NULL) {
35646185db85Sdougm sa_property_t prop;
35656185db85Sdougm prop = sa_get_property(security, optlist->optname);
35666185db85Sdougm if (prop == NULL) {
35676185db85Sdougm /*
356825a68471Sdougm * Add the property, but only if it is
35696185db85Sdougm * a non-NULL or non-zero length value
35706185db85Sdougm */
357125a68471Sdougm if (optlist->optvalue != NULL) {
357225a68471Sdougm prop = sa_create_property(optlist->optname,
357325a68471Sdougm optlist->optvalue);
357425a68471Sdougm if (prop != NULL) {
3575687915e9Sdougm ret = sa_valid_property(handle,
3576687915e9Sdougm security, proto, prop);
357725a68471Sdougm if (ret != SA_OK) {
357825a68471Sdougm (void) sa_remove_property(prop);
357925a68471Sdougm (void) printf(gettext(
358025a68471Sdougm "Could not add "
358125a68471Sdougm "property %s: %s\n"),
358225a68471Sdougm optlist->optname,
358325a68471Sdougm sa_errorstr(ret));
358425a68471Sdougm }
358525a68471Sdougm if (ret == SA_OK) {
358625a68471Sdougm ret = sa_add_property(security,
358725a68471Sdougm prop);
358825a68471Sdougm if (ret != SA_OK) {
358925a68471Sdougm (void) printf(gettext(
359025a68471Sdougm "Could not add "
3591da6c28aaSamw "property (%s=%s):"
3592da6c28aaSamw " %s\n"),
359325a68471Sdougm optlist->optname,
359425a68471Sdougm optlist->optvalue,
359525a68471Sdougm sa_errorstr(ret));
359625a68471Sdougm } else {
359725a68471Sdougm result = 1;
359825a68471Sdougm }
359925a68471Sdougm }
36006185db85Sdougm }
36016185db85Sdougm }
36026185db85Sdougm } else {
360325a68471Sdougm ret = sa_update_property(prop, optlist->optvalue);
360425a68471Sdougm result = 1; /* should check if really changed */
36056185db85Sdougm }
36066185db85Sdougm optlist = optlist->next;
36076185db85Sdougm }
360825a68471Sdougm /*
360925a68471Sdougm * When done, properties may have all been removed but
361025a68471Sdougm * we need to keep the security type itself until
361125a68471Sdougm * explicitly removed.
361225a68471Sdougm */
361325a68471Sdougm if (result)
361425a68471Sdougm ret = sa_commit_properties(security, 0);
3615687915e9Sdougm done:
36166185db85Sdougm *err = ret;
36176185db85Sdougm return (result);
36186185db85Sdougm }
36196185db85Sdougm
3620f8825440Sdougm /*
3621f8825440Sdougm * zfscheck(group, share)
3622f8825440Sdougm *
3623f8825440Sdougm * For the special case where a share was provided, make sure it is a
3624f8825440Sdougm * compatible path for a ZFS property change. The only path
3625f8825440Sdougm * acceptable is the path that defines the zfs sub-group (dataset with
3626f8825440Sdougm * the sharenfs property set) and not one of the paths that inherited
3627f8825440Sdougm * the NFS properties. Returns SA_OK if it is usable and
3628f8825440Sdougm * SA_NOT_ALLOWED if it isn't.
3629f8825440Sdougm *
3630f8825440Sdougm * If group is not a ZFS group/subgroup, we assume OK since the check
3631f8825440Sdougm * on return will catch errors for those cases. What we are looking
3632f8825440Sdougm * for here is that the group is ZFS and the share is not the defining
3633f8825440Sdougm * share. All else is SA_OK.
3634f8825440Sdougm */
3635f8825440Sdougm
3636f8825440Sdougm static int
zfscheck(sa_group_t group,sa_share_t share)3637f8825440Sdougm zfscheck(sa_group_t group, sa_share_t share)
3638f8825440Sdougm {
3639f8825440Sdougm int ret = SA_OK;
3640f8825440Sdougm char *attr;
3641f8825440Sdougm
3642f8825440Sdougm if (sa_group_is_zfs(group)) {
3643f8825440Sdougm /*
3644f8825440Sdougm * The group is a ZFS group. Does the share represent
3645f8825440Sdougm * the dataset that defined the group? It is only OK
3646f8825440Sdougm * if the attribute "subgroup" exists on the share and
3647f8825440Sdougm * has a value of "true".
3648f8825440Sdougm */
3649f8825440Sdougm
3650f8825440Sdougm ret = SA_NOT_ALLOWED;
3651f8825440Sdougm attr = sa_get_share_attr(share, "subgroup");
3652f8825440Sdougm if (attr != NULL) {
3653f8825440Sdougm if (strcmp(attr, "true") == 0)
3654f8825440Sdougm ret = SA_OK;
3655f8825440Sdougm sa_free_attr_string(attr);
3656f8825440Sdougm }
3657f8825440Sdougm }
3658f8825440Sdougm return (ret);
3659f8825440Sdougm }
3660f8825440Sdougm
36616185db85Sdougm /*
3662da6c28aaSamw * basic_set(groupname, optlist, protocol, sharepath, rsrcname, dryrun)
36636185db85Sdougm *
36646185db85Sdougm * This function implements "set" when a name space (-S) is not
36656185db85Sdougm * specified. It is a basic set. Options and other CLI parsing has
36666185db85Sdougm * already been done.
3667da6c28aaSamw *
3668da6c28aaSamw * "rsrcname" is a "resource name". If it is non-NULL, it must match
3669da6c28aaSamw * the sharepath if present or group if present, otherwise it is used
3670da6c28aaSamw * to set options.
3671da6c28aaSamw *
3672da6c28aaSamw * Resource names may take options if the protocol supports it. If the
3673da6c28aaSamw * protocol doesn't support resource level options, rsrcname is just
3674da6c28aaSamw * an alias for the share.
36756185db85Sdougm */
36766185db85Sdougm
36776185db85Sdougm static int
basic_set(sa_handle_t handle,char * groupname,struct options * optlist,char * protocol,char * sharepath,char * rsrcname,int dryrun)3678549ec3ffSdougm basic_set(sa_handle_t handle, char *groupname, struct options *optlist,
3679da6c28aaSamw char *protocol, char *sharepath, char *rsrcname, int dryrun)
36806185db85Sdougm {
36816185db85Sdougm sa_group_t group;
36826185db85Sdougm int ret = SA_OK;
36836185db85Sdougm int change = 0;
36846185db85Sdougm struct list *worklist = NULL;
36856185db85Sdougm
3686549ec3ffSdougm group = sa_get_group(handle, groupname);
36876185db85Sdougm if (group != NULL) {
368825a68471Sdougm sa_share_t share = NULL;
3689da6c28aaSamw sa_resource_t resource = NULL;
3690da6c28aaSamw
3691da6c28aaSamw /*
3692da6c28aaSamw * If there is a sharepath, make sure it belongs to
3693da6c28aaSamw * the group.
3694da6c28aaSamw */
369525a68471Sdougm if (sharepath != NULL) {
369625a68471Sdougm share = sa_get_share(group, sharepath);
369725a68471Sdougm if (share == NULL) {
369825a68471Sdougm (void) printf(gettext(
369925a68471Sdougm "Share does not exist in group %s\n"),
370025a68471Sdougm groupname, sharepath);
370125a68471Sdougm ret = SA_NO_SUCH_PATH;
3702f8825440Sdougm } else {
3703f8825440Sdougm /* if ZFS and OK, then only group */
3704f8825440Sdougm ret = zfscheck(group, share);
3705f8825440Sdougm if (ret == SA_OK &&
3706f8825440Sdougm sa_group_is_zfs(group))
3707f8825440Sdougm share = NULL;
3708f8825440Sdougm if (ret == SA_NOT_ALLOWED)
3709f8825440Sdougm (void) printf(gettext(
3710f8825440Sdougm "Properties on ZFS group shares "
3711f8825440Sdougm "not supported: %s\n"), sharepath);
371225a68471Sdougm }
37136185db85Sdougm }
3714da6c28aaSamw
3715da6c28aaSamw /*
3716da6c28aaSamw * If a resource name exists, make sure it belongs to
3717da6c28aaSamw * the share if present else it belongs to the
3718da6c28aaSamw * group. Also check the protocol to see if it
3719da6c28aaSamw * supports resource level properties or not. If not,
3720da6c28aaSamw * use share only.
3721da6c28aaSamw */
3722da6c28aaSamw if (rsrcname != NULL) {
3723da6c28aaSamw if (share != NULL) {
3724da6c28aaSamw resource = sa_get_share_resource(share,
3725da6c28aaSamw rsrcname);
3726da6c28aaSamw if (resource == NULL)
3727da6c28aaSamw ret = SA_NO_SUCH_RESOURCE;
3728da6c28aaSamw } else {
3729da6c28aaSamw resource = sa_get_resource(group, rsrcname);
3730da6c28aaSamw if (resource != NULL)
3731da6c28aaSamw share = sa_get_resource_parent(
3732da6c28aaSamw resource);
3733da6c28aaSamw else
3734da6c28aaSamw ret = SA_NO_SUCH_RESOURCE;
3735da6c28aaSamw }
3736da6c28aaSamw if (ret == SA_OK && resource != NULL) {
3737da6c28aaSamw uint64_t features;
3738da6c28aaSamw /*
3739da6c28aaSamw * Check to see if the resource can take
3740da6c28aaSamw * properties. If so, stick the resource into
3741da6c28aaSamw * "share" so it will all just work.
3742da6c28aaSamw */
3743da6c28aaSamw features = sa_proto_get_featureset(protocol);
3744da6c28aaSamw if (features & SA_FEATURE_RESOURCE)
3745da6c28aaSamw share = (sa_share_t)resource;
3746da6c28aaSamw }
3747da6c28aaSamw }
3748da6c28aaSamw
374925a68471Sdougm if (ret == SA_OK) {
375025a68471Sdougm /* group must exist */
3751687915e9Sdougm ret = valid_options(handle, optlist, protocol,
375225a68471Sdougm share == NULL ? group : share, NULL);
375325a68471Sdougm if (ret == SA_OK && !dryrun) {
375425a68471Sdougm if (share != NULL)
375525a68471Sdougm change |= add_optionset(share, optlist,
375625a68471Sdougm protocol, &ret);
375725a68471Sdougm else
375825a68471Sdougm change |= add_optionset(group, optlist,
375925a68471Sdougm protocol, &ret);
376025a68471Sdougm if (ret == SA_OK && change)
376125a68471Sdougm worklist = add_list(worklist, group,
3762da6c28aaSamw share, protocol);
376325a68471Sdougm }
376425a68471Sdougm }
376525a68471Sdougm free_opt(optlist);
37666185db85Sdougm } else {
37676185db85Sdougm (void) printf(gettext("Group \"%s\" not found\n"), groupname);
37686185db85Sdougm ret = SA_NO_SUCH_GROUP;
37696185db85Sdougm }
37706185db85Sdougm /*
37716185db85Sdougm * we have a group and potentially legal additions
37726185db85Sdougm */
37736185db85Sdougm
377425a68471Sdougm /*
377525a68471Sdougm * Commit to configuration if not a dryrunp and properties
377625a68471Sdougm * have changed.
377725a68471Sdougm */
377825a68471Sdougm if (!dryrun && ret == SA_OK && change && worklist != NULL)
37796185db85Sdougm /* properties changed, so update all shares */
3780da6c28aaSamw (void) enable_all_groups(handle, worklist, 0, 0, protocol,
3781da6c28aaSamw B_TRUE);
378225a68471Sdougm
37836185db85Sdougm if (worklist != NULL)
378425a68471Sdougm free_list(worklist);
37856185db85Sdougm return (ret);
37866185db85Sdougm }
37876185db85Sdougm
37886185db85Sdougm /*
37896185db85Sdougm * space_set(groupname, optlist, protocol, sharepath, dryrun)
37906185db85Sdougm *
37916185db85Sdougm * This function implements "set" when a name space (-S) is
37926185db85Sdougm * specified. It is a namespace set. Options and other CLI parsing has
37936185db85Sdougm * already been done.
37946185db85Sdougm */
37956185db85Sdougm
37966185db85Sdougm static int
space_set(sa_handle_t handle,char * groupname,struct options * optlist,char * protocol,char * sharepath,int dryrun,char * sectype)3797549ec3ffSdougm space_set(sa_handle_t handle, char *groupname, struct options *optlist,
3798da6c28aaSamw char *protocol, char *sharepath, int dryrun, char *sectype)
37996185db85Sdougm {
38006185db85Sdougm sa_group_t group;
38016185db85Sdougm int ret = SA_OK;
38026185db85Sdougm int change = 0;
38036185db85Sdougm struct list *worklist = NULL;
38046185db85Sdougm
38056185db85Sdougm /*
38066185db85Sdougm * make sure protcol and sectype are valid
38076185db85Sdougm */
38086185db85Sdougm
38096185db85Sdougm if (sa_proto_valid_space(protocol, sectype) == 0) {
381025a68471Sdougm (void) printf(gettext("Option space \"%s\" not valid "
381125a68471Sdougm "for protocol.\n"), sectype);
381225a68471Sdougm return (SA_INVALID_SECURITY);
38136185db85Sdougm }
38146185db85Sdougm
3815549ec3ffSdougm group = sa_get_group(handle, groupname);
38166185db85Sdougm if (group != NULL) {
381725a68471Sdougm sa_share_t share = NULL;
381825a68471Sdougm if (sharepath != NULL) {
381925a68471Sdougm share = sa_get_share(group, sharepath);
382025a68471Sdougm if (share == NULL) {
382125a68471Sdougm (void) printf(gettext(
382225a68471Sdougm "Share does not exist in group %s\n"),
382325a68471Sdougm groupname, sharepath);
382425a68471Sdougm ret = SA_NO_SUCH_PATH;
3825f8825440Sdougm } else {
3826f8825440Sdougm /* if ZFS and OK, then only group */
3827f8825440Sdougm ret = zfscheck(group, share);
3828f8825440Sdougm if (ret == SA_OK &&
3829f8825440Sdougm sa_group_is_zfs(group))
3830f8825440Sdougm share = NULL;
3831f8825440Sdougm if (ret == SA_NOT_ALLOWED)
3832f8825440Sdougm (void) printf(gettext(
3833f8825440Sdougm "Properties on ZFS group shares "
3834f8825440Sdougm "not supported: %s\n"), sharepath);
383525a68471Sdougm }
38366185db85Sdougm }
383725a68471Sdougm if (ret == SA_OK) {
383825a68471Sdougm /* group must exist */
3839687915e9Sdougm ret = valid_options(handle, optlist, protocol,
384025a68471Sdougm share == NULL ? group : share, sectype);
384125a68471Sdougm if (ret == SA_OK && !dryrun) {
384225a68471Sdougm if (share != NULL)
384325a68471Sdougm change = add_security(share, sectype,
384425a68471Sdougm optlist, protocol, &ret);
384525a68471Sdougm else
384625a68471Sdougm change = add_security(group, sectype,
384725a68471Sdougm optlist, protocol, &ret);
384825a68471Sdougm if (ret != SA_OK)
384925a68471Sdougm (void) printf(gettext(
385025a68471Sdougm "Could not set property: %s\n"),
385125a68471Sdougm sa_errorstr(ret));
385225a68471Sdougm }
385325a68471Sdougm if (ret == SA_OK && change)
3854da6c28aaSamw worklist = add_list(worklist, group, share,
3855da6c28aaSamw protocol);
38566185db85Sdougm }
385725a68471Sdougm free_opt(optlist);
38586185db85Sdougm } else {
38596185db85Sdougm (void) printf(gettext("Group \"%s\" not found\n"), groupname);
38606185db85Sdougm ret = SA_NO_SUCH_GROUP;
38616185db85Sdougm }
3862da6c28aaSamw
38636185db85Sdougm /*
3864da6c28aaSamw * We have a group and potentially legal additions.
38656185db85Sdougm */
38666185db85Sdougm
386725a68471Sdougm /* Commit to configuration if not a dryrun */
38686185db85Sdougm if (!dryrun && ret == 0) {
386925a68471Sdougm if (change && worklist != NULL) {
387025a68471Sdougm /* properties changed, so update all shares */
387125a68471Sdougm (void) enable_all_groups(handle, worklist, 0, 0,
3872da6c28aaSamw protocol, B_TRUE);
387325a68471Sdougm }
387425a68471Sdougm ret = sa_update_config(handle);
38756185db85Sdougm }
38766185db85Sdougm if (worklist != NULL)
387725a68471Sdougm free_list(worklist);
38786185db85Sdougm return (ret);
38796185db85Sdougm }
38806185db85Sdougm
38816185db85Sdougm /*
38826185db85Sdougm * sa_set(flags, argc, argv)
38836185db85Sdougm *
38846185db85Sdougm * Implements the set subcommand. It keys off of -S to determine which
38856185db85Sdougm * set of operations to actually do.
38866185db85Sdougm */
38876185db85Sdougm
38886185db85Sdougm int
sa_set(sa_handle_t handle,int flags,int argc,char * argv[])3889549ec3ffSdougm sa_set(sa_handle_t handle, int flags, int argc, char *argv[])
38906185db85Sdougm {
38916185db85Sdougm char *groupname;
38926185db85Sdougm int verbose = 0;
38936185db85Sdougm int dryrun = 0;
38946185db85Sdougm int c;
38956185db85Sdougm char *protocol = NULL;
38966185db85Sdougm int ret = SA_OK;
38976185db85Sdougm struct options *optlist = NULL;
3898da6c28aaSamw char *rsrcname = NULL;
38996185db85Sdougm char *sharepath = NULL;
39006185db85Sdougm char *optset = NULL;
39016185db85Sdougm int auth;
39026185db85Sdougm
3903da6c28aaSamw while ((c = getopt(argc, argv, "?hvnP:p:r:s:S:")) != EOF) {
390425a68471Sdougm switch (c) {
390525a68471Sdougm case 'v':
390625a68471Sdougm verbose++;
390725a68471Sdougm break;
390825a68471Sdougm case 'n':
390925a68471Sdougm dryrun++;
391025a68471Sdougm break;
391125a68471Sdougm case 'P':
3912da6c28aaSamw if (protocol != NULL) {
3913da6c28aaSamw (void) printf(gettext(
3914da6c28aaSamw "Specifying multiple protocols "
3915da6c28aaSamw "not supported: %s\n"), protocol);
3916da6c28aaSamw return (SA_SYNTAX_ERR);
3917da6c28aaSamw }
391825a68471Sdougm protocol = optarg;
391925a68471Sdougm if (!sa_valid_protocol(protocol)) {
392025a68471Sdougm (void) printf(gettext(
392125a68471Sdougm "Invalid protocol specified: %s\n"),
392225a68471Sdougm protocol);
392325a68471Sdougm return (SA_INVALID_PROTOCOL);
392425a68471Sdougm }
392525a68471Sdougm break;
392625a68471Sdougm case 'p':
392725a68471Sdougm ret = add_opt(&optlist, optarg, 0);
392825a68471Sdougm switch (ret) {
392925a68471Sdougm case OPT_ADD_SYNTAX:
393025a68471Sdougm (void) printf(gettext("Property syntax error:"
393125a68471Sdougm " %s\n"), optarg);
393225a68471Sdougm return (SA_SYNTAX_ERR);
393325a68471Sdougm case OPT_ADD_MEMORY:
393425a68471Sdougm (void) printf(gettext("No memory to set "
393525a68471Sdougm "property: %s\n"), optarg);
393625a68471Sdougm return (SA_NO_MEMORY);
393725a68471Sdougm default:
393825a68471Sdougm break;
393925a68471Sdougm }
394025a68471Sdougm break;
3941da6c28aaSamw case 'r':
3942da6c28aaSamw if (rsrcname != NULL) {
3943da6c28aaSamw (void) printf(gettext(
3944da6c28aaSamw "Setting multiple resource names not"
3945da6c28aaSamw " supported\n"));
3946da6c28aaSamw return (SA_SYNTAX_ERR);
3947da6c28aaSamw }
3948da6c28aaSamw rsrcname = optarg;
3949da6c28aaSamw break;
395025a68471Sdougm case 's':
3951da6c28aaSamw if (sharepath != NULL) {
3952da6c28aaSamw (void) printf(gettext(
3953da6c28aaSamw "Setting multiple shares not supported\n"));
3954da6c28aaSamw return (SA_SYNTAX_ERR);
3955da6c28aaSamw }
395625a68471Sdougm sharepath = optarg;
395725a68471Sdougm break;
395825a68471Sdougm case 'S':
3959da6c28aaSamw if (optset != NULL) {
3960da6c28aaSamw (void) printf(gettext(
3961da6c28aaSamw "Specifying multiple property "
3962da6c28aaSamw "spaces not supported: %s\n"), optset);
3963da6c28aaSamw return (SA_SYNTAX_ERR);
3964da6c28aaSamw }
396525a68471Sdougm optset = optarg;
396625a68471Sdougm break;
396725a68471Sdougm case 'h':
3968e7bab347Sdougm /* optopt on valid arg isn't defined */
3969e7bab347Sdougm optopt = c;
3970e7bab347Sdougm /*FALLTHROUGH*/
397125a68471Sdougm case '?':
3972e7bab347Sdougm default:
3973e7bab347Sdougm /*
3974e7bab347Sdougm * Since a bad option gets to here, sort it
3975e7bab347Sdougm * out and return a syntax error return value
3976e7bab347Sdougm * if necessary.
3977e7bab347Sdougm */
3978e7bab347Sdougm switch (optopt) {
3979e7bab347Sdougm default:
3980e7bab347Sdougm ret = SA_SYNTAX_ERR;
3981e7bab347Sdougm break;
3982e7bab347Sdougm case 'h':
3983e7bab347Sdougm case '?':
3984e7bab347Sdougm break;
3985e7bab347Sdougm }
398625a68471Sdougm (void) printf(gettext("usage: %s\n"),
398725a68471Sdougm sa_get_usage(USAGE_SET));
3988e7bab347Sdougm return (ret);
39896185db85Sdougm }
39906185db85Sdougm }
39916185db85Sdougm
39926185db85Sdougm if (optlist != NULL)
399325a68471Sdougm ret = chk_opt(optlist, optset != NULL, protocol);
39946185db85Sdougm
39956185db85Sdougm if (optind >= argc || (optlist == NULL && optset == NULL) ||
399625a68471Sdougm protocol == NULL || ret != OPT_ADD_OK) {
399725a68471Sdougm char *sep = "\t";
399825a68471Sdougm
399925a68471Sdougm (void) printf(gettext("usage: %s\n"), sa_get_usage(USAGE_SET));
400025a68471Sdougm if (optind >= argc) {
400125a68471Sdougm (void) printf(gettext("%sgroup must be specified"),
400225a68471Sdougm sep);
400325a68471Sdougm sep = ", ";
400425a68471Sdougm }
400525a68471Sdougm if (optlist == NULL) {
400625a68471Sdougm (void) printf(gettext("%sat least one property must be"
400725a68471Sdougm " specified"), sep);
400825a68471Sdougm sep = ", ";
400925a68471Sdougm }
401025a68471Sdougm if (protocol == NULL) {
401125a68471Sdougm (void) printf(gettext("%sprotocol must be specified"),
401225a68471Sdougm sep);
401325a68471Sdougm sep = ", ";
401425a68471Sdougm }
401525a68471Sdougm (void) printf("\n");
401625a68471Sdougm ret = SA_SYNTAX_ERR;
40176185db85Sdougm } else {
40186185db85Sdougm /*
4019f8825440Sdougm * Group already exists so we can proceed after a few
4020f8825440Sdougm * additional checks related to ZFS handling.
40216185db85Sdougm */
40226185db85Sdougm
402325a68471Sdougm groupname = argv[optind];
4024f8825440Sdougm if (strcmp(groupname, "zfs") == 0) {
4025f8825440Sdougm (void) printf(gettext("Changing properties for group "
4026f8825440Sdougm "\"zfs\" not allowed\n"));
4027f8825440Sdougm return (SA_NOT_ALLOWED);
4028f8825440Sdougm }
4029f8825440Sdougm
403025a68471Sdougm auth = check_authorizations(groupname, flags);
403125a68471Sdougm if (optset == NULL)
403225a68471Sdougm ret = basic_set(handle, groupname, optlist, protocol,
4033da6c28aaSamw sharepath, rsrcname, dryrun);
403425a68471Sdougm else
403525a68471Sdougm ret = space_set(handle, groupname, optlist, protocol,
403625a68471Sdougm sharepath, dryrun, optset);
403725a68471Sdougm if (dryrun && ret == SA_OK && !auth && verbose) {
403825a68471Sdougm (void) printf(gettext("Command would fail: %s\n"),
403925a68471Sdougm sa_errorstr(SA_NO_PERMISSION));
404025a68471Sdougm }
40416185db85Sdougm }
40426185db85Sdougm return (ret);
40436185db85Sdougm }
40446185db85Sdougm
40456185db85Sdougm /*
40466185db85Sdougm * remove_options(group, optlist, proto, *err)
40476185db85Sdougm *
404825a68471Sdougm * Helper function to actually remove options from a group after all
40496185db85Sdougm * preprocessing is done.
40506185db85Sdougm */
40516185db85Sdougm
40526185db85Sdougm static int
remove_options(sa_group_t group,struct options * optlist,char * proto,int * err)40536185db85Sdougm remove_options(sa_group_t group, struct options *optlist,
4054da6c28aaSamw char *proto, int *err)
40556185db85Sdougm {
40566185db85Sdougm struct options *cur;
40576185db85Sdougm sa_optionset_t optionset;
40586185db85Sdougm sa_property_t prop;
40596185db85Sdougm int change = 0;
40606185db85Sdougm int ret = SA_OK;
40616185db85Sdougm
40626185db85Sdougm optionset = sa_get_optionset(group, proto);
40636185db85Sdougm if (optionset != NULL) {
406425a68471Sdougm for (cur = optlist; cur != NULL; cur = cur->next) {
406525a68471Sdougm prop = sa_get_property(optionset, cur->optname);
406625a68471Sdougm if (prop != NULL) {
406725a68471Sdougm ret = sa_remove_property(prop);
406825a68471Sdougm if (ret != SA_OK)
406925a68471Sdougm break;
407025a68471Sdougm change = 1;
407125a68471Sdougm }
40726185db85Sdougm }
40736185db85Sdougm }
40746185db85Sdougm if (ret == SA_OK && change)
407525a68471Sdougm ret = sa_commit_properties(optionset, 0);
40766185db85Sdougm
40776185db85Sdougm if (err != NULL)
407825a68471Sdougm *err = ret;
40796185db85Sdougm return (change);
40806185db85Sdougm }
40816185db85Sdougm
40826185db85Sdougm /*
40836185db85Sdougm * valid_unset(group, optlist, proto)
40846185db85Sdougm *
40856185db85Sdougm * Sanity check the optlist to make sure they can be removed. Issue an
40866185db85Sdougm * error if a property doesn't exist.
40876185db85Sdougm */
40886185db85Sdougm
40896185db85Sdougm static int
valid_unset(sa_group_t group,struct options * optlist,char * proto)40906185db85Sdougm valid_unset(sa_group_t group, struct options *optlist, char *proto)
40916185db85Sdougm {
40926185db85Sdougm struct options *cur;
40936185db85Sdougm sa_optionset_t optionset;
40946185db85Sdougm sa_property_t prop;
40956185db85Sdougm int ret = SA_OK;
40966185db85Sdougm
40976185db85Sdougm optionset = sa_get_optionset(group, proto);
40986185db85Sdougm if (optionset != NULL) {
409925a68471Sdougm for (cur = optlist; cur != NULL; cur = cur->next) {
410025a68471Sdougm prop = sa_get_property(optionset, cur->optname);
410125a68471Sdougm if (prop == NULL) {
410225a68471Sdougm (void) printf(gettext(
410325a68471Sdougm "Could not unset property %s: not set\n"),
410425a68471Sdougm cur->optname);
410525a68471Sdougm ret = SA_NO_SUCH_PROP;
410625a68471Sdougm }
41076185db85Sdougm }
41086185db85Sdougm }
41096185db85Sdougm return (ret);
41106185db85Sdougm }
41116185db85Sdougm
41126185db85Sdougm /*
41136185db85Sdougm * valid_unset_security(group, optlist, proto)
41146185db85Sdougm *
41156185db85Sdougm * Sanity check the optlist to make sure they can be removed. Issue an
41166185db85Sdougm * error if a property doesn't exist.
41176185db85Sdougm */
41186185db85Sdougm
41196185db85Sdougm static int
valid_unset_security(sa_group_t group,struct options * optlist,char * proto,char * sectype)41206185db85Sdougm valid_unset_security(sa_group_t group, struct options *optlist, char *proto,
4121da6c28aaSamw char *sectype)
41226185db85Sdougm {
41236185db85Sdougm struct options *cur;
41246185db85Sdougm sa_security_t security;
41256185db85Sdougm sa_property_t prop;
41266185db85Sdougm int ret = SA_OK;
41276185db85Sdougm char *sec;
41286185db85Sdougm
41296185db85Sdougm sec = sa_proto_space_alias(proto, sectype);
41306185db85Sdougm security = sa_get_security(group, sec, proto);
41316185db85Sdougm if (security != NULL) {
413225a68471Sdougm for (cur = optlist; cur != NULL; cur = cur->next) {
413325a68471Sdougm prop = sa_get_property(security, cur->optname);
413425a68471Sdougm if (prop == NULL) {
413525a68471Sdougm (void) printf(gettext(
413625a68471Sdougm "Could not unset property %s: not set\n"),
413725a68471Sdougm cur->optname);
413825a68471Sdougm ret = SA_NO_SUCH_PROP;
413925a68471Sdougm }
41406185db85Sdougm }
41416185db85Sdougm } else {
414225a68471Sdougm (void) printf(gettext(
414325a68471Sdougm "Could not unset %s: space not defined\n"), sectype);
414425a68471Sdougm ret = SA_NO_SUCH_SECURITY;
41456185db85Sdougm }
41466185db85Sdougm if (sec != NULL)
414725a68471Sdougm sa_free_attr_string(sec);
41486185db85Sdougm return (ret);
41496185db85Sdougm }
41506185db85Sdougm
41516185db85Sdougm /*
41526185db85Sdougm * remove_security(group, optlist, proto)
41536185db85Sdougm *
41546185db85Sdougm * Remove the properties since they were checked as valid.
41556185db85Sdougm */
41566185db85Sdougm
41576185db85Sdougm static int
remove_security(sa_group_t group,char * sectype,struct options * optlist,char * proto,int * err)41586185db85Sdougm remove_security(sa_group_t group, char *sectype,
4159da6c28aaSamw struct options *optlist, char *proto, int *err)
41606185db85Sdougm {
41616185db85Sdougm sa_security_t security;
41626185db85Sdougm int ret = SA_OK;
41636185db85Sdougm int change = 0;
41646185db85Sdougm
41656185db85Sdougm sectype = sa_proto_space_alias(proto, sectype);
41666185db85Sdougm security = sa_get_security(group, sectype, proto);
41676185db85Sdougm if (sectype != NULL)
416825a68471Sdougm sa_free_attr_string(sectype);
41696185db85Sdougm
41706185db85Sdougm if (security != NULL) {
417125a68471Sdougm while (optlist != NULL) {
417225a68471Sdougm sa_property_t prop;
417325a68471Sdougm prop = sa_get_property(security, optlist->optname);
417425a68471Sdougm if (prop != NULL) {
417525a68471Sdougm ret = sa_remove_property(prop);
417625a68471Sdougm if (ret != SA_OK)
417725a68471Sdougm break;
417825a68471Sdougm change = 1;
417925a68471Sdougm }
418025a68471Sdougm optlist = optlist->next;
41816185db85Sdougm }
41826185db85Sdougm /*
41836185db85Sdougm * when done, properties may have all been removed but
41846185db85Sdougm * we need to keep the security type itself until
41856185db85Sdougm * explicitly removed.
41866185db85Sdougm */
418725a68471Sdougm if (ret == SA_OK && change)
418825a68471Sdougm ret = sa_commit_properties(security, 0);
41896185db85Sdougm } else {
419025a68471Sdougm ret = SA_NO_SUCH_PROP;
41916185db85Sdougm }
41926185db85Sdougm if (err != NULL)
419325a68471Sdougm *err = ret;
41946185db85Sdougm return (change);
41956185db85Sdougm }
41966185db85Sdougm
41976185db85Sdougm /*
4198da6c28aaSamw * basic_unset(groupname, optlist, protocol, sharepath, rsrcname, dryrun)
41996185db85Sdougm *
420025a68471Sdougm * Unset non-named optionset properties.
42016185db85Sdougm */
42026185db85Sdougm
42036185db85Sdougm static int
basic_unset(sa_handle_t handle,char * groupname,struct options * optlist,char * protocol,char * sharepath,char * rsrcname,int dryrun)4204549ec3ffSdougm basic_unset(sa_handle_t handle, char *groupname, struct options *optlist,
4205da6c28aaSamw char *protocol, char *sharepath, char *rsrcname, int dryrun)
42066185db85Sdougm {
42076185db85Sdougm sa_group_t group;
42086185db85Sdougm int ret = SA_OK;
42096185db85Sdougm int change = 0;
42106185db85Sdougm struct list *worklist = NULL;
421125a68471Sdougm sa_share_t share = NULL;
4212da6c28aaSamw sa_resource_t resource = NULL;
42136185db85Sdougm
4214549ec3ffSdougm group = sa_get_group(handle, groupname);
421525a68471Sdougm if (group == NULL)
421625a68471Sdougm return (ret);
421725a68471Sdougm
4218da6c28aaSamw /*
4219da6c28aaSamw * If there is a sharepath, make sure it belongs to
4220da6c28aaSamw * the group.
4221da6c28aaSamw */
422225a68471Sdougm if (sharepath != NULL) {
42236185db85Sdougm share = sa_get_share(group, sharepath);
42246185db85Sdougm if (share == NULL) {
422525a68471Sdougm (void) printf(gettext(
422625a68471Sdougm "Share does not exist in group %s\n"),
422725a68471Sdougm groupname, sharepath);
422825a68471Sdougm ret = SA_NO_SUCH_PATH;
42296185db85Sdougm }
423025a68471Sdougm }
4231da6c28aaSamw /*
4232da6c28aaSamw * If a resource name exists, make sure it belongs to
4233da6c28aaSamw * the share if present else it belongs to the
4234da6c28aaSamw * group. Also check the protocol to see if it
4235da6c28aaSamw * supports resource level properties or not. If not,
4236da6c28aaSamw * use share only.
4237da6c28aaSamw */
4238da6c28aaSamw if (rsrcname != NULL) {
4239da6c28aaSamw if (share != NULL) {
4240da6c28aaSamw resource = sa_get_share_resource(share, rsrcname);
4241da6c28aaSamw if (resource == NULL)
4242da6c28aaSamw ret = SA_NO_SUCH_RESOURCE;
4243da6c28aaSamw } else {
4244da6c28aaSamw resource = sa_get_resource(group, rsrcname);
4245da6c28aaSamw if (resource != NULL) {
4246da6c28aaSamw share = sa_get_resource_parent(resource);
4247da6c28aaSamw } else {
4248da6c28aaSamw ret = SA_NO_SUCH_RESOURCE;
4249da6c28aaSamw }
4250da6c28aaSamw }
4251da6c28aaSamw if (ret == SA_OK && resource != NULL) {
4252da6c28aaSamw uint64_t features;
4253da6c28aaSamw /*
4254da6c28aaSamw * Check to see if the resource can take
4255da6c28aaSamw * properties. If so, stick the resource into
4256da6c28aaSamw * "share" so it will all just work.
4257da6c28aaSamw */
4258da6c28aaSamw features = sa_proto_get_featureset(protocol);
4259da6c28aaSamw if (features & SA_FEATURE_RESOURCE)
4260da6c28aaSamw share = (sa_share_t)resource;
4261da6c28aaSamw }
4262da6c28aaSamw }
4263da6c28aaSamw
426425a68471Sdougm if (ret == SA_OK) {
42656185db85Sdougm /* group must exist */
42666185db85Sdougm ret = valid_unset(share != NULL ? share : group,
426725a68471Sdougm optlist, protocol);
42686185db85Sdougm if (ret == SA_OK && !dryrun) {
426925a68471Sdougm if (share != NULL) {
427025a68471Sdougm sa_optionset_t optionset;
427125a68471Sdougm sa_property_t prop;
427225a68471Sdougm change |= remove_options(share, optlist,
427325a68471Sdougm protocol, &ret);
427425a68471Sdougm /*
427525a68471Sdougm * If a share optionset is
427625a68471Sdougm * empty, remove it.
427725a68471Sdougm */
427825a68471Sdougm optionset = sa_get_optionset((sa_share_t)share,
427925a68471Sdougm protocol);
428025a68471Sdougm if (optionset != NULL) {
428125a68471Sdougm prop = sa_get_property(optionset, NULL);
428225a68471Sdougm if (prop == NULL)
428325a68471Sdougm (void) sa_destroy_optionset(
428425a68471Sdougm optionset);
428525a68471Sdougm }
428625a68471Sdougm } else {
428725a68471Sdougm change |= remove_options(group,
428825a68471Sdougm optlist, protocol, &ret);
428925a68471Sdougm }
429025a68471Sdougm if (ret == SA_OK && change)
4291da6c28aaSamw worklist = add_list(worklist, group, share,
4292da6c28aaSamw protocol);
429325a68471Sdougm if (ret != SA_OK)
429425a68471Sdougm (void) printf(gettext(
429525a68471Sdougm "Could not remove properties: "
429625a68471Sdougm "%s\n"), sa_errorstr(ret));
429725a68471Sdougm }
429825a68471Sdougm } else {
4299da6c28aaSamw (void) printf(gettext("Group \"%s\" not found\n"), groupname);
43006185db85Sdougm ret = SA_NO_SUCH_GROUP;
43016185db85Sdougm }
430225a68471Sdougm free_opt(optlist);
43036185db85Sdougm
43046185db85Sdougm /*
430525a68471Sdougm * We have a group and potentially legal additions
430625a68471Sdougm *
430725a68471Sdougm * Commit to configuration if not a dryrun
43086185db85Sdougm */
43096185db85Sdougm if (!dryrun && ret == SA_OK) {
431025a68471Sdougm if (change && worklist != NULL) {
431125a68471Sdougm /* properties changed, so update all shares */
431225a68471Sdougm (void) enable_all_groups(handle, worklist, 0, 0,
4313da6c28aaSamw protocol, B_TRUE);
431425a68471Sdougm }
43156185db85Sdougm }
43166185db85Sdougm if (worklist != NULL)
431725a68471Sdougm free_list(worklist);
43186185db85Sdougm return (ret);
43196185db85Sdougm }
43206185db85Sdougm
43216185db85Sdougm /*
43226185db85Sdougm * space_unset(groupname, optlist, protocol, sharepath, dryrun)
43236185db85Sdougm *
432425a68471Sdougm * Unset named optionset properties.
43256185db85Sdougm */
43266185db85Sdougm static int
space_unset(sa_handle_t handle,char * groupname,struct options * optlist,char * protocol,char * sharepath,int dryrun,char * sectype)4327549ec3ffSdougm space_unset(sa_handle_t handle, char *groupname, struct options *optlist,
4328da6c28aaSamw char *protocol, char *sharepath, int dryrun, char *sectype)
43296185db85Sdougm {
43306185db85Sdougm sa_group_t group;
43316185db85Sdougm int ret = SA_OK;
43326185db85Sdougm int change = 0;
43336185db85Sdougm struct list *worklist = NULL;
433425a68471Sdougm sa_share_t share = NULL;
43356185db85Sdougm
4336549ec3ffSdougm group = sa_get_group(handle, groupname);
433725a68471Sdougm if (group == NULL) {
433825a68471Sdougm (void) printf(gettext("Group \"%s\" not found\n"), groupname);
433925a68471Sdougm return (SA_NO_SUCH_GROUP);
434025a68471Sdougm }
434125a68471Sdougm if (sharepath != NULL) {
43426185db85Sdougm share = sa_get_share(group, sharepath);
43436185db85Sdougm if (share == NULL) {
434425a68471Sdougm (void) printf(gettext(
434525a68471Sdougm "Share does not exist in group %s\n"),
434625a68471Sdougm groupname, sharepath);
434725a68471Sdougm return (SA_NO_SUCH_PATH);
434825a68471Sdougm }
434925a68471Sdougm }
4350da6c28aaSamw ret = valid_unset_security(share != NULL ? share : group,
4351da6c28aaSamw optlist, protocol, sectype);
435225a68471Sdougm
435325a68471Sdougm if (ret == SA_OK && !dryrun) {
435425a68471Sdougm if (optlist != NULL) {
43556185db85Sdougm if (share != NULL) {
435625a68471Sdougm sa_security_t optionset;
435725a68471Sdougm sa_property_t prop;
435825a68471Sdougm change = remove_security(share,
435925a68471Sdougm sectype, optlist, protocol, &ret);
436025a68471Sdougm
436125a68471Sdougm /* If a share security is empty, remove it */
436225a68471Sdougm optionset = sa_get_security((sa_group_t)share,
436325a68471Sdougm sectype, protocol);
436425a68471Sdougm if (optionset != NULL) {
436525a68471Sdougm prop = sa_get_property(optionset,
436625a68471Sdougm NULL);
436725a68471Sdougm if (prop == NULL)
436825a68471Sdougm ret = sa_destroy_security(
436925a68471Sdougm optionset);
437025a68471Sdougm }
43716185db85Sdougm } else {
437225a68471Sdougm change = remove_security(group, sectype,
437325a68471Sdougm optlist, protocol, &ret);
43746185db85Sdougm }
437525a68471Sdougm } else {
43766185db85Sdougm sa_security_t security;
43776185db85Sdougm char *sec;
43786185db85Sdougm sec = sa_proto_space_alias(protocol, sectype);
43796185db85Sdougm security = sa_get_security(group, sec, protocol);
43806185db85Sdougm if (sec != NULL)
438125a68471Sdougm sa_free_attr_string(sec);
43826185db85Sdougm if (security != NULL) {
438325a68471Sdougm ret = sa_destroy_security(security);
438425a68471Sdougm if (ret == SA_OK)
438525a68471Sdougm change = 1;
43866185db85Sdougm } else {
438725a68471Sdougm ret = SA_NO_SUCH_PROP;
43886185db85Sdougm }
43896185db85Sdougm }
439025a68471Sdougm if (ret != SA_OK)
439125a68471Sdougm (void) printf(gettext("Could not unset property: %s\n"),
439225a68471Sdougm sa_errorstr(ret));
43936185db85Sdougm }
439425a68471Sdougm
439525a68471Sdougm if (ret == SA_OK && change)
4396da6c28aaSamw worklist = add_list(worklist, group, 0, protocol);
439725a68471Sdougm
43986185db85Sdougm free_opt(optlist);
43996185db85Sdougm /*
440025a68471Sdougm * We have a group and potentially legal additions
44016185db85Sdougm */
44026185db85Sdougm
440325a68471Sdougm /* Commit to configuration if not a dryrun */
44046185db85Sdougm if (!dryrun && ret == 0) {
44056185db85Sdougm /* properties changed, so update all shares */
440625a68471Sdougm if (change && worklist != NULL)
440725a68471Sdougm (void) enable_all_groups(handle, worklist, 0, 0,
4408da6c28aaSamw protocol, B_TRUE);
440925a68471Sdougm ret = sa_update_config(handle);
44106185db85Sdougm }
44116185db85Sdougm if (worklist != NULL)
441225a68471Sdougm free_list(worklist);
44136185db85Sdougm return (ret);
44146185db85Sdougm }
44156185db85Sdougm
44166185db85Sdougm /*
44176185db85Sdougm * sa_unset(flags, argc, argv)
44186185db85Sdougm *
441925a68471Sdougm * Implements the unset subcommand. Parsing done here and then basic
44206185db85Sdougm * or space versions of the real code are called.
44216185db85Sdougm */
44226185db85Sdougm
44236185db85Sdougm int
sa_unset(sa_handle_t handle,int flags,int argc,char * argv[])4424549ec3ffSdougm sa_unset(sa_handle_t handle, int flags, int argc, char *argv[])
44256185db85Sdougm {
44266185db85Sdougm char *groupname;
44276185db85Sdougm int verbose = 0;
44286185db85Sdougm int dryrun = 0;
44296185db85Sdougm int c;
44306185db85Sdougm char *protocol = NULL;
44316185db85Sdougm int ret = SA_OK;
44326185db85Sdougm struct options *optlist = NULL;
4433da6c28aaSamw char *rsrcname = NULL;
44346185db85Sdougm char *sharepath = NULL;
44356185db85Sdougm char *optset = NULL;
44366185db85Sdougm int auth;
44376185db85Sdougm
4438da6c28aaSamw while ((c = getopt(argc, argv, "?hvnP:p:r:s:S:")) != EOF) {
443925a68471Sdougm switch (c) {
444025a68471Sdougm case 'v':
444125a68471Sdougm verbose++;
444225a68471Sdougm break;
444325a68471Sdougm case 'n':
444425a68471Sdougm dryrun++;
444525a68471Sdougm break;
444625a68471Sdougm case 'P':
4447da6c28aaSamw if (protocol != NULL) {
4448da6c28aaSamw (void) printf(gettext(
4449da6c28aaSamw "Specifying multiple protocols "
4450da6c28aaSamw "not supported: %s\n"), protocol);
4451da6c28aaSamw return (SA_SYNTAX_ERR);
4452da6c28aaSamw }
445325a68471Sdougm protocol = optarg;
445425a68471Sdougm if (!sa_valid_protocol(protocol)) {
445525a68471Sdougm (void) printf(gettext(
445625a68471Sdougm "Invalid protocol specified: %s\n"),
445725a68471Sdougm protocol);
445825a68471Sdougm return (SA_INVALID_PROTOCOL);
445925a68471Sdougm }
446025a68471Sdougm break;
446125a68471Sdougm case 'p':
446225a68471Sdougm ret = add_opt(&optlist, optarg, 1);
446325a68471Sdougm switch (ret) {
446425a68471Sdougm case OPT_ADD_SYNTAX:
446525a68471Sdougm (void) printf(gettext("Property syntax error "
446625a68471Sdougm "for property %s\n"), optarg);
446725a68471Sdougm return (SA_SYNTAX_ERR);
446825a68471Sdougm
446925a68471Sdougm case OPT_ADD_PROPERTY:
447025a68471Sdougm (void) printf(gettext("Properties need to be "
447125a68471Sdougm "set with set command: %s\n"), optarg);
447225a68471Sdougm return (SA_SYNTAX_ERR);
447325a68471Sdougm
447425a68471Sdougm default:
447525a68471Sdougm break;
447625a68471Sdougm }
447725a68471Sdougm break;
4478da6c28aaSamw case 'r':
4479da6c28aaSamw /*
4480da6c28aaSamw * Unset properties on resource if applicable or on
4481da6c28aaSamw * share if resource for this protocol doesn't use
4482da6c28aaSamw * resources.
4483da6c28aaSamw */
4484da6c28aaSamw if (rsrcname != NULL) {
4485da6c28aaSamw (void) printf(gettext(
4486da6c28aaSamw "Unsetting multiple resource "
4487da6c28aaSamw "names not supported\n"));
4488da6c28aaSamw return (SA_SYNTAX_ERR);
4489da6c28aaSamw }
4490da6c28aaSamw rsrcname = optarg;
4491da6c28aaSamw break;
449225a68471Sdougm case 's':
4493da6c28aaSamw if (sharepath != NULL) {
4494da6c28aaSamw (void) printf(gettext(
4495da6c28aaSamw "Adding multiple shares not supported\n"));
4496da6c28aaSamw return (SA_SYNTAX_ERR);
4497da6c28aaSamw }
449825a68471Sdougm sharepath = optarg;
449925a68471Sdougm break;
450025a68471Sdougm case 'S':
4501da6c28aaSamw if (optset != NULL) {
4502da6c28aaSamw (void) printf(gettext(
4503da6c28aaSamw "Specifying multiple property "
4504da6c28aaSamw "spaces not supported: %s\n"), optset);
4505da6c28aaSamw return (SA_SYNTAX_ERR);
4506da6c28aaSamw }
450725a68471Sdougm optset = optarg;
450825a68471Sdougm break;
450925a68471Sdougm case 'h':
4510e7bab347Sdougm /* optopt on valid arg isn't defined */
4511e7bab347Sdougm optopt = c;
4512e7bab347Sdougm /*FALLTHROUGH*/
451325a68471Sdougm case '?':
4514e7bab347Sdougm default:
4515e7bab347Sdougm /*
4516e7bab347Sdougm * Since a bad option gets to here, sort it
4517e7bab347Sdougm * out and return a syntax error return value
4518e7bab347Sdougm * if necessary.
4519e7bab347Sdougm */
4520e7bab347Sdougm switch (optopt) {
4521e7bab347Sdougm default:
4522e7bab347Sdougm ret = SA_SYNTAX_ERR;
4523e7bab347Sdougm break;
4524e7bab347Sdougm case 'h':
4525e7bab347Sdougm case '?':
4526e7bab347Sdougm break;
4527e7bab347Sdougm }
452825a68471Sdougm (void) printf(gettext("usage: %s\n"),
452925a68471Sdougm sa_get_usage(USAGE_UNSET));
4530e7bab347Sdougm return (ret);
45316185db85Sdougm }
45326185db85Sdougm }
45336185db85Sdougm
45346185db85Sdougm if (optlist != NULL)
453525a68471Sdougm ret = chk_opt(optlist, optset != NULL, protocol);
45366185db85Sdougm
45376185db85Sdougm if (optind >= argc || (optlist == NULL && optset == NULL) ||
45386185db85Sdougm protocol == NULL) {
453925a68471Sdougm char *sep = "\t";
454025a68471Sdougm (void) printf(gettext("usage: %s\n"),
454125a68471Sdougm sa_get_usage(USAGE_UNSET));
454225a68471Sdougm if (optind >= argc) {
454325a68471Sdougm (void) printf(gettext("%sgroup must be specified"),
454425a68471Sdougm sep);
454525a68471Sdougm sep = ", ";
454625a68471Sdougm }
454725a68471Sdougm if (optlist == NULL) {
454825a68471Sdougm (void) printf(gettext("%sat least one property must "
454925a68471Sdougm "be specified"), sep);
455025a68471Sdougm sep = ", ";
455125a68471Sdougm }
455225a68471Sdougm if (protocol == NULL) {
455325a68471Sdougm (void) printf(gettext("%sprotocol must be specified"),
455425a68471Sdougm sep);
455525a68471Sdougm sep = ", ";
455625a68471Sdougm }
455725a68471Sdougm (void) printf("\n");
455825a68471Sdougm ret = SA_SYNTAX_ERR;
45596185db85Sdougm } else {
45606185db85Sdougm
45616185db85Sdougm /*
456225a68471Sdougm * If a group already exists, we can only add a new
45636185db85Sdougm * protocol to it and not create a new one or add the
45646185db85Sdougm * same protocol again.
45656185db85Sdougm */
45666185db85Sdougm
456725a68471Sdougm groupname = argv[optind];
456825a68471Sdougm auth = check_authorizations(groupname, flags);
456925a68471Sdougm if (optset == NULL)
457025a68471Sdougm ret = basic_unset(handle, groupname, optlist, protocol,
4571da6c28aaSamw sharepath, rsrcname, dryrun);
457225a68471Sdougm else
457325a68471Sdougm ret = space_unset(handle, groupname, optlist, protocol,
457425a68471Sdougm sharepath, dryrun, optset);
45756185db85Sdougm
457625a68471Sdougm if (dryrun && ret == SA_OK && !auth && verbose)
457725a68471Sdougm (void) printf(gettext("Command would fail: %s\n"),
457825a68471Sdougm sa_errorstr(SA_NO_PERMISSION));
45796185db85Sdougm }
45806185db85Sdougm return (ret);
45816185db85Sdougm }
45826185db85Sdougm
45836185db85Sdougm /*
45846185db85Sdougm * sa_enable_group(flags, argc, argv)
45856185db85Sdougm *
45866185db85Sdougm * Implements the enable subcommand
45876185db85Sdougm */
45886185db85Sdougm
45896185db85Sdougm int
sa_enable_group(sa_handle_t handle,int flags,int argc,char * argv[])4590549ec3ffSdougm sa_enable_group(sa_handle_t handle, int flags, int argc, char *argv[])
45916185db85Sdougm {
45926185db85Sdougm int verbose = 0;
45936185db85Sdougm int dryrun = 0;
45946185db85Sdougm int all = 0;
45956185db85Sdougm int c;
45966185db85Sdougm int ret = SA_OK;
45976185db85Sdougm char *protocol = NULL;
45986185db85Sdougm char *state;
45996185db85Sdougm struct list *worklist = NULL;
46006185db85Sdougm int auth = 1;
460125a68471Sdougm sa_group_t group;
46026185db85Sdougm
46036185db85Sdougm while ((c = getopt(argc, argv, "?havnP:")) != EOF) {
460425a68471Sdougm switch (c) {
460525a68471Sdougm case 'a':
460625a68471Sdougm all = 1;
460725a68471Sdougm break;
460825a68471Sdougm case 'n':
460925a68471Sdougm dryrun++;
461025a68471Sdougm break;
461125a68471Sdougm case 'P':
4612da6c28aaSamw if (protocol != NULL) {
4613da6c28aaSamw (void) printf(gettext(
4614da6c28aaSamw "Specifying multiple protocols "
4615da6c28aaSamw "not supported: %s\n"), protocol);
4616da6c28aaSamw return (SA_SYNTAX_ERR);
4617da6c28aaSamw }
461825a68471Sdougm protocol = optarg;
461925a68471Sdougm if (!sa_valid_protocol(protocol)) {
462025a68471Sdougm (void) printf(gettext(
462125a68471Sdougm "Invalid protocol specified: %s\n"),
46226185db85Sdougm protocol);
462325a68471Sdougm return (SA_INVALID_PROTOCOL);
462425a68471Sdougm }
462525a68471Sdougm break;
462625a68471Sdougm case 'v':
462725a68471Sdougm verbose++;
462825a68471Sdougm break;
462925a68471Sdougm case 'h':
4630e7bab347Sdougm /* optopt on valid arg isn't defined */
4631e7bab347Sdougm optopt = c;
4632e7bab347Sdougm /*FALLTHROUGH*/
463325a68471Sdougm case '?':
4634e7bab347Sdougm default:
4635e7bab347Sdougm /*
4636e7bab347Sdougm * Since a bad option gets to here, sort it
4637e7bab347Sdougm * out and return a syntax error return value
4638e7bab347Sdougm * if necessary.
4639e7bab347Sdougm */
4640e7bab347Sdougm switch (optopt) {
4641e7bab347Sdougm default:
4642e7bab347Sdougm ret = SA_SYNTAX_ERR;
4643e7bab347Sdougm break;
4644e7bab347Sdougm case 'h':
4645e7bab347Sdougm case '?':
4646e7bab347Sdougm (void) printf(gettext("usage: %s\n"),
4647e7bab347Sdougm sa_get_usage(USAGE_ENABLE));
4648e7bab347Sdougm return (ret);
4649e7bab347Sdougm }
46506185db85Sdougm }
46516185db85Sdougm }
46526185db85Sdougm
46536185db85Sdougm if (optind == argc && !all) {
465425a68471Sdougm (void) printf(gettext("usage: %s\n"),
465525a68471Sdougm sa_get_usage(USAGE_ENABLE));
465625a68471Sdougm (void) printf(gettext("\tmust specify group\n"));
465725a68471Sdougm return (SA_NO_SUCH_PATH);
465825a68471Sdougm }
465925a68471Sdougm if (!all) {
46606185db85Sdougm while (optind < argc) {
466125a68471Sdougm group = sa_get_group(handle, argv[optind]);
466225a68471Sdougm if (group != NULL) {
466325a68471Sdougm auth &= check_authorizations(argv[optind],
466425a68471Sdougm flags);
466525a68471Sdougm state = sa_get_group_attr(group, "state");
466625a68471Sdougm if (state != NULL &&
466725a68471Sdougm strcmp(state, "enabled") == 0) {
466825a68471Sdougm /* already enabled */
466925a68471Sdougm if (verbose)
467025a68471Sdougm (void) printf(gettext(
467125a68471Sdougm "Group \"%s\" is already "
467225a68471Sdougm "enabled\n"),
467325a68471Sdougm argv[optind]);
467425a68471Sdougm ret = SA_BUSY; /* already enabled */
467525a68471Sdougm } else {
467625a68471Sdougm worklist = add_list(worklist, group,
4677da6c28aaSamw 0, protocol);
467825a68471Sdougm if (verbose)
467925a68471Sdougm (void) printf(gettext(
468025a68471Sdougm "Enabling group \"%s\"\n"),
468125a68471Sdougm argv[optind]);
468225a68471Sdougm }
468325a68471Sdougm if (state != NULL)
468425a68471Sdougm sa_free_attr_string(state);
46856185db85Sdougm } else {
468625a68471Sdougm ret = SA_NO_SUCH_GROUP;
46876185db85Sdougm }
468825a68471Sdougm optind++;
46896185db85Sdougm }
469025a68471Sdougm } else {
469125a68471Sdougm for (group = sa_get_group(handle, NULL);
469225a68471Sdougm group != NULL;
46936185db85Sdougm group = sa_get_next_group(group)) {
4694da6c28aaSamw worklist = add_list(worklist, group, 0, protocol);
46956185db85Sdougm }
469625a68471Sdougm }
469725a68471Sdougm if (!dryrun && ret == SA_OK)
4698da6c28aaSamw ret = enable_all_groups(handle, worklist, 1, 0, NULL, B_FALSE);
469925a68471Sdougm
470025a68471Sdougm if (ret != SA_OK && ret != SA_BUSY)
47016185db85Sdougm (void) printf(gettext("Could not enable group: %s\n"),
470225a68471Sdougm sa_errorstr(ret));
470325a68471Sdougm if (ret == SA_BUSY)
47046185db85Sdougm ret = SA_OK;
470525a68471Sdougm
47066185db85Sdougm if (worklist != NULL)
470725a68471Sdougm free_list(worklist);
47086185db85Sdougm if (dryrun && ret == SA_OK && !auth && verbose) {
470925a68471Sdougm (void) printf(gettext("Command would fail: %s\n"),
471025a68471Sdougm sa_errorstr(SA_NO_PERMISSION));
47116185db85Sdougm }
47126185db85Sdougm return (ret);
47136185db85Sdougm }
47146185db85Sdougm
47156185db85Sdougm /*
4716da6c28aaSamw * disable_group(group, proto)
47176185db85Sdougm *
4718da6c28aaSamw * Disable all the shares in the specified group.. This is a helper
4719da6c28aaSamw * for disable_all_groups in order to simplify regular and subgroup
4720da6c28aaSamw * (zfs) disabling. Group has already been checked for non-NULL.
47216185db85Sdougm */
47226185db85Sdougm
47236185db85Sdougm static int
disable_group(sa_group_t group,char * proto)4724da6c28aaSamw disable_group(sa_group_t group, char *proto)
47256185db85Sdougm {
47266185db85Sdougm sa_share_t share;
47276185db85Sdougm int ret = SA_OK;
47286185db85Sdougm
4729da6c28aaSamw /*
4730da6c28aaSamw * If the protocol isn't enabled, skip it and treat as
4731da6c28aaSamw * successful.
4732da6c28aaSamw */
4733da6c28aaSamw if (!has_protocol(group, proto))
4734da6c28aaSamw return (ret);
4735da6c28aaSamw
47366185db85Sdougm for (share = sa_get_share(group, NULL);
47376185db85Sdougm share != NULL && ret == SA_OK;
47386185db85Sdougm share = sa_get_next_share(share)) {
4739da6c28aaSamw ret = sa_disable_share(share, proto);
474025a68471Sdougm if (ret == SA_NO_SUCH_PATH) {
474125a68471Sdougm /*
474225a68471Sdougm * this is OK since the path is gone. we can't
474325a68471Sdougm * re-share it anyway so no error.
474425a68471Sdougm */
474525a68471Sdougm ret = SA_OK;
474625a68471Sdougm }
47476185db85Sdougm }
47486185db85Sdougm return (ret);
47496185db85Sdougm }
47506185db85Sdougm
47516185db85Sdougm /*
47526185db85Sdougm * disable_all_groups(work, setstate)
47536185db85Sdougm *
47546185db85Sdougm * helper function that disables the shares in the list of groups
47556185db85Sdougm * provided. It optionally marks the group as disabled. Used by both
47566185db85Sdougm * enable and start subcommands.
47576185db85Sdougm */
47586185db85Sdougm
47596185db85Sdougm static int
disable_all_groups(sa_handle_t handle,struct list * work,int setstate)4760549ec3ffSdougm disable_all_groups(sa_handle_t handle, struct list *work, int setstate)
47616185db85Sdougm {
47626185db85Sdougm int ret = SA_OK;
47636185db85Sdougm sa_group_t subgroup, group;
47646185db85Sdougm
47656185db85Sdougm while (work != NULL && ret == SA_OK) {
476625a68471Sdougm group = (sa_group_t)work->item;
476725a68471Sdougm if (setstate)
476825a68471Sdougm ret = sa_set_group_attr(group, "state", "disabled");
476925a68471Sdougm if (ret == SA_OK) {
477025a68471Sdougm char *name;
477125a68471Sdougm name = sa_get_group_attr(group, "name");
477225a68471Sdougm if (name != NULL && strcmp(name, "zfs") == 0) {
477325a68471Sdougm /* need to get the sub-groups for stopping */
477425a68471Sdougm for (subgroup = sa_get_sub_group(group);
477525a68471Sdougm subgroup != NULL;
477625a68471Sdougm subgroup = sa_get_next_group(subgroup)) {
4777da6c28aaSamw ret = disable_group(subgroup,
4778da6c28aaSamw work->proto);
477925a68471Sdougm }
478025a68471Sdougm } else {
4781da6c28aaSamw ret = disable_group(group, work->proto);
478225a68471Sdougm }
4783fe1c642dSBill Krier if (name != NULL)
4784fe1c642dSBill Krier sa_free_attr_string(name);
478525a68471Sdougm /*
478625a68471Sdougm * We don't want to "disable" since it won't come
478725a68471Sdougm * up after a reboot. The SMF framework should do
478825a68471Sdougm * the right thing. On enable we do want to do
478925a68471Sdougm * something.
479025a68471Sdougm */
47916185db85Sdougm }
479225a68471Sdougm work = work->next;
47936185db85Sdougm }
47946185db85Sdougm if (ret == SA_OK)
479525a68471Sdougm ret = sa_update_config(handle);
47966185db85Sdougm return (ret);
47976185db85Sdougm }
47986185db85Sdougm
47996185db85Sdougm /*
48006185db85Sdougm * sa_disable_group(flags, argc, argv)
48016185db85Sdougm *
48026185db85Sdougm * Implements the disable subcommand
48036185db85Sdougm */
48046185db85Sdougm
48056185db85Sdougm int
sa_disable_group(sa_handle_t handle,int flags,int argc,char * argv[])4806549ec3ffSdougm sa_disable_group(sa_handle_t handle, int flags, int argc, char *argv[])
48076185db85Sdougm {
48086185db85Sdougm int verbose = 0;
48096185db85Sdougm int dryrun = 0;
48106185db85Sdougm int all = 0;
48116185db85Sdougm int c;
48126185db85Sdougm int ret = SA_OK;
4813da6c28aaSamw char *protocol = NULL;
48146185db85Sdougm char *state;
48156185db85Sdougm struct list *worklist = NULL;
481625a68471Sdougm sa_group_t group;
48176185db85Sdougm int auth = 1;
48186185db85Sdougm
48196185db85Sdougm while ((c = getopt(argc, argv, "?havn")) != EOF) {
482025a68471Sdougm switch (c) {
482125a68471Sdougm case 'a':
482225a68471Sdougm all = 1;
482325a68471Sdougm break;
482425a68471Sdougm case 'n':
482525a68471Sdougm dryrun++;
482625a68471Sdougm break;
482725a68471Sdougm case 'P':
4828da6c28aaSamw if (protocol != NULL) {
4829da6c28aaSamw (void) printf(gettext(
4830da6c28aaSamw "Specifying multiple protocols "
4831da6c28aaSamw "not supported: %s\n"), protocol);
4832da6c28aaSamw return (SA_SYNTAX_ERR);
4833da6c28aaSamw }
483425a68471Sdougm protocol = optarg;
483525a68471Sdougm if (!sa_valid_protocol(protocol)) {
483625a68471Sdougm (void) printf(gettext(
483725a68471Sdougm "Invalid protocol specified: %s\n"),
483825a68471Sdougm protocol);
483925a68471Sdougm return (SA_INVALID_PROTOCOL);
484025a68471Sdougm }
484125a68471Sdougm break;
484225a68471Sdougm case 'v':
484325a68471Sdougm verbose++;
484425a68471Sdougm break;
484525a68471Sdougm case 'h':
4846e7bab347Sdougm /* optopt on valid arg isn't defined */
4847e7bab347Sdougm optopt = c;
4848e7bab347Sdougm /*FALLTHROUGH*/
484925a68471Sdougm case '?':
4850e7bab347Sdougm default:
4851e7bab347Sdougm /*
4852e7bab347Sdougm * Since a bad option gets to here, sort it
4853e7bab347Sdougm * out and return a syntax error return value
4854e7bab347Sdougm * if necessary.
4855e7bab347Sdougm */
4856e7bab347Sdougm switch (optopt) {
4857e7bab347Sdougm default:
4858e7bab347Sdougm ret = SA_SYNTAX_ERR;
4859e7bab347Sdougm break;
4860e7bab347Sdougm case 'h':
4861e7bab347Sdougm case '?':
4862e7bab347Sdougm break;
4863e7bab347Sdougm }
486425a68471Sdougm (void) printf(gettext("usage: %s\n"),
486525a68471Sdougm sa_get_usage(USAGE_DISABLE));
4866e7bab347Sdougm return (ret);
48676185db85Sdougm }
48686185db85Sdougm }
48696185db85Sdougm
48706185db85Sdougm if (optind == argc && !all) {
48716185db85Sdougm (void) printf(gettext("usage: %s\n"),
487225a68471Sdougm sa_get_usage(USAGE_DISABLE));
48736185db85Sdougm (void) printf(gettext("\tmust specify group\n"));
487425a68471Sdougm return (SA_NO_SUCH_PATH);
487525a68471Sdougm }
487625a68471Sdougm if (!all) {
487725a68471Sdougm while (optind < argc) {
4878549ec3ffSdougm group = sa_get_group(handle, argv[optind]);
48796185db85Sdougm if (group != NULL) {
488025a68471Sdougm auth &= check_authorizations(argv[optind],
488125a68471Sdougm flags);
488225a68471Sdougm state = sa_get_group_attr(group, "state");
488325a68471Sdougm if (state == NULL ||
488425a68471Sdougm strcmp(state, "disabled") == 0) {
488525a68471Sdougm /* already disabled */
488625a68471Sdougm if (verbose)
488725a68471Sdougm (void) printf(gettext(
488825a68471Sdougm "Group \"%s\" is "
488925a68471Sdougm "already disabled\n"),
489025a68471Sdougm argv[optind]);
4891da6c28aaSamw ret = SA_BUSY; /* already disabled */
489225a68471Sdougm } else {
4893da6c28aaSamw worklist = add_list(worklist, group, 0,
4894da6c28aaSamw protocol);
489525a68471Sdougm if (verbose)
489625a68471Sdougm (void) printf(gettext(
489725a68471Sdougm "Disabling group "
489825a68471Sdougm "\"%s\"\n"), argv[optind]);
489925a68471Sdougm }
490025a68471Sdougm if (state != NULL)
490125a68471Sdougm sa_free_attr_string(state);
49026185db85Sdougm } else {
490325a68471Sdougm ret = SA_NO_SUCH_GROUP;
49046185db85Sdougm }
49056185db85Sdougm optind++;
49066185db85Sdougm }
490725a68471Sdougm } else {
490825a68471Sdougm for (group = sa_get_group(handle, NULL);
490925a68471Sdougm group != NULL;
491025a68471Sdougm group = sa_get_next_group(group))
4911da6c28aaSamw worklist = add_list(worklist, group, 0, protocol);
49126185db85Sdougm }
491325a68471Sdougm
491425a68471Sdougm if (ret == SA_OK && !dryrun)
491525a68471Sdougm ret = disable_all_groups(handle, worklist, 1);
491625a68471Sdougm if (ret != SA_OK && ret != SA_BUSY)
491725a68471Sdougm (void) printf(gettext("Could not disable group: %s\n"),
491825a68471Sdougm sa_errorstr(ret));
491925a68471Sdougm if (ret == SA_BUSY)
492025a68471Sdougm ret = SA_OK;
49216185db85Sdougm if (worklist != NULL)
492225a68471Sdougm free_list(worklist);
492325a68471Sdougm if (dryrun && ret == SA_OK && !auth && verbose)
492425a68471Sdougm (void) printf(gettext("Command would fail: %s\n"),
492525a68471Sdougm sa_errorstr(SA_NO_PERMISSION));
49266185db85Sdougm return (ret);
49276185db85Sdougm }
49286185db85Sdougm
49296185db85Sdougm /*
49306185db85Sdougm * sa_start_group(flags, argc, argv)
49316185db85Sdougm *
49326185db85Sdougm * Implements the start command.
49336185db85Sdougm * This is similar to enable except it doesn't change the state
49346185db85Sdougm * of the group(s) and only enables shares if the group is already
49356185db85Sdougm * enabled.
49366185db85Sdougm */
4937da6c28aaSamw
49386185db85Sdougm int
sa_start_group(sa_handle_t handle,int flags,int argc,char * argv[])4939549ec3ffSdougm sa_start_group(sa_handle_t handle, int flags, int argc, char *argv[])
49406185db85Sdougm {
49416185db85Sdougm int verbose = 0;
49426185db85Sdougm int all = 0;
49436185db85Sdougm int c;
49446185db85Sdougm int ret = SMF_EXIT_OK;
49456185db85Sdougm char *protocol = NULL;
49466185db85Sdougm char *state;
49476185db85Sdougm struct list *worklist = NULL;
494825a68471Sdougm sa_group_t group;
4949da6c28aaSamw #ifdef lint
4950da6c28aaSamw flags = flags;
4951da6c28aaSamw #endif
49526185db85Sdougm
49536185db85Sdougm while ((c = getopt(argc, argv, "?havP:")) != EOF) {
495425a68471Sdougm switch (c) {
495525a68471Sdougm case 'a':
495625a68471Sdougm all = 1;
495725a68471Sdougm break;
495825a68471Sdougm case 'P':
4959da6c28aaSamw if (protocol != NULL) {
4960da6c28aaSamw (void) printf(gettext(
4961da6c28aaSamw "Specifying multiple protocols "
4962da6c28aaSamw "not supported: %s\n"), protocol);
4963da6c28aaSamw return (SA_SYNTAX_ERR);
4964da6c28aaSamw }
496525a68471Sdougm protocol = optarg;
496625a68471Sdougm if (!sa_valid_protocol(protocol)) {
496725a68471Sdougm (void) printf(gettext(
496825a68471Sdougm "Invalid protocol specified: %s\n"),
49696185db85Sdougm protocol);
497025a68471Sdougm return (SA_INVALID_PROTOCOL);
497125a68471Sdougm }
497225a68471Sdougm break;
497325a68471Sdougm case 'v':
497425a68471Sdougm verbose++;
497525a68471Sdougm break;
497625a68471Sdougm case 'h':
4977e7bab347Sdougm /* optopt on valid arg isn't defined */
4978e7bab347Sdougm optopt = c;
4979e7bab347Sdougm /*FALLTHROUGH*/
498025a68471Sdougm case '?':
4981e7bab347Sdougm default:
4982e7bab347Sdougm /*
4983e7bab347Sdougm * Since a bad option gets to here, sort it
4984e7bab347Sdougm * out and return a syntax error return value
4985e7bab347Sdougm * if necessary.
4986e7bab347Sdougm */
4987e7bab347Sdougm ret = SA_OK;
4988e7bab347Sdougm switch (optopt) {
4989e7bab347Sdougm default:
4990e7bab347Sdougm ret = SA_SYNTAX_ERR;
4991e7bab347Sdougm break;
4992e7bab347Sdougm case 'h':
4993e7bab347Sdougm case '?':
4994e7bab347Sdougm break;
4995e7bab347Sdougm }
499625a68471Sdougm (void) printf(gettext("usage: %s\n"),
499725a68471Sdougm sa_get_usage(USAGE_START));
4998e7bab347Sdougm return (ret);
49996185db85Sdougm }
50006185db85Sdougm }
50016185db85Sdougm
50026185db85Sdougm if (optind == argc && !all) {
50036185db85Sdougm (void) printf(gettext("usage: %s\n"),
500425a68471Sdougm sa_get_usage(USAGE_START));
500525a68471Sdougm return (SMF_EXIT_ERR_FATAL);
500625a68471Sdougm }
50076185db85Sdougm
500825a68471Sdougm if (!all) {
500925a68471Sdougm while (optind < argc) {
5010549ec3ffSdougm group = sa_get_group(handle, argv[optind]);
50116185db85Sdougm if (group != NULL) {
501225a68471Sdougm state = sa_get_group_attr(group, "state");
501325a68471Sdougm if (state == NULL ||
501425a68471Sdougm strcmp(state, "enabled") == 0) {
5015da6c28aaSamw worklist = add_list(worklist, group, 0,
5016da6c28aaSamw protocol);
501725a68471Sdougm if (verbose)
501825a68471Sdougm (void) printf(gettext(
501925a68471Sdougm "Starting group \"%s\"\n"),
502025a68471Sdougm argv[optind]);
502125a68471Sdougm } else {
502225a68471Sdougm /*
502325a68471Sdougm * Determine if there are any
5024da6c28aaSamw * protocols. If there aren't any,
502525a68471Sdougm * then there isn't anything to do in
502625a68471Sdougm * any case so no error.
502725a68471Sdougm */
502825a68471Sdougm if (sa_get_optionset(group,
502925a68471Sdougm protocol) != NULL) {
503025a68471Sdougm ret = SMF_EXIT_OK;
503125a68471Sdougm }
50326185db85Sdougm }
503325a68471Sdougm if (state != NULL)
503425a68471Sdougm sa_free_attr_string(state);
50356185db85Sdougm }
50366185db85Sdougm optind++;
503725a68471Sdougm }
503825a68471Sdougm } else {
5039da6c28aaSamw for (group = sa_get_group(handle, NULL);
5040da6c28aaSamw group != NULL;
504125a68471Sdougm group = sa_get_next_group(group)) {
50426185db85Sdougm state = sa_get_group_attr(group, "state");
50436185db85Sdougm if (state == NULL || strcmp(state, "enabled") == 0)
5044da6c28aaSamw worklist = add_list(worklist, group, 0,
5045da6c28aaSamw protocol);
50466185db85Sdougm if (state != NULL)
504725a68471Sdougm sa_free_attr_string(state);
50486185db85Sdougm }
50496185db85Sdougm }
505025a68471Sdougm
5051da6c28aaSamw (void) enable_all_groups(handle, worklist, 0, 1, protocol, B_FALSE);
505225a68471Sdougm
50536185db85Sdougm if (worklist != NULL)
505425a68471Sdougm free_list(worklist);
50556185db85Sdougm return (ret);
50566185db85Sdougm }
50576185db85Sdougm
50586185db85Sdougm /*
50596185db85Sdougm * sa_stop_group(flags, argc, argv)
50606185db85Sdougm *
50616185db85Sdougm * Implements the stop command.
50626185db85Sdougm * This is similar to disable except it doesn't change the state
50636185db85Sdougm * of the group(s) and only disables shares if the group is already
50646185db85Sdougm * enabled.
50656185db85Sdougm */
50666185db85Sdougm int
sa_stop_group(sa_handle_t handle,int flags,int argc,char * argv[])5067549ec3ffSdougm sa_stop_group(sa_handle_t handle, int flags, int argc, char *argv[])
50686185db85Sdougm {
50696185db85Sdougm int verbose = 0;
50706185db85Sdougm int all = 0;
50716185db85Sdougm int c;
50726185db85Sdougm int ret = SMF_EXIT_OK;
50736185db85Sdougm char *protocol = NULL;
50746185db85Sdougm char *state;
50756185db85Sdougm struct list *worklist = NULL;
507625a68471Sdougm sa_group_t group;
5077da6c28aaSamw #ifdef lint
5078da6c28aaSamw flags = flags;
5079da6c28aaSamw #endif
50806185db85Sdougm
50816185db85Sdougm while ((c = getopt(argc, argv, "?havP:")) != EOF) {
508225a68471Sdougm switch (c) {
508325a68471Sdougm case 'a':
508425a68471Sdougm all = 1;
508525a68471Sdougm break;
508625a68471Sdougm case 'P':
5087da6c28aaSamw if (protocol != NULL) {
5088da6c28aaSamw (void) printf(gettext(
5089da6c28aaSamw "Specifying multiple protocols "
5090da6c28aaSamw "not supported: %s\n"), protocol);
5091da6c28aaSamw return (SA_SYNTAX_ERR);
5092da6c28aaSamw }
509325a68471Sdougm protocol = optarg;
509425a68471Sdougm if (!sa_valid_protocol(protocol)) {
509525a68471Sdougm (void) printf(gettext(
509625a68471Sdougm "Invalid protocol specified: %s\n"),
509725a68471Sdougm protocol);
509825a68471Sdougm return (SA_INVALID_PROTOCOL);
509925a68471Sdougm }
510025a68471Sdougm break;
510125a68471Sdougm case 'v':
510225a68471Sdougm verbose++;
510325a68471Sdougm break;
510425a68471Sdougm case 'h':
5105e7bab347Sdougm /* optopt on valid arg isn't defined */
5106e7bab347Sdougm optopt = c;
5107e7bab347Sdougm /*FALLTHROUGH*/
510825a68471Sdougm case '?':
5109e7bab347Sdougm default:
5110e7bab347Sdougm /*
5111e7bab347Sdougm * Since a bad option gets to here, sort it
5112e7bab347Sdougm * out and return a syntax error return value
5113e7bab347Sdougm * if necessary.
5114e7bab347Sdougm */
5115e7bab347Sdougm ret = SA_OK;
5116e7bab347Sdougm switch (optopt) {
5117e7bab347Sdougm default:
5118e7bab347Sdougm ret = SA_SYNTAX_ERR;
5119e7bab347Sdougm break;
5120e7bab347Sdougm case 'h':
5121e7bab347Sdougm case '?':
5122e7bab347Sdougm break;
5123e7bab347Sdougm }
512425a68471Sdougm (void) printf(gettext("usage: %s\n"),
512525a68471Sdougm sa_get_usage(USAGE_STOP));
5126e7bab347Sdougm return (ret);
51276185db85Sdougm }
51286185db85Sdougm }
51296185db85Sdougm
51306185db85Sdougm if (optind == argc && !all) {
513125a68471Sdougm (void) printf(gettext("usage: %s\n"),
513225a68471Sdougm sa_get_usage(USAGE_STOP));
513325a68471Sdougm return (SMF_EXIT_ERR_FATAL);
513425a68471Sdougm } else if (!all) {
513525a68471Sdougm while (optind < argc) {
5136549ec3ffSdougm group = sa_get_group(handle, argv[optind]);
51376185db85Sdougm if (group != NULL) {
513825a68471Sdougm state = sa_get_group_attr(group, "state");
513925a68471Sdougm if (state == NULL ||
514025a68471Sdougm strcmp(state, "enabled") == 0) {
5141da6c28aaSamw worklist = add_list(worklist, group, 0,
5142da6c28aaSamw protocol);
514325a68471Sdougm if (verbose)
514425a68471Sdougm (void) printf(gettext(
514525a68471Sdougm "Stopping group \"%s\"\n"),
514625a68471Sdougm argv[optind]);
514725a68471Sdougm } else {
514825a68471Sdougm ret = SMF_EXIT_OK;
514925a68471Sdougm }
515025a68471Sdougm if (state != NULL)
515125a68471Sdougm sa_free_attr_string(state);
51526185db85Sdougm }
51536185db85Sdougm optind++;
515425a68471Sdougm }
515525a68471Sdougm } else {
5156da6c28aaSamw for (group = sa_get_group(handle, NULL);
5157da6c28aaSamw group != NULL;
515825a68471Sdougm group = sa_get_next_group(group)) {
51596185db85Sdougm state = sa_get_group_attr(group, "state");
51606185db85Sdougm if (state == NULL || strcmp(state, "enabled") == 0)
5161da6c28aaSamw worklist = add_list(worklist, group, 0,
5162da6c28aaSamw protocol);
51636185db85Sdougm if (state != NULL)
516425a68471Sdougm sa_free_attr_string(state);
51656185db85Sdougm }
51666185db85Sdougm }
516725a68471Sdougm (void) disable_all_groups(handle, worklist, 0);
516825a68471Sdougm ret = sa_update_config(handle);
516925a68471Sdougm
51706185db85Sdougm if (worklist != NULL)
517125a68471Sdougm free_list(worklist);
51726185db85Sdougm return (ret);
51736185db85Sdougm }
51746185db85Sdougm
51756185db85Sdougm /*
51766185db85Sdougm * remove_all_options(share, proto)
51776185db85Sdougm *
51786185db85Sdougm * Removes all options on a share.
51796185db85Sdougm */
51806185db85Sdougm
51816185db85Sdougm static void
remove_all_options(sa_share_t share,char * proto)51826185db85Sdougm remove_all_options(sa_share_t share, char *proto)
51836185db85Sdougm {
51846185db85Sdougm sa_optionset_t optionset;
51856185db85Sdougm sa_security_t security;
51866185db85Sdougm sa_security_t prevsec = NULL;
51876185db85Sdougm
51886185db85Sdougm optionset = sa_get_optionset(share, proto);
51896185db85Sdougm if (optionset != NULL)
519025a68471Sdougm (void) sa_destroy_optionset(optionset);
51916185db85Sdougm for (security = sa_get_security(share, NULL, NULL);
51926185db85Sdougm security != NULL;
51936185db85Sdougm security = sa_get_next_security(security)) {
519425a68471Sdougm char *type;
51956185db85Sdougm /*
519625a68471Sdougm * We walk through the list. prevsec keeps the
51976185db85Sdougm * previous security so we can delete it without
51986185db85Sdougm * destroying the list.
51996185db85Sdougm */
520025a68471Sdougm if (prevsec != NULL) {
520125a68471Sdougm /* remove the previously seen security */
520225a68471Sdougm (void) sa_destroy_security(prevsec);
520325a68471Sdougm /* set to NULL so we don't try multiple times */
520425a68471Sdougm prevsec = NULL;
520525a68471Sdougm }
520625a68471Sdougm type = sa_get_security_attr(security, "type");
520725a68471Sdougm if (type != NULL) {
520825a68471Sdougm /*
520925a68471Sdougm * if the security matches the specified protocol, we
521025a68471Sdougm * want to remove it. prevsec holds it until either
521125a68471Sdougm * the next pass or we fall out of the loop.
521225a68471Sdougm */
521325a68471Sdougm if (strcmp(type, proto) == 0)
521425a68471Sdougm prevsec = security;
521525a68471Sdougm sa_free_attr_string(type);
521625a68471Sdougm }
52176185db85Sdougm }
52186185db85Sdougm /* in case there is one left */
52196185db85Sdougm if (prevsec != NULL)
522025a68471Sdougm (void) sa_destroy_security(prevsec);
52216185db85Sdougm }
52226185db85Sdougm
52236185db85Sdougm
52246185db85Sdougm /*
52256185db85Sdougm * for legacy support, we need to handle the old syntax. This is what
52266185db85Sdougm * we get if sharemgr is called with the name "share" rather than
52276185db85Sdougm * sharemgr.
52286185db85Sdougm */
52296185db85Sdougm
52306185db85Sdougm static int
format_legacy_path(char * buff,int buffsize,char * proto,char * cmd)52316185db85Sdougm format_legacy_path(char *buff, int buffsize, char *proto, char *cmd)
52326185db85Sdougm {
52336185db85Sdougm int err;
52346185db85Sdougm
52356185db85Sdougm err = snprintf(buff, buffsize, "/usr/lib/fs/%s/%s", proto, cmd);
52366185db85Sdougm if (err > buffsize)
523725a68471Sdougm return (-1);
52386185db85Sdougm return (0);
52396185db85Sdougm }
52406185db85Sdougm
52416185db85Sdougm
52426185db85Sdougm /*
52436185db85Sdougm * check_legacy_cmd(proto, cmd)
52446185db85Sdougm *
52456185db85Sdougm * Check to see if the cmd exists in /usr/lib/fs/<proto>/<cmd> and is
52466185db85Sdougm * executable.
52476185db85Sdougm */
52486185db85Sdougm
52496185db85Sdougm static int
check_legacy_cmd(char * path)52506185db85Sdougm check_legacy_cmd(char *path)
52516185db85Sdougm {
52526185db85Sdougm struct stat st;
52536185db85Sdougm int ret = 0;
52546185db85Sdougm
52556185db85Sdougm if (stat(path, &st) == 0) {
525625a68471Sdougm if (S_ISREG(st.st_mode) &&
525725a68471Sdougm st.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH))
525825a68471Sdougm ret = 1;
52596185db85Sdougm }
52606185db85Sdougm return (ret);
52616185db85Sdougm }
52626185db85Sdougm
52636185db85Sdougm /*
52646185db85Sdougm * run_legacy_command(proto, cmd, argv)
52656185db85Sdougm *
526625a68471Sdougm * We know the command exists, so attempt to execute it with all the
52676185db85Sdougm * arguments. This implements full legacy share support for those
52686185db85Sdougm * protocols that don't have plugin providers.
52696185db85Sdougm */
52706185db85Sdougm
52716185db85Sdougm static int
run_legacy_command(char * path,char * argv[])52726185db85Sdougm run_legacy_command(char *path, char *argv[])
52736185db85Sdougm {
52746185db85Sdougm int ret;
52756185db85Sdougm
52766185db85Sdougm ret = execv(path, argv);
52776185db85Sdougm if (ret < 0) {
527825a68471Sdougm switch (errno) {
527925a68471Sdougm case EACCES:
528025a68471Sdougm ret = SA_NO_PERMISSION;
528125a68471Sdougm break;
528225a68471Sdougm default:
528325a68471Sdougm ret = SA_SYSTEM_ERR;
528425a68471Sdougm break;
528525a68471Sdougm }
52866185db85Sdougm }
52876185db85Sdougm return (ret);
52886185db85Sdougm }
52896185db85Sdougm
52906185db85Sdougm /*
5291f345c0beSdougm * out_share(out, group, proto)
52926185db85Sdougm *
52936185db85Sdougm * Display the share information in the format that the "share"
52946185db85Sdougm * command has traditionally used.
52956185db85Sdougm */
52966185db85Sdougm
52976185db85Sdougm static void
out_share(FILE * out,sa_group_t group,char * proto)5298f345c0beSdougm out_share(FILE *out, sa_group_t group, char *proto)
52996185db85Sdougm {
53006185db85Sdougm sa_share_t share;
53016185db85Sdougm char resfmt[128];
5302da6c28aaSamw char *defprop;
5303da6c28aaSamw
5304da6c28aaSamw /*
5305da6c28aaSamw * The original share command defaulted to displaying NFS
5306da6c28aaSamw * shares or allowed a protocol to be specified. We want to
5307da6c28aaSamw * skip those shares that are not the specified protocol.
5308da6c28aaSamw */
5309da6c28aaSamw if (proto != NULL && sa_get_optionset(group, proto) == NULL)
5310da6c28aaSamw return;
5311da6c28aaSamw
5312da6c28aaSamw if (proto == NULL)
5313da6c28aaSamw proto = "nfs";
5314da6c28aaSamw
5315da6c28aaSamw /*
5316da6c28aaSamw * get the default property string. NFS uses "rw" but
5317da6c28aaSamw * everything else will use "".
5318da6c28aaSamw */
5319da6c28aaSamw if (proto != NULL && strcmp(proto, "nfs") != 0)
5320da6c28aaSamw defprop = "\"\"";
5321da6c28aaSamw else
5322da6c28aaSamw defprop = "rw";
53236185db85Sdougm
532425a68471Sdougm for (share = sa_get_share(group, NULL);
532525a68471Sdougm share != NULL;
532625a68471Sdougm share = sa_get_next_share(share)) {
532725a68471Sdougm char *path;
532825a68471Sdougm char *type;
532925a68471Sdougm char *resource;
533025a68471Sdougm char *description;
533125a68471Sdougm char *groupname;
533225a68471Sdougm char *sharedstate;
533325a68471Sdougm int shared = 1;
533425a68471Sdougm char *soptions;
5335da6c28aaSamw char shareopts[MAXNAMLEN];
533625a68471Sdougm
533725a68471Sdougm sharedstate = sa_get_share_attr(share, "shared");
533825a68471Sdougm path = sa_get_share_attr(share, "path");
533925a68471Sdougm type = sa_get_share_attr(share, "type");
5340da6c28aaSamw resource = get_resource(share);
534125a68471Sdougm groupname = sa_get_group_attr(group, "name");
534225a68471Sdougm
534325a68471Sdougm if (groupname != NULL && strcmp(groupname, "default") == 0) {
534425a68471Sdougm sa_free_attr_string(groupname);
534525a68471Sdougm groupname = NULL;
534625a68471Sdougm }
534725a68471Sdougm description = sa_get_share_description(share);
534825a68471Sdougm
5349da6c28aaSamw /*
5350da6c28aaSamw * Want the sharetab version if it exists, defaulting
5351da6c28aaSamw * to NFS if no protocol specified.
5352da6c28aaSamw */
5353da6c28aaSamw (void) snprintf(shareopts, MAXNAMLEN, "shareopts-%s", proto);
5354da6c28aaSamw soptions = sa_get_share_attr(share, shareopts);
535525a68471Sdougm
535625a68471Sdougm if (sharedstate == NULL)
535725a68471Sdougm shared = 0;
535825a68471Sdougm
535925a68471Sdougm if (soptions == NULL)
536025a68471Sdougm soptions = sa_proto_legacy_format(proto, share, 1);
536125a68471Sdougm
536225a68471Sdougm if (shared) {
536325a68471Sdougm /* only active shares go here */
536425a68471Sdougm (void) snprintf(resfmt, sizeof (resfmt), "%s%s%s",
536525a68471Sdougm resource != NULL ? resource : "-",
536625a68471Sdougm groupname != NULL ? "@" : "",
536725a68471Sdougm groupname != NULL ? groupname : "");
536825a68471Sdougm (void) fprintf(out, "%-14.14s %s %s \"%s\" \n",
5369fe1c642dSBill Krier resfmt, (path != NULL) ? path : "",
537025a68471Sdougm (soptions != NULL && strlen(soptions) > 0) ?
5371da6c28aaSamw soptions : defprop,
537225a68471Sdougm (description != NULL) ? description : "");
537325a68471Sdougm }
537425a68471Sdougm
537525a68471Sdougm if (path != NULL)
537625a68471Sdougm sa_free_attr_string(path);
537725a68471Sdougm if (type != NULL)
537825a68471Sdougm sa_free_attr_string(type);
537925a68471Sdougm if (resource != NULL)
538025a68471Sdougm sa_free_attr_string(resource);
538125a68471Sdougm if (groupname != NULL)
538225a68471Sdougm sa_free_attr_string(groupname);
538325a68471Sdougm if (description != NULL)
538425a68471Sdougm sa_free_share_description(description);
538525a68471Sdougm if (sharedstate != NULL)
538625a68471Sdougm sa_free_attr_string(sharedstate);
538725a68471Sdougm if (soptions != NULL)
538825a68471Sdougm sa_format_free(soptions);
53896185db85Sdougm }
53906185db85Sdougm }
53916185db85Sdougm
53926185db85Sdougm /*
53936185db85Sdougm * output_legacy_file(out, proto)
53946185db85Sdougm *
53956185db85Sdougm * Walk all of the groups for the specified protocol and call
53966185db85Sdougm * out_share() to format and write in the format displayed by the
53976185db85Sdougm * "share" command with no arguments.
53986185db85Sdougm */
53996185db85Sdougm
54006185db85Sdougm static void
output_legacy_file(FILE * out,char * proto,sa_handle_t handle)5401549ec3ffSdougm output_legacy_file(FILE *out, char *proto, sa_handle_t handle)
54026185db85Sdougm {
54036185db85Sdougm sa_group_t group;
54046185db85Sdougm
5405da6c28aaSamw for (group = sa_get_group(handle, NULL);
5406da6c28aaSamw group != NULL;
540725a68471Sdougm group = sa_get_next_group(group)) {
540825a68471Sdougm char *zfs;
54096185db85Sdougm
54106185db85Sdougm /*
5411da6c28aaSamw * Go through all the groups and ZFS
5412da6c28aaSamw * sub-groups. out_share() will format the shares in
5413da6c28aaSamw * the group appropriately.
54146185db85Sdougm */
54156185db85Sdougm
541625a68471Sdougm zfs = sa_get_group_attr(group, "zfs");
541725a68471Sdougm if (zfs != NULL) {
541825a68471Sdougm sa_group_t zgroup;
541925a68471Sdougm sa_free_attr_string(zfs);
542025a68471Sdougm for (zgroup = sa_get_sub_group(group);
542125a68471Sdougm zgroup != NULL;
542225a68471Sdougm zgroup = sa_get_next_group(zgroup)) {
542325a68471Sdougm
542425a68471Sdougm /* got a group, so display it */
542525a68471Sdougm out_share(out, zgroup, proto);
542625a68471Sdougm }
542725a68471Sdougm } else {
542825a68471Sdougm out_share(out, group, proto);
54296185db85Sdougm }
54306185db85Sdougm }
54316185db85Sdougm }
54326185db85Sdougm
54336185db85Sdougm int
sa_legacy_share(sa_handle_t handle,int flags,int argc,char * argv[])5434549ec3ffSdougm sa_legacy_share(sa_handle_t handle, int flags, int argc, char *argv[])
54356185db85Sdougm {
54366185db85Sdougm char *protocol = "nfs";
54376185db85Sdougm char *options = NULL;
54386185db85Sdougm char *description = NULL;
54396185db85Sdougm char *groupname = NULL;
54406185db85Sdougm char *sharepath = NULL;
54416185db85Sdougm char *resource = NULL;
54426185db85Sdougm char *groupstatus = NULL;
54436185db85Sdougm int persist = SA_SHARE_TRANSIENT;
54446185db85Sdougm int argsused = 0;
54456185db85Sdougm int c;
54466185db85Sdougm int ret = SA_OK;
54476185db85Sdougm int zfs = 0;
54486185db85Sdougm int true_legacy = 0;
54496185db85Sdougm int curtype = SA_SHARE_TRANSIENT;
54506185db85Sdougm char cmd[MAXPATHLEN];
545125a68471Sdougm sa_group_t group = NULL;
5452da6c28aaSamw sa_resource_t rsrc = NULL;
545325a68471Sdougm sa_share_t share;
545425a68471Sdougm char dir[MAXPATHLEN];
5455da6c28aaSamw uint64_t features;
5456da6c28aaSamw #ifdef lint
5457da6c28aaSamw flags = flags;
5458da6c28aaSamw #endif
54596185db85Sdougm
54606185db85Sdougm while ((c = getopt(argc, argv, "?hF:d:o:p")) != EOF) {
546125a68471Sdougm switch (c) {
546225a68471Sdougm case 'd':
546325a68471Sdougm description = optarg;
546425a68471Sdougm argsused++;
546525a68471Sdougm break;
546625a68471Sdougm case 'F':
546725a68471Sdougm protocol = optarg;
546825a68471Sdougm if (!sa_valid_protocol(protocol)) {
546925a68471Sdougm if (format_legacy_path(cmd, MAXPATHLEN,
547025a68471Sdougm protocol, "share") == 0 &&
547125a68471Sdougm check_legacy_cmd(cmd)) {
547225a68471Sdougm true_legacy++;
547325a68471Sdougm } else {
547425a68471Sdougm (void) fprintf(stderr, gettext(
547525a68471Sdougm "Invalid protocol specified: "
547625a68471Sdougm "%s\n"), protocol);
547725a68471Sdougm return (SA_INVALID_PROTOCOL);
547825a68471Sdougm }
547925a68471Sdougm }
548025a68471Sdougm break;
548125a68471Sdougm case 'o':
548225a68471Sdougm options = optarg;
548325a68471Sdougm argsused++;
548425a68471Sdougm break;
548525a68471Sdougm case 'p':
548625a68471Sdougm persist = SA_SHARE_PERMANENT;
548725a68471Sdougm argsused++;
548825a68471Sdougm break;
548925a68471Sdougm case 'h':
5490e7bab347Sdougm /* optopt on valid arg isn't defined */
5491e7bab347Sdougm optopt = c;
5492e7bab347Sdougm /*FALLTHROUGH*/
549325a68471Sdougm case '?':
549425a68471Sdougm default:
5495e7bab347Sdougm /*
5496e7bab347Sdougm * Since a bad option gets to here, sort it
5497e7bab347Sdougm * out and return a syntax error return value
5498e7bab347Sdougm * if necessary.
5499e7bab347Sdougm */
5500e7bab347Sdougm switch (optopt) {
5501e7bab347Sdougm default:
5502e7bab347Sdougm ret = SA_LEGACY_ERR;
5503e7bab347Sdougm break;
5504e7bab347Sdougm case 'h':
5505e7bab347Sdougm case '?':
5506e7bab347Sdougm break;
5507e7bab347Sdougm }
550825a68471Sdougm (void) fprintf(stderr, gettext("usage: %s\n"),
550925a68471Sdougm sa_get_usage(USAGE_SHARE));
5510e7bab347Sdougm return (ret);
55116185db85Sdougm }
55126185db85Sdougm }
55136185db85Sdougm
551425a68471Sdougm /* Have the info so construct what is needed */
55156185db85Sdougm if (!argsused && optind == argc) {
551625a68471Sdougm /* display current info in share format */
5517da6c28aaSamw (void) output_legacy_file(stdout, protocol, handle);
551825a68471Sdougm return (ret);
551925a68471Sdougm }
55206185db85Sdougm
552125a68471Sdougm /* We are modifying the configuration */
552225a68471Sdougm if (optind == argc) {
55236185db85Sdougm (void) fprintf(stderr, gettext("usage: %s\n"),
552425a68471Sdougm sa_get_usage(USAGE_SHARE));
55256185db85Sdougm return (SA_LEGACY_ERR);
552625a68471Sdougm }
552725a68471Sdougm if (true_legacy) {
552825a68471Sdougm /* If still using legacy share/unshare, exec it */
55296185db85Sdougm ret = run_legacy_command(cmd, argv);
55306185db85Sdougm return (ret);
553125a68471Sdougm }
55326185db85Sdougm
553325a68471Sdougm sharepath = argv[optind++];
553425a68471Sdougm if (optind < argc) {
55356185db85Sdougm resource = argv[optind];
55366185db85Sdougm groupname = strchr(resource, '@');
55376185db85Sdougm if (groupname != NULL)
553825a68471Sdougm *groupname++ = '\0';
553925a68471Sdougm }
554025a68471Sdougm if (realpath(sharepath, dir) == NULL)
55416185db85Sdougm ret = SA_BAD_PATH;
554225a68471Sdougm else
55436185db85Sdougm sharepath = dir;
554425a68471Sdougm if (ret == SA_OK)
5545549ec3ffSdougm share = sa_find_share(handle, sharepath);
554625a68471Sdougm else
55476185db85Sdougm share = NULL;
554825a68471Sdougm
5549da6c28aaSamw features = sa_proto_get_featureset(protocol);
5550da6c28aaSamw
555125a68471Sdougm if (groupname != NULL) {
555225a68471Sdougm ret = SA_NOT_ALLOWED;
555325a68471Sdougm } else if (ret == SA_OK) {
5554da6c28aaSamw char *legacygroup;
55556185db85Sdougm /*
555625a68471Sdougm * The legacy group is always present and zfs groups
55576185db85Sdougm * come and go. zfs shares may be in sub-groups and
55586185db85Sdougm * the zfs share will already be in that group so it
5559da6c28aaSamw * isn't an error. If the protocol is "smb", the group
5560da6c28aaSamw * "smb" is used when "default" would otherwise be
5561da6c28aaSamw * used. "default" is NFS only and "smb" is SMB only.
55626185db85Sdougm */
5563da6c28aaSamw if (strcmp(protocol, "smb") == 0)
5564da6c28aaSamw legacygroup = "smb";
5565da6c28aaSamw else
5566da6c28aaSamw legacygroup = "default";
5567da6c28aaSamw
55686185db85Sdougm /*
556925a68471Sdougm * If the share exists (not NULL), then make sure it
557025a68471Sdougm * is one we want to handle by getting the parent
557125a68471Sdougm * group.
55726185db85Sdougm */
5573da6c28aaSamw if (share != NULL) {
557425a68471Sdougm group = sa_get_parent_group(share);
5575da6c28aaSamw } else {
557625a68471Sdougm group = sa_get_group(handle, legacygroup);
5577da6c28aaSamw if (group == NULL && strcmp(legacygroup, "smb") == 0) {
5578da6c28aaSamw /*
5579da6c28aaSamw * This group may not exist, so create
5580da6c28aaSamw * as necessary. It only contains the
5581da6c28aaSamw * "smb" protocol.
5582da6c28aaSamw */
5583da6c28aaSamw group = sa_create_group(handle, legacygroup,
5584da6c28aaSamw &ret);
5585da6c28aaSamw if (group != NULL)
5586da6c28aaSamw (void) sa_create_optionset(group,
5587da6c28aaSamw protocol);
5588da6c28aaSamw }
5589da6c28aaSamw }
559025a68471Sdougm
5591da6c28aaSamw if (group == NULL) {
5592da6c28aaSamw ret = SA_SYSTEM_ERR;
5593da6c28aaSamw goto err;
5594da6c28aaSamw }
5595da6c28aaSamw
5596da6c28aaSamw groupstatus = group_status(group);
5597da6c28aaSamw if (share == NULL) {
5598da6c28aaSamw share = sa_add_share(group, sharepath,
5599da6c28aaSamw persist, &ret);
5600da6c28aaSamw if (share == NULL &&
5601da6c28aaSamw ret == SA_DUPLICATE_NAME) {
560225a68471Sdougm /*
5603da6c28aaSamw * Could be a ZFS path being started
560425a68471Sdougm */
5605da6c28aaSamw if (sa_zfs_is_shared(handle,
5606da6c28aaSamw sharepath)) {
5607da6c28aaSamw ret = SA_OK;
5608da6c28aaSamw group = sa_get_group(handle,
5609da6c28aaSamw "zfs");
5610da6c28aaSamw if (group == NULL) {
5611da6c28aaSamw /*
5612da6c28aaSamw * This shouldn't
5613da6c28aaSamw * happen.
5614da6c28aaSamw */
5615da6c28aaSamw ret = SA_CONFIG_ERR;
5616da6c28aaSamw } else {
5617da6c28aaSamw share = sa_add_share(
5618da6c28aaSamw group, sharepath,
5619da6c28aaSamw persist, &ret);
5620da6c28aaSamw }
562125a68471Sdougm }
5622da6c28aaSamw }
5623da6c28aaSamw } else {
5624da6c28aaSamw char *type;
5625da6c28aaSamw /*
5626da6c28aaSamw * May want to change persist state, but the
5627da6c28aaSamw * important thing is to change options. We
5628da6c28aaSamw * need to change them regardless of the
5629da6c28aaSamw * source.
5630da6c28aaSamw */
5631da6c28aaSamw
5632da6c28aaSamw if (sa_zfs_is_shared(handle, sharepath)) {
5633da6c28aaSamw zfs = 1;
5634da6c28aaSamw }
5635da6c28aaSamw remove_all_options(share, protocol);
5636da6c28aaSamw type = sa_get_share_attr(share, "type");
5637da6c28aaSamw if (type != NULL &&
5638da6c28aaSamw strcmp(type, "transient") != 0) {
5639da6c28aaSamw curtype = SA_SHARE_PERMANENT;
5640da6c28aaSamw }
5641da6c28aaSamw if (type != NULL)
5642da6c28aaSamw sa_free_attr_string(type);
5643da6c28aaSamw if (curtype != persist) {
5644da6c28aaSamw (void) sa_set_share_attr(share, "type",
5645da6c28aaSamw persist == SA_SHARE_PERMANENT ?
5646da6c28aaSamw "persist" : "transient");
5647da6c28aaSamw }
5648da6c28aaSamw }
5649da6c28aaSamw
5650da6c28aaSamw /*
5651da6c28aaSamw * If there is a resource name, we may
5652da6c28aaSamw * actually care about it if this is share for
5653da6c28aaSamw * a protocol that uses resource level sharing
5654da6c28aaSamw * (SMB). We need to find the resource and, if
5655da6c28aaSamw * it exists, make sure it belongs to the
5656da6c28aaSamw * current share. If it doesn't exist, attempt
5657da6c28aaSamw * to create it.
5658da6c28aaSamw */
5659da6c28aaSamw
5660da6c28aaSamw if (ret == SA_OK && resource != NULL) {
5661da6c28aaSamw rsrc = sa_find_resource(handle, resource);
5662da6c28aaSamw if (rsrc != NULL) {
5663da6c28aaSamw if (share != sa_get_resource_parent(rsrc))
5664da6c28aaSamw ret = SA_DUPLICATE_NAME;
5665bc54f855SJohn Levon } else {
5666bc54f855SJohn Levon rsrc = sa_add_resource(share, resource,
5667bc54f855SJohn Levon persist, &ret);
56686185db85Sdougm }
5669bc54f855SJohn Levon if (features & SA_FEATURE_RESOURCE)
5670bc54f855SJohn Levon share = rsrc;
5671bc54f855SJohn Levon }
5672da6c28aaSamw
5673bc54f855SJohn Levon /* Have a group to hold this share path */
5674bc54f855SJohn Levon if (ret == SA_OK && options != NULL &&
5675bc54f855SJohn Levon strlen(options) > 0) {
5676bc54f855SJohn Levon ret = sa_parse_legacy_options(share,
5677bc54f855SJohn Levon options,
5678bc54f855SJohn Levon protocol);
5679bc54f855SJohn Levon }
5680bc54f855SJohn Levon if (!zfs) {
5681bc54f855SJohn Levon /*
5682bc54f855SJohn Levon * ZFS shares never have a description
5683bc54f855SJohn Levon * and we can't store the values so
5684bc54f855SJohn Levon * don't try.
5685bc54f855SJohn Levon */
5686bc54f855SJohn Levon if (ret == SA_OK && description != NULL)
5687bc54f855SJohn Levon ret = sa_set_share_description(share,
5688bc54f855SJohn Levon description);
5689bc54f855SJohn Levon }
5690bc54f855SJohn Levon if (ret == SA_OK &&
5691bc54f855SJohn Levon strcmp(groupstatus, "enabled") == 0) {
5692bc54f855SJohn Levon if (rsrc != share)
5693bc54f855SJohn Levon ret = sa_enable_share(share, protocol);
5694bc54f855SJohn Levon else
5695bc54f855SJohn Levon ret = sa_enable_resource(rsrc,
569625a68471Sdougm protocol);
5697da6c28aaSamw if (ret == SA_OK &&
5698bc54f855SJohn Levon persist == SA_SHARE_PERMANENT) {
5699bc54f855SJohn Levon (void) sa_update_legacy(share,
5700bc54f855SJohn Levon protocol);
570125a68471Sdougm }
5702bc54f855SJohn Levon if (ret == SA_OK)
5703bc54f855SJohn Levon ret = sa_update_config(handle);
5704bc54f855SJohn Levon }
57056185db85Sdougm }
5706da6c28aaSamw err:
57076185db85Sdougm if (ret != SA_OK) {
570825a68471Sdougm (void) fprintf(stderr, gettext("Could not share: %s: %s\n"),
570925a68471Sdougm sharepath, sa_errorstr(ret));
571025a68471Sdougm ret = SA_LEGACY_ERR;
57116185db85Sdougm }
57126185db85Sdougm return (ret);
57136185db85Sdougm }
57146185db85Sdougm
57156185db85Sdougm /*
57166185db85Sdougm * sa_legacy_unshare(flags, argc, argv)
57176185db85Sdougm *
57186185db85Sdougm * Implements the original unshare command.
57196185db85Sdougm */
57206185db85Sdougm int
sa_legacy_unshare(sa_handle_t handle,int flags,int argc,char * argv[])5721549ec3ffSdougm sa_legacy_unshare(sa_handle_t handle, int flags, int argc, char *argv[])
57226185db85Sdougm {
57236185db85Sdougm char *protocol = "nfs"; /* for now */
57246185db85Sdougm char *options = NULL;
57256185db85Sdougm char *sharepath = NULL;
57266185db85Sdougm int persist = SA_SHARE_TRANSIENT;
57276185db85Sdougm int argsused = 0;
57286185db85Sdougm int c;
57296185db85Sdougm int ret = SA_OK;
57306185db85Sdougm int true_legacy = 0;
5731da6c28aaSamw uint64_t features = 0;
5732da6c28aaSamw sa_resource_t resource = NULL;
57336185db85Sdougm char cmd[MAXPATHLEN];
5734da6c28aaSamw #ifdef lint
5735da6c28aaSamw flags = flags;
5736da6c28aaSamw options = options;
5737da6c28aaSamw #endif
57386185db85Sdougm
57396185db85Sdougm while ((c = getopt(argc, argv, "?hF:o:p")) != EOF) {
574025a68471Sdougm switch (c) {
574125a68471Sdougm case 'F':
574225a68471Sdougm protocol = optarg;
574325a68471Sdougm if (!sa_valid_protocol(protocol)) {
574425a68471Sdougm if (format_legacy_path(cmd, MAXPATHLEN,
574525a68471Sdougm protocol, "unshare") == 0 &&
574625a68471Sdougm check_legacy_cmd(cmd)) {
574725a68471Sdougm true_legacy++;
574825a68471Sdougm } else {
574925a68471Sdougm (void) printf(gettext(
575025a68471Sdougm "Invalid file system name\n"));
575125a68471Sdougm return (SA_INVALID_PROTOCOL);
575225a68471Sdougm }
575325a68471Sdougm }
575425a68471Sdougm break;
575525a68471Sdougm case 'o':
575625a68471Sdougm options = optarg;
575725a68471Sdougm argsused++;
575825a68471Sdougm break;
575925a68471Sdougm case 'p':
576025a68471Sdougm persist = SA_SHARE_PERMANENT;
576125a68471Sdougm argsused++;
576225a68471Sdougm break;
5763e7bab347Sdougm case 'h':
5764e7bab347Sdougm /* optopt on valid arg isn't defined */
5765e7bab347Sdougm optopt = c;
5766e7bab347Sdougm /*FALLTHROUGH*/
5767e7bab347Sdougm case '?':
576825a68471Sdougm default:
5769e7bab347Sdougm /*
5770e7bab347Sdougm * Since a bad option gets to here, sort it
5771e7bab347Sdougm * out and return a syntax error return value
5772e7bab347Sdougm * if necessary.
5773e7bab347Sdougm */
5774e7bab347Sdougm switch (optopt) {
5775e7bab347Sdougm default:
5776e7bab347Sdougm ret = SA_LEGACY_ERR;
5777e7bab347Sdougm break;
5778e7bab347Sdougm case 'h':
5779e7bab347Sdougm case '?':
5780e7bab347Sdougm break;
5781e7bab347Sdougm }
578225a68471Sdougm (void) printf(gettext("usage: %s\n"),
578325a68471Sdougm sa_get_usage(USAGE_UNSHARE));
5784e7bab347Sdougm return (ret);
57856185db85Sdougm }
57866185db85Sdougm }
57876185db85Sdougm
578825a68471Sdougm /* Have the info so construct what is needed */
578925a68471Sdougm if (optind == argc || (optind + 1) < argc || options != NULL) {
579025a68471Sdougm ret = SA_SYNTAX_ERR;
57916185db85Sdougm } else {
579225a68471Sdougm sa_share_t share;
579325a68471Sdougm char dir[MAXPATHLEN];
579425a68471Sdougm if (true_legacy) {
579525a68471Sdougm /* if still using legacy share/unshare, exec it */
579625a68471Sdougm ret = run_legacy_command(cmd, argv);
579725a68471Sdougm return (ret);
579825a68471Sdougm }
5799a99982a7Sdougm /*
5800a99982a7Sdougm * Find the path in the internal configuration. If it
5801a99982a7Sdougm * isn't found, attempt to resolve the path via
5802a99982a7Sdougm * realpath() and try again.
5803a99982a7Sdougm */
580425a68471Sdougm sharepath = argv[optind++];
580525a68471Sdougm share = sa_find_share(handle, sharepath);
580625a68471Sdougm if (share == NULL) {
580725a68471Sdougm if (realpath(sharepath, dir) == NULL) {
580825a68471Sdougm ret = SA_NO_SUCH_PATH;
580925a68471Sdougm } else {
581025a68471Sdougm share = sa_find_share(handle, dir);
581125a68471Sdougm }
58126185db85Sdougm }
5813da6c28aaSamw if (share == NULL) {
5814da6c28aaSamw /* Could be a resource name so check that next */
5815da6c28aaSamw features = sa_proto_get_featureset(protocol);
5816da6c28aaSamw resource = sa_find_resource(handle, sharepath);
5817da6c28aaSamw if (resource != NULL) {
5818da6c28aaSamw share = sa_get_resource_parent(resource);
5819da6c28aaSamw if (features & SA_FEATURE_RESOURCE)
5820da6c28aaSamw (void) sa_disable_resource(resource,
5821da6c28aaSamw protocol);
5822da6c28aaSamw if (persist == SA_SHARE_PERMANENT) {
5823da6c28aaSamw ret = sa_remove_resource(resource);
5824da6c28aaSamw if (ret == SA_OK)
5825da6c28aaSamw ret = sa_update_config(handle);
5826da6c28aaSamw }
5827da6c28aaSamw /*
5828da6c28aaSamw * If we still have a resource on the
5829da6c28aaSamw * share, we don't disable the share
5830da6c28aaSamw * itself. IF there aren't anymore, we
5831da6c28aaSamw * need to remove the share. The
5832da6c28aaSamw * removal will be done in the next
5833da6c28aaSamw * section if appropriate.
5834da6c28aaSamw */
5835da6c28aaSamw resource = sa_get_share_resource(share, NULL);
5836da6c28aaSamw if (resource != NULL)
5837da6c28aaSamw share = NULL;
5838da6c28aaSamw } else if (ret == SA_OK) {
5839da6c28aaSamw /* Didn't find path and no resource */
5840da6c28aaSamw ret = SA_BAD_PATH;
5841da6c28aaSamw }
5842da6c28aaSamw }
5843da6c28aaSamw if (share != NULL && resource == NULL) {
584425a68471Sdougm ret = sa_disable_share(share, protocol);
584525a68471Sdougm /*
584625a68471Sdougm * Errors are ok and removal should still occur. The
584725a68471Sdougm * legacy unshare is more forgiving of errors than the
584825a68471Sdougm * remove-share subcommand which may need the force
584925a68471Sdougm * flag set for some error conditions. That is, the
585025a68471Sdougm * "unshare" command will always unshare if it can
585125a68471Sdougm * while "remove-share" might require the force option.
585225a68471Sdougm */
585325a68471Sdougm if (persist == SA_SHARE_PERMANENT) {
585425a68471Sdougm ret = sa_remove_share(share);
585525a68471Sdougm if (ret == SA_OK)
585625a68471Sdougm ret = sa_update_config(handle);
585725a68471Sdougm }
5858da6c28aaSamw } else if (ret == SA_OK && share == NULL && resource == NULL) {
5859da6c28aaSamw /*
5860da6c28aaSamw * If both share and resource are NULL, then
5861da6c28aaSamw * share not found. If one or the other was
5862da6c28aaSamw * found or there was an earlier error, we
5863da6c28aaSamw * assume it was handled earlier.
5864da6c28aaSamw */
586525a68471Sdougm ret = SA_NOT_SHARED;
5866a99982a7Sdougm }
58676185db85Sdougm }
58686185db85Sdougm switch (ret) {
58696185db85Sdougm default:
587025a68471Sdougm (void) printf("%s: %s\n", sharepath, sa_errorstr(ret));
587125a68471Sdougm ret = SA_LEGACY_ERR;
587225a68471Sdougm break;
58736185db85Sdougm case SA_SYNTAX_ERR:
587425a68471Sdougm (void) printf(gettext("usage: %s\n"),
587525a68471Sdougm sa_get_usage(USAGE_UNSHARE));
587625a68471Sdougm break;
58776185db85Sdougm case SA_OK:
587825a68471Sdougm break;
58796185db85Sdougm }
58806185db85Sdougm return (ret);
58816185db85Sdougm }
58826185db85Sdougm
58836185db85Sdougm /*
588425a68471Sdougm * Common commands that implement the sub-commands used by all
5885da6c28aaSamw * protocols. The entries are found via the lookup command
58866185db85Sdougm */
58876185db85Sdougm
58886185db85Sdougm static sa_command_t commands[] = {
58896185db85Sdougm {"add-share", 0, sa_addshare, USAGE_ADD_SHARE, SVC_SET},
58906185db85Sdougm {"create", 0, sa_create, USAGE_CREATE, SVC_SET|SVC_ACTION},
58916185db85Sdougm {"delete", 0, sa_delete, USAGE_DELETE, SVC_SET|SVC_ACTION},
58926185db85Sdougm {"disable", 0, sa_disable_group, USAGE_DISABLE, SVC_SET|SVC_ACTION},
58936185db85Sdougm {"enable", 0, sa_enable_group, USAGE_ENABLE, SVC_SET|SVC_ACTION},
58946185db85Sdougm {"list", 0, sa_list, USAGE_LIST},
58956185db85Sdougm {"move-share", 0, sa_moveshare, USAGE_MOVE_SHARE, SVC_SET},
58966185db85Sdougm {"remove-share", 0, sa_removeshare, USAGE_REMOVE_SHARE, SVC_SET},
58976185db85Sdougm {"set", 0, sa_set, USAGE_SET, SVC_SET},
58986185db85Sdougm {"set-share", 0, sa_set_share, USAGE_SET_SHARE, SVC_SET},
58996185db85Sdougm {"show", 0, sa_show, USAGE_SHOW},
59006185db85Sdougm {"share", 0, sa_legacy_share, USAGE_SHARE, SVC_SET|SVC_ACTION},
59016185db85Sdougm {"start", CMD_NODISPLAY, sa_start_group, USAGE_START,
5902da6c28aaSamw SVC_SET|SVC_ACTION},
59036185db85Sdougm {"stop", CMD_NODISPLAY, sa_stop_group, USAGE_STOP, SVC_SET|SVC_ACTION},
59046185db85Sdougm {"unset", 0, sa_unset, USAGE_UNSET, SVC_SET},
59056185db85Sdougm {"unshare", 0, sa_legacy_unshare, USAGE_UNSHARE, SVC_SET|SVC_ACTION},
59061a80a7c5SToomas Soome {NULL, 0, NULL, 0}
59076185db85Sdougm };
59086185db85Sdougm
59096185db85Sdougm static char *
sa_get_usage(sa_usage_t index)59106185db85Sdougm sa_get_usage(sa_usage_t index)
59116185db85Sdougm {
59126185db85Sdougm char *ret = NULL;
59136185db85Sdougm switch (index) {
59146185db85Sdougm case USAGE_ADD_SHARE:
591525a68471Sdougm ret = gettext("add-share [-nth] [-r resource-name] "
591625a68471Sdougm "[-d \"description text\"] -s sharepath group");
591725a68471Sdougm break;
59186185db85Sdougm case USAGE_CREATE:
591925a68471Sdougm ret = gettext(
592025a68471Sdougm "create [-nvh] [-P proto [-p property=value]] group");
592125a68471Sdougm break;
59226185db85Sdougm case USAGE_DELETE:
592325a68471Sdougm ret = gettext("delete [-nvh] [-P proto] [-f] group");
592425a68471Sdougm break;
59256185db85Sdougm case USAGE_DISABLE:
592625a68471Sdougm ret = gettext("disable [-nvh] {-a | group ...}");
592725a68471Sdougm break;
59286185db85Sdougm case USAGE_ENABLE:
592925a68471Sdougm ret = gettext("enable [-nvh] {-a | group ...}");
593025a68471Sdougm break;
59316185db85Sdougm case USAGE_LIST:
593225a68471Sdougm ret = gettext("list [-vh] [-P proto]");
593325a68471Sdougm break;
59346185db85Sdougm case USAGE_MOVE_SHARE:
593525a68471Sdougm ret = gettext(
593625a68471Sdougm "move-share [-nvh] -s sharepath destination-group");
593725a68471Sdougm break;
59386185db85Sdougm case USAGE_REMOVE_SHARE:
5939da6c28aaSamw ret = gettext(
5940da6c28aaSamw "remove-share [-fnvh] {-s sharepath | -r resource} "
5941da6c28aaSamw "group");
594225a68471Sdougm break;
59436185db85Sdougm case USAGE_SET:
594425a68471Sdougm ret = gettext("set [-nvh] -P proto [-S optspace] "
5945da6c28aaSamw "[-p property=value]* [-s sharepath] [-r resource]] "
5946da6c28aaSamw "group");
594725a68471Sdougm break;
59486185db85Sdougm case USAGE_SET_SECURITY:
594925a68471Sdougm ret = gettext("set-security [-nvh] -P proto -S security-type "
595025a68471Sdougm "[-p property=value]* group");
595125a68471Sdougm break;
59526185db85Sdougm case USAGE_SET_SHARE:
595325a68471Sdougm ret = gettext("set-share [-nh] [-r resource] "
595425a68471Sdougm "[-d \"description text\"] -s sharepath group");
595525a68471Sdougm break;
59566185db85Sdougm case USAGE_SHOW:
595725a68471Sdougm ret = gettext("show [-pvxh] [-P proto] [group ...]");
595825a68471Sdougm break;
59596185db85Sdougm case USAGE_SHARE:
596025a68471Sdougm ret = gettext("share [-F fstype] [-p] [-o optionlist]"
596125a68471Sdougm "[-d description] [pathname [resourcename]]");
596225a68471Sdougm break;
59636185db85Sdougm case USAGE_START:
596425a68471Sdougm ret = gettext("start [-vh] [-P proto] {-a | group ...}");
596525a68471Sdougm break;
59666185db85Sdougm case USAGE_STOP:
596725a68471Sdougm ret = gettext("stop [-vh] [-P proto] {-a | group ...}");
596825a68471Sdougm break;
59696185db85Sdougm case USAGE_UNSET:
597025a68471Sdougm ret = gettext("unset [-nvh] -P proto [-S optspace] "
597125a68471Sdougm "[-p property]* group");
597225a68471Sdougm break;
59736185db85Sdougm case USAGE_UNSET_SECURITY:
5974da6c28aaSamw ret = gettext("unset-security [-nvh] -P proto "
5975da6c28aaSamw "-S security-type [-p property]* group");
597625a68471Sdougm break;
59776185db85Sdougm case USAGE_UNSHARE:
597825a68471Sdougm ret = gettext(
5979da6c28aaSamw "unshare [-F fstype] [-p] [-o optionlist] sharepath");
598025a68471Sdougm break;
59816185db85Sdougm }
59826185db85Sdougm return (ret);
59836185db85Sdougm }
59846185db85Sdougm
59856185db85Sdougm /*
59866185db85Sdougm * sa_lookup(cmd, proto)
59876185db85Sdougm *
59886185db85Sdougm * Lookup the sub-command. proto isn't currently used, but it may
59896185db85Sdougm * eventually provide a way to provide protocol specific sub-commands.
59906185db85Sdougm */
59916185db85Sdougm sa_command_t *
sa_lookup(char * cmd,char * proto)59926185db85Sdougm sa_lookup(char *cmd, char *proto)
59936185db85Sdougm {
59946185db85Sdougm int i;
59956185db85Sdougm size_t len;
5996da6c28aaSamw #ifdef lint
5997da6c28aaSamw proto = proto;
5998da6c28aaSamw #endif
59996185db85Sdougm
60006185db85Sdougm len = strlen(cmd);
60016185db85Sdougm for (i = 0; commands[i].cmdname != NULL; i++) {
600225a68471Sdougm if (strncmp(cmd, commands[i].cmdname, len) == 0)
600325a68471Sdougm return (&commands[i]);
60046185db85Sdougm }
60056185db85Sdougm return (NULL);
60066185db85Sdougm }
60076185db85Sdougm
60086185db85Sdougm void
sub_command_help(char * proto)60096185db85Sdougm sub_command_help(char *proto)
60106185db85Sdougm {
60116185db85Sdougm int i;
6012da6c28aaSamw #ifdef lint
6013da6c28aaSamw proto = proto;
6014da6c28aaSamw #endif
60156185db85Sdougm
60166185db85Sdougm (void) printf(gettext("\tsub-commands:\n"));
60176185db85Sdougm for (i = 0; commands[i].cmdname != NULL; i++) {
601825a68471Sdougm if (!(commands[i].flags & (CMD_ALIAS|CMD_NODISPLAY)))
601925a68471Sdougm (void) printf("\t%s\n",
602025a68471Sdougm sa_get_usage((sa_usage_t)commands[i].cmdidx));
60216185db85Sdougm }
60226185db85Sdougm }
6023