1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25 /*
26 * Copyright 2012 Nexenta Systems, Inc. All rights reserved.
27 */
28
29 #include <stdio.h>
30 #include <libzfs.h>
31 #include <string.h>
32 #include <strings.h>
33 #include <errno.h>
34 #include <libshare.h>
35 #include "libshare_impl.h"
36 #include <libintl.h>
37 #include <sys/mnttab.h>
38 #include <sys/mntent.h>
39
40 extern sa_share_t _sa_add_share(sa_group_t, char *, int, int *, uint64_t);
41 extern sa_group_t _sa_create_zfs_group(sa_group_t, char *);
42 extern char *sa_fstype(char *);
43 extern void set_node_attr(void *, char *, char *);
44 extern int sa_is_share(void *);
45 extern void sa_update_sharetab_ts(sa_handle_t);
46
47 /*
48 * File system specific code for ZFS. The original code was stolen
49 * from the "zfs" command and modified to better suit this library's
50 * usage.
51 */
52
53 typedef struct get_all_cbdata {
54 zfs_handle_t **cb_handles;
55 size_t cb_alloc;
56 size_t cb_used;
57 uint_t cb_types;
58 } get_all_cbdata_t;
59
60 /*
61 * sa_zfs_init(impl_handle)
62 *
63 * Initialize an access handle into libzfs. The handle needs to stay
64 * around until sa_zfs_fini() in order to maintain the cache of
65 * mounts.
66 */
67
68 int
69 sa_zfs_init(sa_handle_impl_t impl_handle)
70 {
71 impl_handle->zfs_libhandle = libzfs_init();
72 if (impl_handle->zfs_libhandle != NULL) {
73 libzfs_print_on_error(impl_handle->zfs_libhandle, B_TRUE);
74 return (B_TRUE);
75 }
76 return (B_FALSE);
77 }
78
79 /*
80 * sa_zfs_fini(impl_handle)
81 *
82 * cleanup data structures and the libzfs handle used for accessing
83 * zfs file share info.
84 */
85
86 void
87 sa_zfs_fini(sa_handle_impl_t impl_handle)
88 {
89 if (impl_handle->zfs_libhandle != NULL) {
90 if (impl_handle->zfs_list != NULL) {
91 zfs_handle_t **zhp = impl_handle->zfs_list;
92 size_t i;
93
94 /*
95 * Contents of zfs_list need to be freed so we
96 * don't lose ZFS handles.
97 */
98 for (i = 0; i < impl_handle->zfs_list_count; i++) {
99 zfs_close(zhp[i]);
100 }
101 free(impl_handle->zfs_list);
102 impl_handle->zfs_list = NULL;
103 impl_handle->zfs_list_count = 0;
104 }
105
106 libzfs_fini(impl_handle->zfs_libhandle);
107 impl_handle->zfs_libhandle = NULL;
108 }
109 }
110
111 /*
112 * get_one_filesystem(zfs_handle_t, data)
113 *
114 * an iterator function called while iterating through the ZFS
115 * root. It accumulates into an array of file system handles that can
116 * be used to derive info about those file systems.
117 *
118 * Note that as this function is called, we close all zhp handles that
119 * are not going to be places into the cp_handles list. We don't want
120 * to close the ones we are keeping, but all others would be leaked if
121 * not closed here.
122 */
123
124 static int
125 get_one_filesystem(zfs_handle_t *zhp, void *data)
126 {
127 get_all_cbdata_t *cbp = data;
128 zfs_type_t type = zfs_get_type(zhp);
129
130 /*
131 * Interate over any nested datasets.
132 */
133 if (type == ZFS_TYPE_FILESYSTEM &&
134 zfs_iter_filesystems(zhp, get_one_filesystem, data) != 0) {
135 zfs_close(zhp);
136 return (1);
137 }
138
139 /*
140 * Skip any datasets whose type does not match.
141 */
142 if ((type & cbp->cb_types) == 0) {
143 zfs_close(zhp);
144 return (0);
145 }
146
147 if (cbp->cb_alloc == cbp->cb_used) {
148 zfs_handle_t **handles;
149
150 if (cbp->cb_alloc == 0)
151 cbp->cb_alloc = 64;
152 else
153 cbp->cb_alloc *= 2;
154
155 handles = (zfs_handle_t **)calloc(1,
156 cbp->cb_alloc * sizeof (void *));
157
158 if (handles == NULL) {
159 zfs_close(zhp);
160 return (0);
161 }
162 if (cbp->cb_handles) {
163 bcopy(cbp->cb_handles, handles,
164 cbp->cb_used * sizeof (void *));
165 free(cbp->cb_handles);
166 }
167
168 cbp->cb_handles = handles;
169 }
170
171 cbp->cb_handles[cbp->cb_used++] = zhp;
172
173 return (0);
174 }
175
176 /*
177 * get_all_filesystems(zfs_handle_t ***fslist, size_t *count)
178 *
179 * iterate through all ZFS file systems starting at the root. Returns
180 * a count and an array of handle pointers. Allocating is only done
181 * once. The caller does not need to free since it will be done at
182 * sa_zfs_fini() time.
183 */
184
185 static void
186 get_all_filesystems(sa_handle_impl_t impl_handle,
187 zfs_handle_t ***fslist, size_t *count)
188 {
189 get_all_cbdata_t cb = { 0 };
190 cb.cb_types = ZFS_TYPE_FILESYSTEM;
191
192 if (impl_handle->zfs_list != NULL) {
193 *fslist = impl_handle->zfs_list;
194 *count = impl_handle->zfs_list_count;
195 return;
196 }
197
198 (void) zfs_iter_root(impl_handle->zfs_libhandle,
199 get_one_filesystem, &cb);
200
201 impl_handle->zfs_list = *fslist = cb.cb_handles;
202 impl_handle->zfs_list_count = *count = cb.cb_used;
203 }
204
205 /*
206 * mountpoint_compare(a, b)
207 *
208 * compares the mountpoint on two zfs file systems handles.
209 * returns values following strcmp() model.
210 */
211
212 static int
213 mountpoint_compare(const void *a, const void *b)
214 {
215 zfs_handle_t **za = (zfs_handle_t **)a;
216 zfs_handle_t **zb = (zfs_handle_t **)b;
217 char mounta[MAXPATHLEN];
218 char mountb[MAXPATHLEN];
219
220 verify(zfs_prop_get(*za, ZFS_PROP_MOUNTPOINT, mounta,
221 sizeof (mounta), NULL, NULL, 0, B_FALSE) == 0);
222 verify(zfs_prop_get(*zb, ZFS_PROP_MOUNTPOINT, mountb,
223 sizeof (mountb), NULL, NULL, 0, B_FALSE) == 0);
224
225 return (strcmp(mounta, mountb));
226 }
227
228 /*
229 * return legacy mountpoint. Caller provides space for mountpoint and
230 * dataset.
231 */
232 int
233 get_legacy_mountpoint(char *path, char *dataset, size_t dlen,
234 char *mountpoint, size_t mlen)
235 {
236 FILE *fp;
237 struct mnttab entry;
238
239 if ((fp = fopen(MNTTAB, "r")) == NULL) {
240 return (1);
241 }
242
243 while (getmntent(fp, &entry) == 0) {
244
245 if (entry.mnt_fstype == NULL ||
246 strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
247 continue;
248
249 if (strcmp(entry.mnt_mountp, path) == 0) {
250 if (mlen > 0)
251 (void) strlcpy(mountpoint, entry.mnt_mountp,
252 mlen);
253 if (dlen > 0)
254 (void) strlcpy(dataset, entry.mnt_special,
255 dlen);
256 break;
257 }
258 }
259 (void) fclose(fp);
260 return (1);
261 }
262
263 /*
264 * get_zfs_dataset(impl_handle, path)
265 *
266 * get the name of the ZFS dataset the path is equivalent to. The
267 * dataset name is used for get/set of ZFS properties since libzfs
268 * requires a dataset to do a zfs_open().
269 */
270
271 static char *
272 get_zfs_dataset(sa_handle_impl_t impl_handle, char *path,
273 boolean_t search_mnttab)
274 {
275 size_t i, count = 0;
276 char *dataset = NULL;
277 zfs_handle_t **zlist;
278 char mountpoint[ZFS_MAXPROPLEN];
279 char canmount[ZFS_MAXPROPLEN];
280
281 get_all_filesystems(impl_handle, &zlist, &count);
282 qsort(zlist, count, sizeof (void *), mountpoint_compare);
283 for (i = 0; i < count; i++) {
284 /* must have a mountpoint */
285 if (zfs_prop_get(zlist[i], ZFS_PROP_MOUNTPOINT, mountpoint,
286 sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) {
287 /* no mountpoint */
288 continue;
289 }
290
291 /* mountpoint must be a path */
292 if (strcmp(mountpoint, ZFS_MOUNTPOINT_NONE) == 0 ||
293 strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0) {
294 /*
295 * Search mmttab for mountpoint and get dataset.
296 */
297
298 if (search_mnttab == B_TRUE &&
299 get_legacy_mountpoint(path, mountpoint,
300 sizeof (mountpoint), NULL, 0) == 0) {
301 dataset = mountpoint;
302 break;
303 }
304 continue;
305 }
306
307 /* canmount must be set */
308 canmount[0] = '\0';
309 if (zfs_prop_get(zlist[i], ZFS_PROP_CANMOUNT, canmount,
310 sizeof (canmount), NULL, NULL, 0, B_FALSE) != 0 ||
311 strcmp(canmount, "off") == 0)
312 continue;
313
314 /*
315 * have a mountable handle but want to skip those marked none
316 * and legacy
317 */
318 if (strcmp(mountpoint, path) == 0) {
319 dataset = (char *)zfs_get_name(zlist[i]);
320 break;
321 }
322
323 }
324
325 if (dataset != NULL)
326 dataset = strdup(dataset);
327
328 return (dataset);
329 }
330
331 /*
332 * get_zfs_property(dataset, property)
333 *
334 * Get the file system property specified from the ZFS dataset.
335 */
336
337 static char *
338 get_zfs_property(char *dataset, zfs_prop_t property)
339 {
340 zfs_handle_t *handle = NULL;
341 char shareopts[ZFS_MAXPROPLEN];
342 libzfs_handle_t *libhandle;
343
344 libhandle = libzfs_init();
345 if (libhandle != NULL) {
346 handle = zfs_open(libhandle, dataset, ZFS_TYPE_FILESYSTEM);
347 if (handle != NULL) {
348 if (zfs_prop_get(handle, property, shareopts,
349 sizeof (shareopts), NULL, NULL, 0,
350 B_FALSE) == 0) {
351 zfs_close(handle);
352 libzfs_fini(libhandle);
353 return (strdup(shareopts));
354 }
355 zfs_close(handle);
356 }
357 libzfs_fini(libhandle);
358 }
359 return (NULL);
360 }
361
362 /*
363 * sa_zfs_is_shared(handle, path)
364 *
365 * Check to see if the ZFS path provided has the sharenfs option set
366 * or not.
367 */
368
369 int
370 sa_zfs_is_shared(sa_handle_t sahandle, char *path)
371 {
372 int ret = 0;
373 char *dataset;
374 zfs_handle_t *handle = NULL;
375 char shareopts[ZFS_MAXPROPLEN];
376 libzfs_handle_t *libhandle;
377
378 dataset = get_zfs_dataset((sa_handle_t)sahandle, path, B_FALSE);
379 if (dataset != NULL) {
380 libhandle = libzfs_init();
381 if (libhandle != NULL) {
382 handle = zfs_open(libhandle, dataset,
383 ZFS_TYPE_FILESYSTEM);
384 if (handle != NULL) {
385 if (zfs_prop_get(handle, ZFS_PROP_SHARENFS,
386 shareopts, sizeof (shareopts), NULL, NULL,
387 0, B_FALSE) == 0 &&
388 strcmp(shareopts, "off") != 0) {
389 ret = 1; /* it is shared */
390 }
391 zfs_close(handle);
392 }
393 libzfs_fini(libhandle);
394 }
395 free(dataset);
396 }
397 return (ret);
398 }
399
400 /*
401 * find_or_create_group(handle, groupname, proto, *err)
402 *
403 * While walking the ZFS tree, we need to add shares to a defined
404 * group. If the group doesn't exist, create it first, making sure it
405 * is marked as a ZFS group.
406 *
407 * Note that all ZFS shares are in a subgroup of the top level group
408 * called "zfs".
409 */
410
411 static sa_group_t
412 find_or_create_group(sa_handle_t handle, char *groupname, char *proto, int *err)
413 {
414 sa_group_t group;
415 sa_optionset_t optionset;
416 int ret = SA_OK;
417
418 /*
419 * we check to see if the "zfs" group exists. Since this
420 * should be the top level group, we don't want the
421 * parent. This is to make sure the zfs group has been created
422 * and to created if it hasn't been.
423 */
424 group = sa_get_group(handle, groupname);
425 if (group == NULL) {
426 group = sa_create_group(handle, groupname, &ret);
427
428 /* make sure this is flagged as a ZFS group */
429 if (group != NULL)
430 ret = sa_set_group_attr(group, "zfs", "true");
431 }
432 if (group != NULL) {
433 if (proto != NULL) {
434 optionset = sa_get_optionset(group, proto);
435 if (optionset == NULL)
436 optionset = sa_create_optionset(group, proto);
437 }
438 }
439 if (err != NULL)
440 *err = ret;
441 return (group);
442 }
443
444 /*
445 * find_or_create_zfs_subgroup(groupname, optstring, *err)
446 *
447 * ZFS shares will be in a subgroup of the "zfs" master group. This
448 * function looks to see if the groupname exists and returns it if it
449 * does or else creates a new one with the specified name and returns
450 * that. The "zfs" group will exist before we get here, but we make
451 * sure just in case.
452 *
453 * err must be a valid pointer.
454 */
455
456 static sa_group_t
457 find_or_create_zfs_subgroup(sa_handle_t handle, char *groupname, char *proto,
458 char *optstring, int *err)
459 {
460 sa_group_t group = NULL;
461 sa_group_t zfs;
462 char *name;
463 char *options;
464
465 /* start with the top-level "zfs" group */
466 zfs = sa_get_group(handle, "zfs");
467 *err = SA_OK;
468 if (zfs != NULL) {
469 for (group = sa_get_sub_group(zfs); group != NULL;
470 group = sa_get_next_group(group)) {
471 name = sa_get_group_attr(group, "name");
472 if (name != NULL && strcmp(name, groupname) == 0) {
473 /* have the group so break out of here */
474 sa_free_attr_string(name);
475 break;
476 }
477 if (name != NULL)
478 sa_free_attr_string(name);
479 }
480
481 if (group == NULL) {
482 /*
483 * Need to create the sub-group since it doesn't exist
484 */
485 group = _sa_create_zfs_group(zfs, groupname);
486 if (group == NULL) {
487 *err = SA_NO_MEMORY;
488 return (NULL);
489 }
490 set_node_attr(group, "zfs", "true");
491 }
492 if (strcmp(optstring, "on") == 0)
493 optstring = "rw";
494 options = strdup(optstring);
495 if (options != NULL) {
496 *err = sa_parse_legacy_options(group, options,
497 proto);
498 /* If no optionset, add one. */
499 if (sa_get_optionset(group, proto) == NULL)
500 (void) sa_create_optionset(group, proto);
501
502 /*
503 * Do not forget to update an optionset of
504 * the parent group so that it contains
505 * all protocols its subgroups have.
506 */
507 if (sa_get_optionset(zfs, proto) == NULL)
508 (void) sa_create_optionset(zfs, proto);
509
510 free(options);
511 } else {
512 *err = SA_NO_MEMORY;
513 }
514 }
515 return (group);
516 }
517
518 /*
519 * zfs_construct_resource(share, name, base, dataset)
520 *
521 * Add a resource to the share using name as a template. If name ==
522 * NULL, then construct a name based on the dataset value.
523 * name.
524 */
525 static void
526 zfs_construct_resource(sa_share_t share, char *dataset)
527 {
528 char buff[SA_MAX_RESOURCE_NAME + 1];
529 int ret = SA_OK;
530
531 (void) snprintf(buff, SA_MAX_RESOURCE_NAME, "%s", dataset);
532 sa_fix_resource_name(buff);
533 (void) sa_add_resource(share, buff, SA_SHARE_TRANSIENT, &ret);
534 }
535
536 /*
537 * zfs_inherited(handle, source, sourcestr)
538 *
539 * handle case of inherited share{nfs,smb}. Pulled out of sa_get_zfs_shares
540 * for readability.
541 */
542 static int
543 zfs_inherited(sa_handle_t handle, sa_share_t share, char *sourcestr,
544 char *shareopts, char *mountpoint, char *proto, char *dataset)
545 {
546 int doshopt = 0;
547 int err = SA_OK;
548 sa_group_t group;
549 sa_resource_t resource;
550 uint64_t features;
551
552 /*
553 * Need to find the "real" parent sub-group. It may not be
554 * mounted, but it was identified in the "sourcestr"
555 * variable. The real parent not mounted can occur if
556 * "canmount=off and sharenfs=on".
557 */
558 group = find_or_create_zfs_subgroup(handle, sourcestr, proto,
559 shareopts, &doshopt);
560 if (group != NULL) {
561 /*
562 * We may need the first share for resource
563 * prototype. We only care about it if it has a
564 * resource that sets a prefix value.
565 */
566 if (share == NULL)
567 share = _sa_add_share(group, mountpoint,
568 SA_SHARE_TRANSIENT, &err,
569 (uint64_t)SA_FEATURE_NONE);
570 /*
571 * some options may only be on shares. If the opt
572 * string contains one of those, we put it just on the
573 * share.
574 */
575 if (share != NULL && doshopt == SA_PROP_SHARE_ONLY) {
576 char *options;
577 options = strdup(shareopts);
578 if (options != NULL) {
579 set_node_attr(share, "dataset", dataset);
580 err = sa_parse_legacy_options(share, options,
581 proto);
582 set_node_attr(share, "dataset", NULL);
583 free(options);
584 }
585 if (sa_get_optionset(group, proto) == NULL)
586 (void) sa_create_optionset(group, proto);
587 }
588 features = sa_proto_get_featureset(proto);
589 if (share != NULL && features & SA_FEATURE_RESOURCE) {
590 /*
591 * We have a share and the protocol requires
592 * that at least one resource exist (probably
593 * SMB). We need to make sure that there is at
594 * least one.
595 */
596 resource = sa_get_share_resource(share, NULL);
597 if (resource == NULL) {
598 zfs_construct_resource(share, dataset);
599 }
600 }
601 } else {
602 err = SA_NO_MEMORY;
603 }
604 return (err);
605 }
606
607 /*
608 * zfs_notinherited(group, share, mountpoint, shareopts, proto, dataset,
609 * grouperr)
610 *
611 * handle case where this is the top of a sub-group in ZFS. Pulled out
612 * of sa_get_zfs_shares for readability. We need the grouperr from the
613 * creation of the subgroup to know whether to add the public
614 * property, etc. to the specific share.
615 */
616 static int
617 zfs_notinherited(sa_group_t group, sa_share_t share, char *mountpoint,
618 char *shareopts, char *proto, char *dataset, int grouperr)
619 {
620 int err = SA_OK;
621 sa_resource_t resource;
622 uint64_t features;
623
624 set_node_attr(group, "zfs", "true");
625 if (share == NULL)
626 share = _sa_add_share(group, mountpoint, SA_SHARE_TRANSIENT,
627 &err, (uint64_t)SA_FEATURE_NONE);
628
629 if (err != SA_OK)
630 return (err);
631
632 if (strcmp(shareopts, "on") == 0)
633 shareopts = "";
634 if (shareopts != NULL) {
635 char *options;
636 if (grouperr == SA_PROP_SHARE_ONLY) {
637 /*
638 * Some properties may only be on shares, but
639 * due to the ZFS sub-groups being artificial,
640 * we sometimes get this and have to deal with
641 * it. We do it by attempting to put it on the
642 * share.
643 */
644 options = strdup(shareopts);
645 if (options != NULL) {
646 err = sa_parse_legacy_options(share,
647 options, proto);
648 free(options);
649 }
650 }
651 /* Unmark the share's changed state */
652 set_node_attr(share, "changed", NULL);
653 }
654 features = sa_proto_get_featureset(proto);
655 if (share != NULL && features & SA_FEATURE_RESOURCE) {
656 /*
657 * We have a share and the protocol requires that at
658 * least one resource exist (probably SMB). We need to
659 * make sure that there is at least one.
660 */
661 resource = sa_get_share_resource(share, NULL);
662 if (resource == NULL) {
663 zfs_construct_resource(share, dataset);
664 }
665 }
666 return (err);
667 }
668
669 /*
670 * zfs_grp_error(err)
671 *
672 * Print group create error, but only once. If err is 0 do the
673 * print else don't.
674 */
675
676 static void
677 zfs_grp_error(int err)
678 {
679 if (err == 0) {
680 /* only print error once */
681 (void) fprintf(stderr, dgettext(TEXT_DOMAIN,
682 "Cannot create ZFS subgroup during initialization:"
683 " %s\n"), sa_errorstr(SA_SYSTEM_ERR));
684 }
685 }
686
687 /*
688 * zfs_process_share(handle, share, mountpoint, proto, source,
689 * shareopts, sourcestr)
690 *
691 * Creates the subgroup, if necessary and adds shares, resources
692 * and properties.
693 */
694 int
695 sa_zfs_process_share(sa_handle_t handle, sa_group_t group, sa_share_t share,
696 char *mountpoint, char *proto, zprop_source_t source, char *shareopts,
697 char *sourcestr, char *dataset)
698 {
699 int err = SA_OK;
700
701 if (source & ZPROP_SRC_INHERITED) {
702 err = zfs_inherited(handle, share, sourcestr, shareopts,
703 mountpoint, proto, dataset);
704 } else {
705 group = find_or_create_zfs_subgroup(handle, dataset, proto,
706 shareopts, &err);
707 if (group == NULL) {
708 static boolean_t reported_error = B_FALSE;
709 /*
710 * There is a problem, but we can't do
711 * anything about it at this point so we issue
712 * a warning and move on.
713 */
714 zfs_grp_error(reported_error);
715 reported_error = B_TRUE;
716 }
717 set_node_attr(group, "zfs", "true");
718 /*
719 * Add share with local opts via zfs_notinherited.
720 */
721 err = zfs_notinherited(group, share, mountpoint, shareopts,
722 proto, dataset, err);
723 }
724 return (err);
725 }
726
727 /*
728 * sa_get_zfs_shares(handle, groupname)
729 *
730 * Walk the mnttab for all zfs mounts and determine which are
731 * shared. Find or create the appropriate group/sub-group to contain
732 * the shares.
733 *
734 * All shares are in a sub-group that will hold the properties. This
735 * allows representing the inherited property model.
736 *
737 * One area of complication is if "sharenfs" is set at one level of
738 * the directory tree and "sharesmb" is set at a different level, the
739 * a sub-group must be formed at the lower level for both
740 * protocols. That is the nature of the problem in CR 6667349.
741 */
742
743 int
744 sa_get_zfs_shares(sa_handle_t handle, char *groupname)
745 {
746 sa_group_t zfsgroup;
747 boolean_t nfs;
748 boolean_t nfs_inherited;
749 boolean_t smb;
750 boolean_t smb_inherited;
751 zfs_handle_t **zlist;
752 char nfsshareopts[ZFS_MAXPROPLEN];
753 char smbshareopts[ZFS_MAXPROPLEN];
754 sa_share_t share;
755 zprop_source_t source;
756 char nfssourcestr[ZFS_MAXPROPLEN];
757 char smbsourcestr[ZFS_MAXPROPLEN];
758 char mountpoint[ZFS_MAXPROPLEN];
759 size_t count = 0, i;
760 libzfs_handle_t *zfs_libhandle;
761 int err = SA_OK;
762
763 /*
764 * If we can't access libzfs, don't bother doing anything.
765 */
766 zfs_libhandle = ((sa_handle_impl_t)handle)->zfs_libhandle;
767 if (zfs_libhandle == NULL)
768 return (SA_SYSTEM_ERR);
769
770 zfsgroup = find_or_create_group(handle, groupname, NULL, &err);
771 /* Not an error, this could be a legacy condition */
772 if (zfsgroup == NULL)
773 return (SA_OK);
774
775 /*
776 * need to walk the mounted ZFS pools and datasets to
777 * find shares that are possible.
778 */
779 get_all_filesystems((sa_handle_impl_t)handle, &zlist, &count);
780 qsort(zlist, count, sizeof (void *), mountpoint_compare);
781
782 for (i = 0; i < count; i++) {
783 char *dataset;
784
785 source = ZPROP_SRC_ALL;
786 /* If no mountpoint, skip. */
787 if (zfs_prop_get(zlist[i], ZFS_PROP_MOUNTPOINT,
788 mountpoint, sizeof (mountpoint), NULL, NULL, 0,
789 B_FALSE) != 0)
790 continue;
791
792 /*
793 * zfs_get_name value must not be freed. It is just a
794 * pointer to a value in the handle.
795 */
796 if ((dataset = (char *)zfs_get_name(zlist[i])) == NULL)
797 continue;
798
799 /*
800 * only deal with "mounted" file systems since
801 * unmounted file systems can't actually be shared.
802 */
803
804 if (!zfs_is_mounted(zlist[i], NULL))
805 continue;
806
807 nfs = nfs_inherited = B_FALSE;
808
809 if (zfs_prop_get(zlist[i], ZFS_PROP_SHARENFS, nfsshareopts,
810 sizeof (nfsshareopts), &source, nfssourcestr,
811 ZFS_MAXPROPLEN, B_FALSE) == 0 &&
812 strcmp(nfsshareopts, "off") != 0) {
813 if (source & ZPROP_SRC_INHERITED)
814 nfs_inherited = B_TRUE;
815 else
816 nfs = B_TRUE;
817 }
818
819 smb = smb_inherited = B_FALSE;
820 if (zfs_prop_get(zlist[i], ZFS_PROP_SHARESMB, smbshareopts,
821 sizeof (smbshareopts), &source, smbsourcestr,
822 ZFS_MAXPROPLEN, B_FALSE) == 0 &&
823 strcmp(smbshareopts, "off") != 0) {
824 if (source & ZPROP_SRC_INHERITED)
825 smb_inherited = B_TRUE;
826 else
827 smb = B_TRUE;
828 }
829
830 /*
831 * If the mountpoint is already shared, it must be a
832 * non-ZFS share. We want to remove the share from its
833 * parent group and reshare it under ZFS.
834 */
835 share = sa_find_share(handle, mountpoint);
836 if (share != NULL &&
837 (nfs || smb || nfs_inherited || smb_inherited)) {
838 err = sa_remove_share(share);
839 share = NULL;
840 }
841
842 /*
843 * At this point, we have the information needed to
844 * determine what to do with the share.
845 *
846 * If smb or nfs is set, we have a new sub-group.
847 * If smb_inherit and/or nfs_inherit is set, then
848 * place on an existing sub-group. If both are set,
849 * the existing sub-group is the closest up the tree.
850 */
851 if (nfs || smb) {
852 /*
853 * Non-inherited is the straightforward
854 * case. sa_zfs_process_share handles it
855 * directly. Make sure that if the "other"
856 * protocol is inherited, that we treat it as
857 * non-inherited as well.
858 */
859 if (nfs || nfs_inherited) {
860 err = sa_zfs_process_share(handle, zfsgroup,
861 share, mountpoint, "nfs",
862 0, nfsshareopts,
863 nfssourcestr, dataset);
864 share = sa_find_share(handle, mountpoint);
865 }
866 if (smb || smb_inherited) {
867 err = sa_zfs_process_share(handle, zfsgroup,
868 share, mountpoint, "smb",
869 0, smbshareopts,
870 smbsourcestr, dataset);
871 }
872 } else if (nfs_inherited || smb_inherited) {
873 char *grpdataset;
874 /*
875 * If we only have inherited groups, it is
876 * important to find the closer of the two if
877 * the protocols are set at different
878 * levels. The closest sub-group is the one we
879 * want to work with.
880 */
881 if (nfs_inherited && smb_inherited) {
882 if (strcmp(nfssourcestr, smbsourcestr) <= 0)
883 grpdataset = nfssourcestr;
884 else
885 grpdataset = smbsourcestr;
886 } else if (nfs_inherited) {
887 grpdataset = nfssourcestr;
888 } else if (smb_inherited) {
889 grpdataset = smbsourcestr;
890 }
891 if (nfs_inherited) {
892 err = sa_zfs_process_share(handle, zfsgroup,
893 share, mountpoint, "nfs",
894 ZPROP_SRC_INHERITED, nfsshareopts,
895 grpdataset, dataset);
896 share = sa_find_share(handle, mountpoint);
897 }
898 if (smb_inherited) {
899 err = sa_zfs_process_share(handle, zfsgroup,
900 share, mountpoint, "smb",
901 ZPROP_SRC_INHERITED, smbshareopts,
902 grpdataset, dataset);
903 }
904 }
905 }
906 /*
907 * Don't need to free the "zlist" variable since it is only a
908 * pointer to a cached value that will be freed when
909 * sa_fini() is called.
910 */
911 return (err);
912 }
913
914 #define COMMAND "/usr/sbin/zfs"
915
916 /*
917 * sa_zfs_set_sharenfs(group, path, on)
918 *
919 * Update the "sharenfs" property on the path. If on is true, then set
920 * to the properties on the group or "on" if no properties are
921 * defined. Set to "off" if on is false.
922 */
923
924 int
925 sa_zfs_set_sharenfs(sa_group_t group, char *path, int on)
926 {
927 int ret = SA_NOT_IMPLEMENTED;
928 char *command;
929
930 command = malloc(ZFS_MAXPROPLEN * 2);
931 if (command != NULL) {
932 char *opts = NULL;
933 char *dataset = NULL;
934 FILE *pfile;
935 sa_handle_impl_t impl_handle;
936 /* for now, NFS is always available for "zfs" */
937 if (on) {
938 opts = sa_proto_legacy_format("nfs", group, 1);
939 if (opts != NULL && strlen(opts) == 0) {
940 free(opts);
941 opts = strdup("on");
942 }
943 }
944
945 impl_handle = (sa_handle_impl_t)sa_find_group_handle(group);
946 assert(impl_handle != NULL);
947 if (impl_handle != NULL)
948 dataset = get_zfs_dataset(impl_handle, path, B_FALSE);
949 else
950 ret = SA_SYSTEM_ERR;
951
952 if (dataset != NULL) {
953 (void) snprintf(command, ZFS_MAXPROPLEN * 2,
954 "%s set sharenfs=\"%s\" %s", COMMAND,
955 opts != NULL ? opts : "off", dataset);
956 pfile = popen(command, "r");
957 if (pfile != NULL) {
958 ret = pclose(pfile);
959 if (ret != 0)
960 ret = SA_SYSTEM_ERR;
961 }
962 }
963 if (opts != NULL)
964 free(opts);
965 if (dataset != NULL)
966 free(dataset);
967 free(command);
968 }
969 return (ret);
970 }
971
972 /*
973 * add_resources(share, opt)
974 *
975 * Add resource properties to those in "opt". Resources are prefixed
976 * with name=resourcename.
977 */
978 static char *
979 add_resources(sa_share_t share, char *opt)
980 {
981 char *newopt = NULL;
982 char *propstr;
983 sa_resource_t resource;
984
985 newopt = strdup(opt);
986 if (newopt == NULL)
987 return (newopt);
988
989 for (resource = sa_get_share_resource(share, NULL);
990 resource != NULL;
991 resource = sa_get_next_resource(resource)) {
992 char *name;
993 size_t size;
994
995 name = sa_get_resource_attr(resource, "name");
996 if (name == NULL) {
997 free(newopt);
998 return (NULL);
999 }
1000 size = strlen(name) + strlen(opt) + sizeof ("name=") + 1;
1001 newopt = calloc(1, size);
1002 if (newopt != NULL)
1003 (void) snprintf(newopt, size, "%s,name=%s", opt, name);
1004 sa_free_attr_string(name);
1005 free(opt);
1006 opt = newopt;
1007 propstr = sa_proto_legacy_format("smb", resource, 0);
1008 if (propstr == NULL) {
1009 free(opt);
1010 return (NULL);
1011 }
1012 size = strlen(propstr) + strlen(opt) + 2;
1013 newopt = calloc(1, size);
1014 if (newopt != NULL)
1015 (void) snprintf(newopt, size, "%s,%s", opt, propstr);
1016 free(opt);
1017 opt = newopt;
1018 }
1019 return (opt);
1020 }
1021
1022 /*
1023 * sa_zfs_set_sharesmb(group, path, on)
1024 *
1025 * Update the "sharesmb" property on the path. If on is true, then set
1026 * to the properties on the group or "on" if no properties are
1027 * defined. Set to "off" if on is false.
1028 */
1029
1030 int
1031 sa_zfs_set_sharesmb(sa_group_t group, char *path, int on)
1032 {
1033 int ret = SA_NOT_IMPLEMENTED;
1034 char *command;
1035 sa_share_t share;
1036
1037 /* In case SMB not enabled */
1038 if (sa_get_optionset(group, "smb") == NULL)
1039 return (SA_NOT_SUPPORTED);
1040
1041 command = malloc(ZFS_MAXPROPLEN * 2);
1042 if (command != NULL) {
1043 char *opts = NULL;
1044 char *dataset = NULL;
1045 FILE *pfile;
1046 sa_handle_impl_t impl_handle;
1047
1048 if (on) {
1049 char *newopt;
1050
1051 share = sa_get_share(group, NULL);
1052 opts = sa_proto_legacy_format("smb", share, 1);
1053 if (opts != NULL && strlen(opts) == 0) {
1054 free(opts);
1055 opts = strdup("on");
1056 }
1057 newopt = add_resources(opts, share);
1058 free(opts);
1059 opts = newopt;
1060 }
1061
1062 impl_handle = (sa_handle_impl_t)sa_find_group_handle(group);
1063 assert(impl_handle != NULL);
1064 if (impl_handle != NULL)
1065 dataset = get_zfs_dataset(impl_handle, path, B_FALSE);
1066 else
1067 ret = SA_SYSTEM_ERR;
1068
1069 if (dataset != NULL) {
1070 (void) snprintf(command, ZFS_MAXPROPLEN * 2,
1071 "echo %s set sharesmb=\"%s\" %s", COMMAND,
1072 opts != NULL ? opts : "off", dataset);
1073 pfile = popen(command, "r");
1074 if (pfile != NULL) {
1075 ret = pclose(pfile);
1076 if (ret != 0)
1077 ret = SA_SYSTEM_ERR;
1078 }
1079 }
1080 if (opts != NULL)
1081 free(opts);
1082 if (dataset != NULL)
1083 free(dataset);
1084 free(command);
1085 }
1086 return (ret);
1087 }
1088
1089 /*
1090 * sa_zfs_update(group)
1091 *
1092 * call back to ZFS to update the share if necessary.
1093 * Don't do it if it isn't a real change.
1094 */
1095 int
1096 sa_zfs_update(sa_group_t group)
1097 {
1098 sa_optionset_t protopt;
1099 sa_group_t parent;
1100 char *command;
1101 char *optstring;
1102 int ret = SA_OK;
1103 int doupdate = 0;
1104 FILE *pfile;
1105
1106 if (sa_is_share(group))
1107 parent = sa_get_parent_group(group);
1108 else
1109 parent = group;
1110
1111 if (parent != NULL) {
1112 command = malloc(ZFS_MAXPROPLEN * 2);
1113 if (command == NULL)
1114 return (SA_NO_MEMORY);
1115
1116 *command = '\0';
1117 for (protopt = sa_get_optionset(parent, NULL); protopt != NULL;
1118 protopt = sa_get_next_optionset(protopt)) {
1119
1120 char *proto = sa_get_optionset_attr(protopt, "type");
1121 char *path;
1122 char *dataset = NULL;
1123 char *zfsopts = NULL;
1124
1125 if (sa_is_share(group)) {
1126 path = sa_get_share_attr((sa_share_t)group,
1127 "path");
1128 if (path != NULL) {
1129 sa_handle_impl_t impl_handle;
1130
1131 impl_handle = sa_find_group_handle(
1132 group);
1133 if (impl_handle != NULL)
1134 dataset = get_zfs_dataset(
1135 impl_handle, path, B_FALSE);
1136 else
1137 ret = SA_SYSTEM_ERR;
1138
1139 sa_free_attr_string(path);
1140 }
1141 } else {
1142 dataset = sa_get_group_attr(group, "name");
1143 }
1144 /* update only when there is an optstring found */
1145 doupdate = 0;
1146 if (proto != NULL && dataset != NULL) {
1147 optstring = sa_proto_legacy_format(proto,
1148 group, 1);
1149 zfsopts = get_zfs_property(dataset,
1150 ZFS_PROP_SHARENFS);
1151
1152 if (optstring != NULL && zfsopts != NULL) {
1153 if (strcmp(optstring, zfsopts) != 0)
1154 doupdate++;
1155 }
1156 if (doupdate) {
1157 if (optstring != NULL &&
1158 strlen(optstring) > 0) {
1159 (void) snprintf(command,
1160 ZFS_MAXPROPLEN * 2,
1161 "%s set share%s=%s %s",
1162 COMMAND, proto,
1163 optstring, dataset);
1164 } else {
1165 (void) snprintf(command,
1166 ZFS_MAXPROPLEN * 2,
1167 "%s set share%s=on %s",
1168 COMMAND, proto,
1169 dataset);
1170 }
1171 pfile = popen(command, "r");
1172 if (pfile != NULL)
1173 ret = pclose(pfile);
1174 switch (ret) {
1175 default:
1176 case 1:
1177 ret = SA_SYSTEM_ERR;
1178 break;
1179 case 2:
1180 ret = SA_SYNTAX_ERR;
1181 break;
1182 case 0:
1183 break;
1184 }
1185 }
1186 if (optstring != NULL)
1187 free(optstring);
1188 if (zfsopts != NULL)
1189 free(zfsopts);
1190 }
1191 if (proto != NULL)
1192 sa_free_attr_string(proto);
1193 if (dataset != NULL)
1194 free(dataset);
1195 }
1196 free(command);
1197 }
1198 return (ret);
1199 }
1200
1201 /*
1202 * sa_group_is_zfs(group)
1203 *
1204 * Given the group, determine if the zfs attribute is set.
1205 */
1206
1207 int
1208 sa_group_is_zfs(sa_group_t group)
1209 {
1210 char *zfs;
1211 int ret = 0;
1212
1213 zfs = sa_get_group_attr(group, "zfs");
1214 if (zfs != NULL) {
1215 ret = 1;
1216 sa_free_attr_string(zfs);
1217 }
1218 return (ret);
1219 }
1220
1221 /*
1222 * sa_path_is_zfs(path)
1223 *
1224 * Check to see if the file system path represents is of type "zfs".
1225 */
1226
1227 int
1228 sa_path_is_zfs(char *path)
1229 {
1230 char *fstype;
1231 int ret = 0;
1232
1233 fstype = sa_fstype(path);
1234 if (fstype != NULL && strcmp(fstype, "zfs") == 0)
1235 ret = 1;
1236 if (fstype != NULL)
1237 sa_free_fstype(fstype);
1238 return (ret);
1239 }
1240
1241 int
1242 sa_sharetab_fill_zfs(sa_share_t share, share_t *sh, char *proto)
1243 {
1244 char *path;
1245
1246 /* Make sure path is valid */
1247
1248 path = sa_get_share_attr(share, "path");
1249 if (path != NULL) {
1250 (void) memset(sh, 0, sizeof (sh));
1251 (void) sa_fillshare(share, proto, sh);
1252 sa_free_attr_string(path);
1253 return (0);
1254 } else
1255 return (1);
1256 }
1257
1258 #define SMAX(i, j) \
1259 if ((j) > (i)) { \
1260 (i) = (j); \
1261 }
1262
1263 int
1264 sa_share_zfs(sa_share_t share, sa_resource_t resource, char *path, share_t *sh,
1265 void *exportdata, zfs_share_op_t operation)
1266 {
1267 libzfs_handle_t *libhandle;
1268 sa_group_t group;
1269 sa_handle_t sahandle;
1270 char *dataset;
1271 int err = EINVAL;
1272 int i, j;
1273 char newpath[MAXPATHLEN];
1274 char *pathp;
1275
1276 /*
1277 * First find the dataset name
1278 */
1279 if ((group = sa_get_parent_group(share)) == NULL) {
1280 return (EINVAL);
1281 }
1282 if ((sahandle = sa_find_group_handle(group)) == NULL) {
1283 return (EINVAL);
1284 }
1285
1286 /*
1287 * If get_zfs_dataset fails, see if it is a subdirectory
1288 */
1289
1290 pathp = path;
1291 while ((dataset = get_zfs_dataset(sahandle, pathp, B_TRUE)) == NULL) {
1292 char *p;
1293
1294 if (pathp == path) {
1295 (void) strlcpy(newpath, path, sizeof (newpath));
1296 pathp = newpath;
1297 }
1298
1299 /*
1300 * Make sure only one leading '/' This condition came
1301 * about when using HAStoragePlus which insisted on
1302 * putting an extra leading '/' in the ZFS path
1303 * name. The problem is fixed in other areas, but this
1304 * will catch any other ways that a double slash might
1305 * get introduced.
1306 */
1307 while (*pathp == '/' && *(pathp + 1) == '/')
1308 pathp++;
1309
1310 /*
1311 * chop off part of path, but if we are at root then
1312 * make sure path is a /
1313 */
1314 if ((strlen(pathp) > 1) && (p = strrchr(pathp, '/'))) {
1315 if (pathp == p) {
1316 *(p + 1) = '\0'; /* skip over /, root case */
1317 } else {
1318 *p = '\0';
1319 }
1320 } else {
1321 return (EINVAL);
1322 }
1323 }
1324
1325 libhandle = libzfs_init();
1326 if (libhandle != NULL) {
1327 char *resource_name;
1328
1329 i = (sh->sh_path ? strlen(sh->sh_path) : 0);
1330 sh->sh_size = i;
1331
1332 j = (sh->sh_res ? strlen(sh->sh_res) : 0);
1333 sh->sh_size += j;
1334 SMAX(i, j);
1335
1336 j = (sh->sh_fstype ? strlen(sh->sh_fstype) : 0);
1337 sh->sh_size += j;
1338 SMAX(i, j);
1339
1340 j = (sh->sh_opts ? strlen(sh->sh_opts) : 0);
1341 sh->sh_size += j;
1342 SMAX(i, j);
1343
1344 j = (sh->sh_descr ? strlen(sh->sh_descr) : 0);
1345 sh->sh_size += j;
1346 SMAX(i, j);
1347
1348 resource_name = sa_get_resource_attr(resource, "name");
1349
1350 err = zfs_deleg_share_nfs(libhandle, dataset, path,
1351 resource_name, exportdata, sh, i, operation);
1352 if (err == SA_OK)
1353 sa_update_sharetab_ts(sahandle);
1354 else
1355 err = errno;
1356 if (resource_name)
1357 sa_free_attr_string(resource_name);
1358
1359 libzfs_fini(libhandle);
1360 }
1361 free(dataset);
1362 return (err);
1363 }
1364
1365 /*
1366 * sa_get_zfs_handle(handle)
1367 *
1368 * Given an sa_handle_t, return the libzfs_handle_t *. This is only
1369 * used internally by libzfs. Needed in order to avoid including
1370 * libshare_impl.h in libzfs.
1371 */
1372
1373 libzfs_handle_t *
1374 sa_get_zfs_handle(sa_handle_t handle)
1375 {
1376 sa_handle_impl_t implhandle = (sa_handle_impl_t)handle;
1377
1378 return (implhandle->zfs_libhandle);
1379 }
1380
1381 /*
1382 * sa_get_zfs_info(libzfs, path, mountpoint, dataset)
1383 *
1384 * Find the ZFS dataset and mountpoint for a given path
1385 */
1386 int
1387 sa_zfs_get_info(libzfs_handle_t *libzfs, char *path, char *mountpointp,
1388 char *datasetp)
1389 {
1390 get_all_cbdata_t cb = { 0 };
1391 int i;
1392 char mountpoint[ZFS_MAXPROPLEN];
1393 char dataset[ZFS_MAXPROPLEN];
1394 char canmount[ZFS_MAXPROPLEN];
1395 char *dp;
1396 int count;
1397 int ret = 0;
1398
1399 cb.cb_types = ZFS_TYPE_FILESYSTEM;
1400
1401 if (libzfs == NULL)
1402 return (0);
1403
1404 (void) zfs_iter_root(libzfs, get_one_filesystem, &cb);
1405 count = cb.cb_used;
1406
1407 qsort(cb.cb_handles, count, sizeof (void *), mountpoint_compare);
1408 for (i = 0; i < count; i++) {
1409 /* must have a mountpoint */
1410 if (zfs_prop_get(cb.cb_handles[i], ZFS_PROP_MOUNTPOINT,
1411 mountpoint, sizeof (mountpoint),
1412 NULL, NULL, 0, B_FALSE) != 0) {
1413 /* no mountpoint */
1414 continue;
1415 }
1416
1417 /* mountpoint must be a path */
1418 if (strcmp(mountpoint, ZFS_MOUNTPOINT_NONE) == 0 ||
1419 strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0) {
1420 /*
1421 * Search mmttab for mountpoint
1422 */
1423
1424 if (get_legacy_mountpoint(path, dataset,
1425 ZFS_MAXPROPLEN, mountpoint,
1426 ZFS_MAXPROPLEN) == 0) {
1427 ret = 1;
1428 break;
1429 }
1430 continue;
1431 }
1432
1433 /* canmount must be set */
1434 canmount[0] = '\0';
1435 if (zfs_prop_get(cb.cb_handles[i], ZFS_PROP_CANMOUNT, canmount,
1436 sizeof (canmount), NULL, NULL, 0, B_FALSE) != 0 ||
1437 strcmp(canmount, "off") == 0)
1438 continue;
1439
1440 /*
1441 * have a mountable handle but want to skip those marked none
1442 * and legacy
1443 */
1444 if (strcmp(mountpoint, path) == 0) {
1445 dp = (char *)zfs_get_name(cb.cb_handles[i]);
1446 if (dp != NULL) {
1447 if (datasetp != NULL)
1448 (void) strcpy(datasetp, dp);
1449 if (mountpointp != NULL)
1450 (void) strcpy(mountpointp, mountpoint);
1451 ret = 1;
1452 }
1453 break;
1454 }
1455
1456 }
1457
1458 return (ret);
1459 }
1460
1461 /*
1462 * This method builds values for "sharesmb" property from the
1463 * nvlist argument. The values are returned in sharesmb_val variable.
1464 */
1465 static int
1466 sa_zfs_sprintf_new_prop(nvlist_t *nvl, char *sharesmb_val)
1467 {
1468 char cur_val[MAXPATHLEN];
1469 char *name, *val;
1470 nvpair_t *cur;
1471 int err = 0;
1472
1473 cur = nvlist_next_nvpair(nvl, NULL);
1474 while (cur != NULL) {
1475 name = nvpair_name(cur);
1476 err = nvpair_value_string(cur, &val);
1477 if ((err != 0) || (name == NULL) || (val == NULL))
1478 return (-1);
1479
1480 (void) snprintf(cur_val, MAXPATHLEN, "%s=%s,", name, val);
1481 (void) strlcat(sharesmb_val, cur_val, MAXPATHLEN);
1482
1483 cur = nvlist_next_nvpair(nvl, cur);
1484 }
1485
1486 return (0);
1487 }
1488
1489 /*
1490 * This method builds values for "sharesmb" property from values
1491 * already existing on the share. The properties set via sa_zfs_sprint_new_prop
1492 * method are passed in sharesmb_val. If a existing property is already
1493 * set via sa_zfs_sprint_new_prop method, then they are not appended
1494 * to the sharesmb_val string. The returned sharesmb_val string is a combination
1495 * of new and existing values for 'sharesmb' property.
1496 */
1497 static int
1498 sa_zfs_sprintf_existing_prop(zfs_handle_t *handle, char *sharesmb_val)
1499 {
1500 char shareopts[ZFS_MAXPROPLEN], cur_val[MAXPATHLEN];
1501 char *token, *last, *value;
1502
1503 if (zfs_prop_get(handle, ZFS_PROP_SHARESMB, shareopts,
1504 sizeof (shareopts), NULL, NULL, 0, B_FALSE) != 0)
1505 return (-1);
1506
1507 if (strstr(shareopts, "=") == NULL)
1508 return (0);
1509
1510 for (token = strtok_r(shareopts, ",", &last); token != NULL;
1511 token = strtok_r(NULL, ",", &last)) {
1512 value = strchr(token, '=');
1513 if (value == NULL)
1514 return (-1);
1515 *value++ = '\0';
1516
1517 (void) snprintf(cur_val, MAXPATHLEN, "%s=", token);
1518 if (strstr(sharesmb_val, cur_val) == NULL) {
1519 (void) strlcat(cur_val, value, MAXPATHLEN);
1520 (void) strlcat(cur_val, ",", MAXPATHLEN);
1521 (void) strlcat(sharesmb_val, cur_val, MAXPATHLEN);
1522 }
1523 }
1524
1525 return (0);
1526 }
1527
1528 /*
1529 * Sets the share properties on a ZFS share. For now, this method sets only
1530 * the "sharesmb" property.
1531 *
1532 * This method includes building a comma seperated name-value string to be
1533 * set on the "sharesmb" property of a ZFS share. This name-value string is
1534 * build in 2 steps:
1535 * - New property values given as name-value pair are set first.
1536 * - Existing optionset properties, which are not part of the new properties
1537 * passed in step 1, are appended to the newly set properties.
1538 */
1539 int
1540 sa_zfs_setprop(sa_handle_t handle, char *path, nvlist_t *nvl)
1541 {
1542 zfs_handle_t *z_fs;
1543 libzfs_handle_t *z_lib;
1544 char sharesmb_val[MAXPATHLEN];
1545 char *dataset, *lastcomma;
1546
1547 if (nvlist_empty(nvl))
1548 return (0);
1549
1550 if ((handle == NULL) || (path == NULL))
1551 return (-1);
1552
1553 if ((dataset = get_zfs_dataset(handle, path, B_FALSE)) == NULL)
1554 return (-1);
1555
1556 if ((z_lib = libzfs_init()) == NULL) {
1557 free(dataset);
1558 return (-1);
1559 }
1560
1561 z_fs = zfs_open(z_lib, dataset, ZFS_TYPE_DATASET);
1562 if (z_fs == NULL) {
1563 free(dataset);
1564 libzfs_fini(z_lib);
1565 return (-1);
1566 }
1567
1568 bzero(sharesmb_val, MAXPATHLEN);
1569 if (sa_zfs_sprintf_new_prop(nvl, sharesmb_val) != 0) {
1570 free(dataset);
1571 zfs_close(z_fs);
1572 libzfs_fini(z_lib);
1573 return (-1);
1574 }
1575
1576 if (sa_zfs_sprintf_existing_prop(z_fs, sharesmb_val) != 0) {
1577 free(dataset);
1578 zfs_close(z_fs);
1579 libzfs_fini(z_lib);
1580 return (-1);
1581 }
1582
1583 lastcomma = strrchr(sharesmb_val, ',');
1584 if ((lastcomma != NULL) && (lastcomma[1] == '\0'))
1585 *lastcomma = '\0';
1586
1587 (void) zfs_prop_set(z_fs, zfs_prop_to_name(ZFS_PROP_SHARESMB),
1588 sharesmb_val);
1589 free(dataset);
1590 zfs_close(z_fs);
1591 libzfs_fini(z_lib);
1592
1593 return (0);
1594 }