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 * Copyright (c) 2012, 2014 by Delphix. All rights reserved. 28 */ 29 30 #include <stdio.h> 31 #include <libzfs.h> 32 #include <string.h> 33 #include <strings.h> 34 #include <errno.h> 35 #include <libshare.h> 36 #include "libshare_impl.h" 37 #include <libintl.h> 38 #include <sys/mnttab.h> 39 #include <sys/mntent.h> 40 41 extern sa_share_t _sa_add_share(sa_group_t, char *, int, int *, uint64_t); 42 extern sa_group_t _sa_create_zfs_group(sa_group_t, char *); 43 extern char *sa_fstype(char *); 44 extern void set_node_attr(void *, char *, char *); 45 extern int sa_is_share(void *); 46 extern void sa_update_sharetab_ts(sa_handle_t); 47 48 /* 49 * File system specific code for ZFS. The original code was stolen 50 * from the "zfs" command and modified to better suit this library's 51 * usage. 52 */ 53 54 typedef struct get_all_cbdata { 55 zfs_handle_t **cb_handles; 56 size_t cb_alloc; 57 size_t cb_used; 58 uint_t cb_types; 59 } get_all_cbdata_t; 60 61 /* 62 * sa_zfs_init(impl_handle) 63 * 64 * Initialize an access handle into libzfs. The handle needs to stay 65 * around until sa_zfs_fini() in order to maintain the cache of 66 * mounts. 67 */ 68 69 int 70 sa_zfs_init(sa_handle_impl_t impl_handle) 71 { 72 impl_handle->zfs_libhandle = libzfs_init(); 73 if (impl_handle->zfs_libhandle != NULL) { 74 libzfs_print_on_error(impl_handle->zfs_libhandle, B_TRUE); 75 return (B_TRUE); 76 } 77 return (B_FALSE); 78 } 79 80 /* 81 * sa_zfs_fini(impl_handle) 82 * 83 * cleanup data structures and the libzfs handle used for accessing 84 * zfs file share info. 85 */ 86 87 void 88 sa_zfs_fini(sa_handle_impl_t impl_handle) 89 { 90 if (impl_handle->zfs_libhandle != NULL) { 91 if (impl_handle->zfs_list != NULL) { 92 zfs_handle_t **zhp = impl_handle->zfs_list; 93 size_t i; 94 95 /* 96 * Contents of zfs_list need to be freed so we 97 * don't lose ZFS handles. 98 */ 99 for (i = 0; i < impl_handle->zfs_list_count; i++) { 100 zfs_close(zhp[i]); 101 } 102 free(impl_handle->zfs_list); 103 impl_handle->zfs_list = NULL; 104 impl_handle->zfs_list_count = 0; 105 } 106 107 libzfs_fini(impl_handle->zfs_libhandle); 108 impl_handle->zfs_libhandle = NULL; 109 } 110 } 111 112 /* 113 * get_one_filesystem(zfs_handle_t, data) 114 * 115 * an iterator function called while iterating through the ZFS 116 * root. It accumulates into an array of file system handles that can 117 * be used to derive info about those file systems. 118 * 119 * Note that as this function is called, we close all zhp handles that 120 * are not going to be places into the cp_handles list. We don't want 121 * to close the ones we are keeping, but all others would be leaked if 122 * not closed here. 123 */ 124 125 static int 126 get_one_filesystem(zfs_handle_t *zhp, void *data) 127 { 128 get_all_cbdata_t *cbp = data; 129 zfs_type_t type = zfs_get_type(zhp); 130 131 /* 132 * Interate over any nested datasets. 133 */ 134 if (type == ZFS_TYPE_FILESYSTEM && 135 zfs_iter_filesystems(zhp, get_one_filesystem, data) != 0) { 136 zfs_close(zhp); 137 return (1); 138 } 139 140 /* 141 * Skip any datasets whose type does not match. 142 */ 143 if ((type & cbp->cb_types) == 0) { 144 zfs_close(zhp); 145 return (0); 146 } 147 148 if (cbp->cb_alloc == cbp->cb_used) { 149 zfs_handle_t **handles; 150 151 if (cbp->cb_alloc == 0) 152 cbp->cb_alloc = 64; 153 else 154 cbp->cb_alloc *= 2; 155 156 handles = (zfs_handle_t **)calloc(1, 157 cbp->cb_alloc * sizeof (void *)); 158 159 if (handles == NULL) { 160 zfs_close(zhp); 161 return (0); 162 } 163 if (cbp->cb_handles) { 164 bcopy(cbp->cb_handles, handles, 165 cbp->cb_used * sizeof (void *)); 166 free(cbp->cb_handles); 167 } 168 169 cbp->cb_handles = handles; 170 } 171 172 cbp->cb_handles[cbp->cb_used++] = zhp; 173 174 return (0); 175 } 176 177 /* 178 * get_all_filesystems(zfs_handle_t ***fslist, size_t *count) 179 * 180 * iterate through all ZFS file systems starting at the root. Returns 181 * a count and an array of handle pointers. Allocating is only done 182 * once. The caller does not need to free since it will be done at 183 * sa_zfs_fini() time. 184 */ 185 186 static void 187 get_all_filesystems(sa_handle_impl_t impl_handle, 188 zfs_handle_t ***fslist, size_t *count) 189 { 190 get_all_cbdata_t cb = { 0 }; 191 cb.cb_types = ZFS_TYPE_FILESYSTEM; 192 193 if (impl_handle->zfs_list != NULL) { 194 *fslist = impl_handle->zfs_list; 195 *count = impl_handle->zfs_list_count; 196 return; 197 } 198 199 (void) zfs_iter_root(impl_handle->zfs_libhandle, 200 get_one_filesystem, &cb); 201 202 impl_handle->zfs_list = *fslist = cb.cb_handles; 203 impl_handle->zfs_list_count = *count = cb.cb_used; 204 } 205 206 /* 207 * mountpoint_compare(a, b) 208 * 209 * compares the mountpoint on two zfs file systems handles. 210 * returns values following strcmp() model. 211 */ 212 213 static int 214 mountpoint_compare(const void *a, const void *b) 215 { 216 zfs_handle_t **za = (zfs_handle_t **)a; 217 zfs_handle_t **zb = (zfs_handle_t **)b; 218 char mounta[MAXPATHLEN]; 219 char mountb[MAXPATHLEN]; 220 221 verify(zfs_prop_get(*za, ZFS_PROP_MOUNTPOINT, mounta, 222 sizeof (mounta), NULL, NULL, 0, B_FALSE) == 0); 223 verify(zfs_prop_get(*zb, ZFS_PROP_MOUNTPOINT, mountb, 224 sizeof (mountb), NULL, NULL, 0, B_FALSE) == 0); 225 226 return (strcmp(mounta, mountb)); 227 } 228 229 /* 230 * return legacy mountpoint. Caller provides space for mountpoint and 231 * dataset. 232 */ 233 int 234 get_legacy_mountpoint(char *path, char *dataset, size_t dlen, 235 char *mountpoint, size_t mlen) 236 { 237 FILE *fp; 238 struct mnttab entry; 239 240 if ((fp = fopen(MNTTAB, "r")) == NULL) { 241 return (1); 242 } 243 244 while (getmntent(fp, &entry) == 0) { 245 246 if (entry.mnt_fstype == NULL || 247 strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) 248 continue; 249 250 if (strcmp(entry.mnt_mountp, path) == 0) { 251 if (mlen > 0) 252 (void) strlcpy(mountpoint, entry.mnt_mountp, 253 mlen); 254 if (dlen > 0) 255 (void) strlcpy(dataset, entry.mnt_special, 256 dlen); 257 break; 258 } 259 } 260 (void) fclose(fp); 261 return (1); 262 } 263 264 /* 265 * get_zfs_dataset(impl_handle, path) 266 * 267 * get the name of the ZFS dataset the path is equivalent to. The 268 * dataset name is used for get/set of ZFS properties since libzfs 269 * requires a dataset to do a zfs_open(). 270 */ 271 272 static char * 273 get_zfs_dataset(sa_handle_impl_t impl_handle, char *path, 274 boolean_t search_mnttab) 275 { 276 size_t i, count = 0; 277 char *dataset = NULL; 278 zfs_handle_t **zlist; 279 char mountpoint[ZFS_MAXPROPLEN]; 280 char canmount[ZFS_MAXPROPLEN]; 281 282 get_all_filesystems(impl_handle, &zlist, &count); 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 } 1595