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