libshare/common/libshare_zfs.c

	libshare_zfs.c revision 3c484793bfff1d54b5fdf216e48d5cfc625d5170
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

#include <stdio.h>
#include <libzfs.h>
#include <string.h>
#include <strings.h>
#include <libshare.h>
#include "libshare_impl.h"
#include <libintl.h>
#include <sys/mnttab.h>
#include <sys/mntent.h>

extern sa_share_t _sa_add_share(sa_group_t, char *, int, int *, uint64_t);
extern sa_group_t _sa_create_zfs_group(sa_group_t, char *);
extern char *sa_fstype(char *);
extern void set_node_attr(void *, char *, char *);
extern int sa_is_share(void *);
extern void sa_update_sharetab_ts(sa_handle_t);

/*
 * File system specific code for ZFS. The original code was stolen
 * from the "zfs" command and modified to better suit this library's
 * usage.
 */

typedef struct get_all_cbdata {
    zfs_handle_t    **cb_handles;
    size_t      cb_alloc;
    size_t      cb_used;
    uint_t      cb_types;
} get_all_cbdata_t;

/*
 * sa_zfs_init(impl_handle)
 *
 * Initialize an access handle into libzfs.  The handle needs to stay
 * around until sa_zfs_fini() in order to maintain the cache of
 * mounts.
 */

int
sa_zfs_init(sa_handle_impl_t impl_handle)
{
    impl_handle->zfs_libhandle = libzfs_init();
    if (impl_handle->zfs_libhandle != NULL) {
        libzfs_print_on_error(impl_handle->zfs_libhandle, B_TRUE);
        return (B_TRUE);
    }
    return (B_FALSE);
}

/*
 * sa_zfs_fini(impl_handle)
 *
 * cleanup data structures and the libzfs handle used for accessing
 * zfs file share info.
 */

void
sa_zfs_fini(sa_handle_impl_t impl_handle)
{
    if (impl_handle->zfs_libhandle != NULL) {
        if (impl_handle->zfs_list != NULL) {
            zfs_handle_t **zhp = impl_handle->zfs_list;
            size_t i;

            /*
             * Contents of zfs_list need to be freed so we
             * don't lose ZFS handles.
             */
            for (i = 0; i < impl_handle->zfs_list_count; i++) {
                zfs_close(zhp[i]);
            }
            free(impl_handle->zfs_list);
            impl_handle->zfs_list = NULL;
            impl_handle->zfs_list_count = 0;
        }

        libzfs_fini(impl_handle->zfs_libhandle);
        impl_handle->zfs_libhandle = NULL;
    }
}

/*
 * get_one_filesystem(zfs_handle_t, data)
 *
 * an iterator function called while iterating through the ZFS
 * root. It accumulates into an array of file system handles that can
 * be used to derive info about those file systems.
 *
 * Note that as this function is called, we close all zhp handles that
 * are not going to be places into the cp_handles list. We don't want
 * to close the ones we are keeping, but all others would be leaked if
 * not closed here.
 */

static int
get_one_filesystem(zfs_handle_t *zhp, void *data)
{
    get_all_cbdata_t *cbp = data;
    zfs_type_t type = zfs_get_type(zhp);

    /*
     * Interate over any nested datasets.
     */
    if (type == ZFS_TYPE_FILESYSTEM &&
        zfs_iter_filesystems(zhp, get_one_filesystem, data) != 0) {
        zfs_close(zhp);
        return (1);
    }

    /*
     * Skip any datasets whose type does not match.
     */
    if ((type & cbp->cb_types) == 0) {
        zfs_close(zhp);
        return (0);
    }

    if (cbp->cb_alloc == cbp->cb_used) {
        zfs_handle_t **handles;

        if (cbp->cb_alloc == 0)
            cbp->cb_alloc = 64;
        else
            cbp->cb_alloc *= 2;

        handles = (zfs_handle_t **)calloc(1,
            cbp->cb_alloc * sizeof (void *));

        if (handles == NULL) {
            zfs_close(zhp);
            return (0);
        }
        if (cbp->cb_handles) {
            bcopy(cbp->cb_handles, handles,
                cbp->cb_used * sizeof (void *));
            free(cbp->cb_handles);
        }

        cbp->cb_handles = handles;
    }

    cbp->cb_handles[cbp->cb_used++] = zhp;

    return (0);
}

/*
 * get_all_filesystems(zfs_handle_t ***fslist, size_t *count)
 *
 * iterate through all ZFS file systems starting at the root. Returns
 * a count and an array of handle pointers. Allocating is only done
 * once. The caller does not need to free since it will be done at
 * sa_zfs_fini() time.
 */

static void
get_all_filesystems(sa_handle_impl_t impl_handle,
            zfs_handle_t ***fslist, size_t *count)
{
    get_all_cbdata_t cb = { 0 };
    cb.cb_types = ZFS_TYPE_FILESYSTEM;

    if (impl_handle->zfs_list != NULL) {
        *fslist = impl_handle->zfs_list;
        *count = impl_handle->zfs_list_count;
        return;
    }

    (void) zfs_iter_root(impl_handle->zfs_libhandle,
        get_one_filesystem, &cb);

    impl_handle->zfs_list = *fslist = cb.cb_handles;
    impl_handle->zfs_list_count = *count = cb.cb_used;
}

/*
 * mountpoint_compare(a, b)
 *
 * compares the mountpoint on two zfs file systems handles.
 * returns values following strcmp() model.
 */

static int
mountpoint_compare(const void *a, const void *b)
{
    zfs_handle_t **za = (zfs_handle_t **)a;
    zfs_handle_t **zb = (zfs_handle_t **)b;
    char mounta[MAXPATHLEN];
    char mountb[MAXPATHLEN];

    verify(zfs_prop_get(*za, ZFS_PROP_MOUNTPOINT, mounta,
        sizeof (mounta), NULL, NULL, 0, B_FALSE) == 0);
    verify(zfs_prop_get(*zb, ZFS_PROP_MOUNTPOINT, mountb,
        sizeof (mountb), NULL, NULL, 0, B_FALSE) == 0);

    return (strcmp(mounta, mountb));
}

/*
 * return legacy mountpoint.  Caller provides space for mountpoint.
 */
int
get_legacy_mountpoint(char *path, char *mountpoint, size_t len)
{
    FILE *fp;
    struct mnttab entry;

    if ((fp = fopen(MNTTAB, "r")) == NULL) {
        return (1);
    }

    while (getmntent(fp, &entry) == 0) {

        if (entry.mnt_fstype == NULL ||
            strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
            continue;

        if (strcmp(entry.mnt_mountp, path) == 0) {
            (void) strlcpy(mountpoint, entry.mnt_special, len);
            (void) fclose(fp);
            return (0);
        }
    }
    (void) fclose(fp);
    return (1);
}

/*
 * get_zfs_dataset(impl_handle, path)
 *
 * get the name of the ZFS dataset the path is equivalent to.  The
 * dataset name is used for get/set of ZFS properties since libzfs
 * requires a dataset to do a zfs_open().
 */

static char *
get_zfs_dataset(sa_handle_impl_t impl_handle, char *path,
    boolean_t search_mnttab)
{
    size_t i, count = 0;
    char *dataset = NULL;
    zfs_handle_t **zlist;
    char mountpoint[ZFS_MAXPROPLEN];
    char canmount[ZFS_MAXPROPLEN];

    get_all_filesystems(impl_handle, &zlist, &count);
    qsort(zlist, count, sizeof (void *), mountpoint_compare);
    for (i = 0; i < count; i++) {
        /* must have a mountpoint */
        if (zfs_prop_get(zlist[i], ZFS_PROP_MOUNTPOINT, mountpoint,
            sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) {
            /* no mountpoint */
            continue;
        }

        /* mountpoint must be a path */
        if (strcmp(mountpoint, ZFS_MOUNTPOINT_NONE) == 0 ||
            strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0) {
            /*
             * Search mmttab for mountpoint
             */

            if (search_mnttab == B_TRUE &&
                get_legacy_mountpoint(path, mountpoint,
                sizeof (mountpoint)) == 0) {
                dataset = mountpoint;
                break;
            }
            continue;
        }

        /* canmount must be set */
        canmount[0] = '\0';
        if (zfs_prop_get(zlist[i], ZFS_PROP_CANMOUNT, canmount,
            sizeof (canmount), NULL, NULL, 0, B_FALSE) != 0 ||
            strcmp(canmount, "off") == 0)
            continue;

        /*
         * have a mountable handle but want to skip those marked none
         * and legacy
         */
        if (strcmp(mountpoint, path) == 0) {
            dataset = (char *)zfs_get_name(zlist[i]);
            break;
        }

    }

    if (dataset != NULL)
        dataset = strdup(dataset);

    return (dataset);
}

/*
 * get_zfs_property(dataset, property)
 *
 * Get the file system property specified from the ZFS dataset.
 */

static char *
get_zfs_property(char *dataset, zfs_prop_t property)
{
    zfs_handle_t *handle = NULL;
    char shareopts[ZFS_MAXPROPLEN];
    libzfs_handle_t *libhandle;

    libhandle = libzfs_init();
    if (libhandle != NULL) {
        handle = zfs_open(libhandle, dataset, ZFS_TYPE_FILESYSTEM);
        if (handle != NULL) {
            if (zfs_prop_get(handle, property, shareopts,
                sizeof (shareopts), NULL, NULL, 0,
                B_FALSE) == 0) {
                zfs_close(handle);
                libzfs_fini(libhandle);
                return (strdup(shareopts));
            }
            zfs_close(handle);
        }
        libzfs_fini(libhandle);
    }
    return (NULL);
}

/*
 * sa_zfs_is_shared(handle, path)
 *
 * Check to see if the ZFS path provided has the sharenfs option set
 * or not.
 */

int
sa_zfs_is_shared(sa_handle_t sahandle, char *path)
{
    int ret = 0;
    char *dataset;
    zfs_handle_t *handle = NULL;
    char shareopts[ZFS_MAXPROPLEN];
    libzfs_handle_t *libhandle;

    dataset = get_zfs_dataset((sa_handle_t)sahandle, path, B_FALSE);
    if (dataset != NULL) {
        libhandle = libzfs_init();
        if (libhandle != NULL) {
            handle = zfs_open(libhandle, dataset,
                ZFS_TYPE_FILESYSTEM);
            if (handle != NULL) {
                if (zfs_prop_get(handle, ZFS_PROP_SHARENFS,
                    shareopts, sizeof (shareopts), NULL, NULL,
                    0, B_FALSE) == 0 &&
                    strcmp(shareopts, "off") != 0) {
                    ret = 1; /* it is shared */
                }
                zfs_close(handle);
            }
            libzfs_fini(libhandle);
        }
        free(dataset);
    }
    return (ret);
}

/*
 * find_or_create_group(handle, groupname, proto, *err)
 *
 * While walking the ZFS tree, we need to add shares to a defined
 * group. If the group doesn't exist, create it first, making sure it
 * is marked as a ZFS group.
 *
 * Note that all ZFS shares are in a subgroup of the top level group
 * called "zfs".
 */

static sa_group_t
find_or_create_group(sa_handle_t handle, char *groupname, char *proto, int *err)
{
    sa_group_t group;
    sa_optionset_t optionset;
    int ret = SA_OK;

    /*
     * we check to see if the "zfs" group exists. Since this
     * should be the top level group, we don't want the
     * parent. This is to make sure the zfs group has been created
     * and to created if it hasn't been.
     */
    group = sa_get_group(handle, groupname);
    if (group == NULL) {
        group = sa_create_group(handle, groupname, &ret);

        /* make sure this is flagged as a ZFS group */
        if (group != NULL)
            ret = sa_set_group_attr(group, "zfs", "true");
    }
    if (group != NULL) {
        if (proto != NULL) {
            optionset = sa_get_optionset(group, proto);
            if (optionset == NULL)
                optionset = sa_create_optionset(group, proto);
        }
    }
    if (err != NULL)
        *err = ret;
    return (group);
}

/*
 * find_or_create_zfs_subgroup(groupname, optstring, *err)
 *
 * ZFS shares will be in a subgroup of the "zfs" master group.  This
 * function looks to see if the groupname exists and returns it if it
 * does or else creates a new one with the specified name and returns
 * that.  The "zfs" group will exist before we get here, but we make
 * sure just in case.
 *
 * err must be a valid pointer.
 */

static sa_group_t
find_or_create_zfs_subgroup(sa_handle_t handle, char *groupname, char *proto,
    char *optstring, int *err)
{
    sa_group_t group = NULL;
    sa_group_t zfs;
    char *name;
    char *options;

    /* start with the top-level "zfs" group */
    zfs = sa_get_group(handle, "zfs");
    *err = SA_OK;
    if (zfs != NULL) {
        for (group = sa_get_sub_group(zfs); group != NULL;
            group = sa_get_next_group(group)) {
            name = sa_get_group_attr(group, "name");
            if (name != NULL && strcmp(name, groupname) == 0) {
                /* have the group so break out of here */
                sa_free_attr_string(name);
                break;
            }
            if (name != NULL)
                sa_free_attr_string(name);
        }

        if (group == NULL) {
            /*
             * Need to create the sub-group since it doesn't exist
             */
            group = _sa_create_zfs_group(zfs, groupname);
            if (group == NULL) {
                *err = SA_NO_MEMORY;
                return (NULL);
            }
            set_node_attr(group, "zfs", "true");
        }
        if (strcmp(optstring, "on") == 0)
            optstring = "rw";
        options = strdup(optstring);
        if (options != NULL) {
            *err = sa_parse_legacy_options(group, options,
                proto);
            /* If no optionset, add one. */
            if (sa_get_optionset(group, proto) == NULL)
                (void) sa_create_optionset(group, proto);
            free(options);
        } else {
            *err = SA_NO_MEMORY;
        }
    }
    return (group);
}

/*
 * zfs_construct_resource(share, name, base, dataset)
 *
 * Add a resource to the share using name as a template. If name ==
 * NULL, then construct a name based on the dataset value.
 * name.
 */
static void
zfs_construct_resource(sa_share_t share, char *dataset)
{
    char buff[SA_MAX_RESOURCE_NAME + 1];
    int ret = SA_OK;

    (void) snprintf(buff, SA_MAX_RESOURCE_NAME, "%s", dataset);
    sa_fix_resource_name(buff);
    (void) sa_add_resource(share, buff, SA_SHARE_TRANSIENT, &ret);
}

/*
 * zfs_inherited(handle, source, sourcestr)
 *
 * handle case of inherited share{nfs,smb}. Pulled out of sa_get_zfs_shares
 * for readability.
 */
static int
zfs_inherited(sa_handle_t handle, sa_share_t share, char *sourcestr,
    char *shareopts, char *mountpoint, char *proto, char *dataset)
{
    int doshopt = 0;
    int err = SA_OK;
    sa_group_t group;
    sa_resource_t resource;
    uint64_t features;

    /*
     * Need to find the "real" parent sub-group. It may not be
     * mounted, but it was identified in the "sourcestr"
     * variable. The real parent not mounted can occur if
     * "canmount=off and sharenfs=on".
     */
    group = find_or_create_zfs_subgroup(handle, sourcestr, proto,
        shareopts, &doshopt);
    if (group != NULL) {
        /*
         * We may need the first share for resource
         * prototype. We only care about it if it has a
         * resource that sets a prefix value.
         */
        if (share == NULL)
            share = _sa_add_share(group, mountpoint,
                SA_SHARE_TRANSIENT, &err,
                (uint64_t)SA_FEATURE_NONE);
        /*
         * some options may only be on shares. If the opt
         * string contains one of those, we put it just on the
         * share.
         */
        if (share != NULL && doshopt == SA_PROP_SHARE_ONLY) {
            char *options;
            options = strdup(shareopts);
            if (options != NULL) {
                set_node_attr(share, "dataset", dataset);
                err = sa_parse_legacy_options(share, options,
                    proto);
                set_node_attr(share, "dataset", NULL);
                free(options);
            }
            if (sa_get_optionset(group, proto) == NULL)
                (void) sa_create_optionset(group, proto);
        }
        features = sa_proto_get_featureset(proto);
        if (share != NULL && features & SA_FEATURE_RESOURCE) {
            /*
             * We have a share and the protocol requires
             * that at least one resource exist (probably
             * SMB). We need to make sure that there is at
             * least one.
             */
            resource = sa_get_share_resource(share, NULL);
            if (resource == NULL) {
                zfs_construct_resource(share, dataset);
            }
        }
    } else {
        err = SA_NO_MEMORY;
    }
    return (err);
}

/*
 * zfs_notinherited(group, share, mountpoint, shareopts, proto, dataset,
 *     grouperr)
 *
 * handle case where this is the top of a sub-group in ZFS. Pulled out
 * of sa_get_zfs_shares for readability. We need the grouperr from the
 * creation of the subgroup to know whether to add the public
 * property, etc. to the specific share.
 */
static int
zfs_notinherited(sa_group_t group, sa_share_t share, char *mountpoint,
    char *shareopts, char *proto, char *dataset, int grouperr)
{
    int err = SA_OK;
    sa_resource_t resource;
    uint64_t features;

    set_node_attr(group, "zfs", "true");
    if (share == NULL)
        share = _sa_add_share(group, mountpoint, SA_SHARE_TRANSIENT,
            &err, (uint64_t)SA_FEATURE_NONE);

    if (err != SA_OK)
        return (err);

    if (strcmp(shareopts, "on") == 0)
        shareopts = "";
    if (shareopts != NULL) {
        char *options;
        if (grouperr == SA_PROP_SHARE_ONLY) {
            /*
             * Some properties may only be on shares, but
             * due to the ZFS sub-groups being artificial,
             * we sometimes get this and have to deal with
             * it. We do it by attempting to put it on the
             * share.
             */
            options = strdup(shareopts);
            if (options != NULL) {
                err = sa_parse_legacy_options(share,
                    options, proto);
                free(options);
            }
        }
        /* Unmark the share's changed state */
        set_node_attr(share, "changed", NULL);
    }
    features = sa_proto_get_featureset(proto);
    if (share != NULL && features & SA_FEATURE_RESOURCE) {
        /*
         * We have a share and the protocol requires that at
         * least one resource exist (probably SMB). We need to
         * make sure that there is at least one.
         */
        resource = sa_get_share_resource(share, NULL);
        if (resource == NULL) {
            zfs_construct_resource(share, dataset);
        }
    }
    return (err);
}

/*
 * zfs_grp_error(err)
 *
 * Print group create error, but only once. If err is 0 do the
 * print else don't.
 */

static void
zfs_grp_error(int err)
{
    if (err == 0) {
        /* only print error once */
        (void) fprintf(stderr, dgettext(TEXT_DOMAIN,
            "Cannot create ZFS subgroup during initialization:"
            " %s\n"), sa_errorstr(SA_SYSTEM_ERR));
    }
}

/*
 * zfs_process_share(handle, share, mountpoint, proto, source,
 *     shareopts, sourcestr)
 *
 * Creates the subgroup, if necessary and adds shares, resources
 * and properties.
 */
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)
{
    int err = SA_OK;

    if (source & ZPROP_SRC_INHERITED) {
        err = zfs_inherited(handle, share, sourcestr, shareopts,
            mountpoint, proto, dataset);
    } else {
        group = find_or_create_zfs_subgroup(handle, dataset, proto,
            shareopts, &err);
        if (group == NULL) {
            static boolean_t reported_error = B_FALSE;
            /*
             * There is a problem, but we can't do
             * anything about it at this point so we issue
             * a warning and move on.
             */
            zfs_grp_error(reported_error);
            reported_error = B_TRUE;
        }
        set_node_attr(group, "zfs", "true");
        /*
         * Add share with local opts via zfs_notinherited.
         */
        err = zfs_notinherited(group, share, mountpoint, shareopts,
            proto, dataset, err);
    }
    return (err);
}

/*
 * sa_get_zfs_shares(handle, groupname)
 *
 * Walk the mnttab for all zfs mounts and determine which are
 * shared. Find or create the appropriate group/sub-group to contain
 * the shares.
 *
 * All shares are in a sub-group that will hold the properties. This
 * allows representing the inherited property model.
 *
 * One area of complication is if "sharenfs" is set at one level of
 * the directory tree and "sharesmb" is set at a different level, the
 * a sub-group must be formed at the lower level for both
 * protocols. That is the nature of the problem in CR 6667349.
 */

int
sa_get_zfs_shares(sa_handle_t handle, char *groupname)
{
    sa_group_t zfsgroup;
    boolean_t nfs;
    boolean_t nfs_inherited;
    boolean_t smb;
    boolean_t smb_inherited;
    zfs_handle_t **zlist;
    char nfsshareopts[ZFS_MAXPROPLEN];
    char smbshareopts[ZFS_MAXPROPLEN];
    sa_share_t share;
    zprop_source_t source;
    char nfssourcestr[ZFS_MAXPROPLEN];
    char smbsourcestr[ZFS_MAXPROPLEN];
    char mountpoint[ZFS_MAXPROPLEN];
    size_t count = 0, i;
    libzfs_handle_t *zfs_libhandle;
    int err = SA_OK;

    /*
     * If we can't access libzfs, don't bother doing anything.
     */
    zfs_libhandle = ((sa_handle_impl_t)handle)->zfs_libhandle;
    if (zfs_libhandle == NULL)
        return (SA_SYSTEM_ERR);

    zfsgroup = find_or_create_group(handle, groupname, NULL, &err);
    /* Not an error, this could be a legacy condition */
    if (zfsgroup == NULL)
        return (SA_OK);

    /*
     * need to walk the mounted ZFS pools and datasets to
     * find shares that are possible.
     */
    get_all_filesystems((sa_handle_impl_t)handle, &zlist, &count);
    qsort(zlist, count, sizeof (void *), mountpoint_compare);

    for (i = 0; i < count; i++) {
        char *dataset;

        source = ZPROP_SRC_ALL;
        /* If no mountpoint, skip. */
        if (zfs_prop_get(zlist[i], ZFS_PROP_MOUNTPOINT,
            mountpoint, sizeof (mountpoint), NULL, NULL, 0,
            B_FALSE) != 0)
            continue;

        /*
         * zfs_get_name value must not be freed. It is just a
         * pointer to a value in the handle.
         */
        if ((dataset = (char *)zfs_get_name(zlist[i])) == NULL)
            continue;

        /*
         * only deal with "mounted" file systems since
         * unmounted file systems can't actually be shared.
         */

        if (!zfs_is_mounted(zlist[i], NULL))
            continue;

        nfs = nfs_inherited = B_FALSE;

        if (zfs_prop_get(zlist[i], ZFS_PROP_SHARENFS, nfsshareopts,
            sizeof (nfsshareopts), &source, nfssourcestr,
            ZFS_MAXPROPLEN, B_FALSE) == 0 &&
            strcmp(nfsshareopts, "off") != 0) {
            if (source & ZPROP_SRC_INHERITED)
                nfs_inherited = B_TRUE;
            else
                nfs = B_TRUE;
        }

        smb = smb_inherited = B_FALSE;
        if (zfs_prop_get(zlist[i], ZFS_PROP_SHARESMB, smbshareopts,
            sizeof (smbshareopts), &source, smbsourcestr,
            ZFS_MAXPROPLEN, B_FALSE) == 0 &&
            strcmp(smbshareopts, "off") != 0) {
            if (source & ZPROP_SRC_INHERITED)
                smb_inherited = B_TRUE;
            else
                smb = B_TRUE;
        }

        /*
         * If the mountpoint is already shared, it must be a
         * non-ZFS share. We want to remove the share from its
         * parent group and reshare it under ZFS.
         */
        share = sa_find_share(handle, mountpoint);
        if (share != NULL &&
            (nfs || smb || nfs_inherited || smb_inherited)) {
            err = sa_remove_share(share);
            share = NULL;
        }

        /*
         * At this point, we have the information needed to
         * determine what to do with the share.
         *
         * If smb or nfs is set, we have a new sub-group.
         * If smb_inherit and/or nfs_inherit is set, then
         * place on an existing sub-group. If both are set,
         * the existing sub-group is the closest up the tree.
         */
        if (nfs || smb) {
            /*
             * Non-inherited is the straightforward
             * case. sa_zfs_process_share handles it
             * directly. Make sure that if the "other"
             * protocol is inherited, that we treat it as
             * non-inherited as well.
             */
            if (nfs || nfs_inherited) {
                err = sa_zfs_process_share(handle, zfsgroup,
                    share, mountpoint, "nfs",
                    0, nfsshareopts,
                    nfssourcestr, dataset);
                share = sa_find_share(handle, mountpoint);
            }
            if (smb || smb_inherited) {
                err = sa_zfs_process_share(handle, zfsgroup,
                    share, mountpoint, "smb",
                    0, smbshareopts,
                    smbsourcestr, dataset);
            }
        } else if (nfs_inherited || smb_inherited) {
            char *grpdataset;
            /*
             * If we only have inherited groups, it is
             * important to find the closer of the two if
             * the protocols are set at different
             * levels. The closest sub-group is the one we
             * want to work with.
             */
            if (nfs_inherited && smb_inherited) {
                if (strcmp(nfssourcestr, smbsourcestr) <= 0)
                    grpdataset = nfssourcestr;
                else
                    grpdataset = smbsourcestr;
            } else if (nfs_inherited) {
                grpdataset = nfssourcestr;
            } else if (smb_inherited) {
                grpdataset = smbsourcestr;
            }
            if (nfs_inherited) {
                err = sa_zfs_process_share(handle, zfsgroup,
                    share, mountpoint, "nfs",
                    ZPROP_SRC_INHERITED, nfsshareopts,
                    grpdataset, dataset);
                share = sa_find_share(handle, mountpoint);
            }
            if (smb_inherited) {
                err = sa_zfs_process_share(handle, zfsgroup,
                    share, mountpoint, "smb",
                    ZPROP_SRC_INHERITED, smbshareopts,
                    grpdataset, dataset);
            }
        }
    }
    /*
     * Don't need to free the "zlist" variable since it is only a
     * pointer to a cached value that will be freed when
     * sa_fini() is called.
     */
    return (err);
}

#define COMMAND     "/usr/sbin/zfs"

/*
 * sa_zfs_set_sharenfs(group, path, on)
 *
 * Update the "sharenfs" property on the path. If on is true, then set
 * to the properties on the group or "on" if no properties are
 * defined. Set to "off" if on is false.
 */

int
sa_zfs_set_sharenfs(sa_group_t group, char *path, int on)
{
    int ret = SA_NOT_IMPLEMENTED;
    char *command;

    command = malloc(ZFS_MAXPROPLEN * 2);
    if (command != NULL) {
        char *opts = NULL;
        char *dataset = NULL;
        FILE *pfile;
        sa_handle_impl_t impl_handle;
        /* for now, NFS is always available for "zfs" */
        if (on) {
            opts = sa_proto_legacy_format("nfs", group, 1);
            if (opts != NULL && strlen(opts) == 0) {
                free(opts);
                opts = strdup("on");
            }
        }

        impl_handle = (sa_handle_impl_t)sa_find_group_handle(group);
        assert(impl_handle != NULL);
        if (impl_handle != NULL)
            dataset = get_zfs_dataset(impl_handle, path, B_FALSE);
        else
            ret = SA_SYSTEM_ERR;

        if (dataset != NULL) {
            (void) snprintf(command, ZFS_MAXPROPLEN * 2,
                "%s set sharenfs=\"%s\" %s", COMMAND,
                opts != NULL ? opts : "off", dataset);
            pfile = popen(command, "r");
            if (pfile != NULL) {
                ret = pclose(pfile);
                if (ret != 0)
                    ret = SA_SYSTEM_ERR;
            }
        }
        if (opts != NULL)
            free(opts);
        if (dataset != NULL)
            free(dataset);
        free(command);
    }
    return (ret);
}

/*
 * add_resources(share, opt)
 *
 * Add resource properties to those in "opt".  Resources are prefixed
 * with name=resourcename.
 */
static char *
add_resources(sa_share_t share, char *opt)
{
    char *newopt = NULL;
    char *propstr;
    sa_resource_t resource;

    newopt = strdup(opt);
    if (newopt == NULL)
        return (newopt);

    for (resource = sa_get_share_resource(share, NULL);
        resource != NULL;
        resource = sa_get_next_resource(resource)) {
        char *name;
        size_t size;

        name = sa_get_resource_attr(resource, "name");
        if (name == NULL) {
            free(newopt);
            return (NULL);
        }
        size = strlen(name) + strlen(opt) + sizeof ("name=") + 1;
        newopt = calloc(1, size);
        if (newopt != NULL)
            (void) snprintf(newopt, size, "%s,name=%s", opt, name);
        free(opt);
        opt = newopt;
        propstr = sa_proto_legacy_format("smb", resource, 0);
        if (propstr == NULL) {
            free(opt);
            return (NULL);
        }
        size = strlen(propstr) + strlen(opt) + 2;
        newopt = calloc(1, size);
        if (newopt != NULL)
            (void) snprintf(newopt, size, "%s,%s", opt, propstr);
        free(opt);
        opt = newopt;
    }
    return (opt);
}

/*
 * sa_zfs_set_sharesmb(group, path, on)
 *
 * Update the "sharesmb" property on the path. If on is true, then set
 * to the properties on the group or "on" if no properties are
 * defined. Set to "off" if on is false.
 */

int
sa_zfs_set_sharesmb(sa_group_t group, char *path, int on)
{
    int ret = SA_NOT_IMPLEMENTED;
    char *command;
    sa_share_t share;

    /* In case SMB not enabled */
    if (sa_get_optionset(group, "smb") == NULL)
        return (SA_NOT_SUPPORTED);

    command = malloc(ZFS_MAXPROPLEN * 2);
    if (command != NULL) {
        char *opts = NULL;
        char *dataset = NULL;
        FILE *pfile;
        sa_handle_impl_t impl_handle;

        if (on) {
            char *newopt;

            share = sa_get_share(group, NULL);
            opts = sa_proto_legacy_format("smb", share, 1);
            if (opts != NULL && strlen(opts) == 0) {
                free(opts);
                opts = strdup("on");
            }
            newopt = add_resources(opts, share);
            free(opts);
            opts = newopt;
        }

        impl_handle = (sa_handle_impl_t)sa_find_group_handle(group);
        assert(impl_handle != NULL);
        if (impl_handle != NULL)
            dataset = get_zfs_dataset(impl_handle, path, B_FALSE);
        else
            ret = SA_SYSTEM_ERR;

        if (dataset != NULL) {
            (void) snprintf(command, ZFS_MAXPROPLEN * 2,
                "echo %s set sharesmb=\"%s\" %s", COMMAND,
                opts != NULL ? opts : "off", dataset);
            pfile = popen(command, "r");
            if (pfile != NULL) {
                ret = pclose(pfile);
                if (ret != 0)
                    ret = SA_SYSTEM_ERR;
            }
        }
        if (opts != NULL)
            free(opts);
        if (dataset != NULL)
            free(dataset);
        free(command);
    }
    return (ret);
}

/*
 * sa_zfs_update(group)
 *
 * call back to ZFS to update the share if necessary.
 * Don't do it if it isn't a real change.
 */
int
sa_zfs_update(sa_group_t group)
{
    sa_optionset_t protopt;
    sa_group_t parent;
    char *command;
    char *optstring;
    int ret = SA_OK;
    int doupdate = 0;
    FILE *pfile;

    if (sa_is_share(group))
        parent = sa_get_parent_group(group);
    else
        parent = group;

    if (parent != NULL) {
        command = malloc(ZFS_MAXPROPLEN * 2);
        if (command == NULL)
            return (SA_NO_MEMORY);

        *command = '\0';
        for (protopt = sa_get_optionset(parent, NULL); protopt != NULL;
            protopt = sa_get_next_optionset(protopt)) {

            char *proto = sa_get_optionset_attr(protopt, "type");
            char *path;
            char *dataset = NULL;
            char *zfsopts = NULL;

            if (sa_is_share(group)) {
                path = sa_get_share_attr((sa_share_t)group,
                    "path");
                if (path != NULL) {
                    sa_handle_impl_t impl_handle;

                    impl_handle = sa_find_group_handle(
                        group);
                    if (impl_handle != NULL)
                        dataset = get_zfs_dataset(
                            impl_handle, path, B_FALSE);
                    else
                        ret = SA_SYSTEM_ERR;

                    sa_free_attr_string(path);
                }
            } else {
                dataset = sa_get_group_attr(group, "name");
            }
            /* update only when there is an optstring found */
            doupdate = 0;
            if (proto != NULL && dataset != NULL) {
                optstring = sa_proto_legacy_format(proto,
                    group, 1);
                zfsopts = get_zfs_property(dataset,
                    ZFS_PROP_SHARENFS);

                if (optstring != NULL && zfsopts != NULL) {
                    if (strcmp(optstring, zfsopts) != 0)
                        doupdate++;
                }
                if (doupdate) {
                    if (optstring != NULL &&
                        strlen(optstring) > 0) {
                        (void) snprintf(command,
                            ZFS_MAXPROPLEN * 2,
                            "%s set sharenfs=%s %s",
                            COMMAND,
                            optstring, dataset);
                    } else {
                        (void) snprintf(command,
                            ZFS_MAXPROPLEN * 2,
                            "%s set sharenfs=on %s",
                            COMMAND,
                            dataset);
                    }
                    pfile = popen(command, "r");
                    if (pfile != NULL)
                        ret = pclose(pfile);
                    switch (ret) {
                    default:
                    case 1:
                        ret = SA_SYSTEM_ERR;
                        break;
                    case 2:
                        ret = SA_SYNTAX_ERR;
                        break;
                    case 0:
                        break;
                    }
                }
                if (optstring != NULL)
                    free(optstring);
                if (zfsopts != NULL)
                    free(zfsopts);
            }
            if (proto != NULL)
                sa_free_attr_string(proto);
            if (dataset != NULL)
                free(dataset);
        }
        free(command);
    }
    return (ret);
}

/*
 * sa_group_is_zfs(group)
 *
 * Given the group, determine if the zfs attribute is set.
 */

int
sa_group_is_zfs(sa_group_t group)
{
    char *zfs;
    int ret = 0;

    zfs = sa_get_group_attr(group, "zfs");
    if (zfs != NULL) {
        ret = 1;
        sa_free_attr_string(zfs);
    }
    return (ret);
}

/*
 * sa_path_is_zfs(path)
 *
 * Check to see if the file system path represents is of type "zfs".
 */

int
sa_path_is_zfs(char *path)
{
    char *fstype;
    int ret = 0;

    fstype = sa_fstype(path);
    if (fstype != NULL && strcmp(fstype, "zfs") == 0)
        ret = 1;
    if (fstype != NULL)
        sa_free_fstype(fstype);
    return (ret);
}

int
sa_sharetab_fill_zfs(sa_share_t share, share_t *sh, char *proto)
{
    char *path;

    /* Make sure path is valid */

    path = sa_get_share_attr(share, "path");
    if (path != NULL) {
        (void) memset(sh, 0, sizeof (sh));
        (void) sa_fillshare(share, proto, sh);
        sa_free_attr_string(path);
        return (0);
    } else
        return (1);
}

#define SMAX(i, j)  \
    if ((j) > (i)) { \
        (i) = (j); \
    }

int
sa_share_zfs(sa_share_t share, char *path, share_t *sh,
    void *exportdata, zfs_share_op_t operation)
{
    libzfs_handle_t *libhandle;
    sa_group_t group;
    sa_handle_t sahandle;
    char *dataset;
    int err = EINVAL;
    int i, j;
    char newpath[MAXPATHLEN];
    char *pathp;

    /*
     * First find the dataset name
     */
    if ((group = sa_get_parent_group(share)) == NULL)  {
        return (SA_SYSTEM_ERR);
    }
    if ((sahandle = sa_find_group_handle(group)) == NULL) {
        return (SA_SYSTEM_ERR);
    }

    /*
     * If get_zfs_dataset fails, see if it is a subdirectory
     */

    pathp = path;
    while ((dataset = get_zfs_dataset(sahandle, pathp, B_TRUE)) == NULL) {
        char *p;

        if (pathp == path) {
            (void) strlcpy(newpath, path, sizeof (newpath));
            pathp = newpath;
        }

        /*
         * chop off part of path, but if we are at root then
         * make sure path is a /
         */
        if ((strlen(pathp) > 1) && (p = strrchr(pathp, '/'))) {
            if (pathp == p) {
                *(p + 1) = '\0';  /* skip over /, root case */
            } else {
                *p = '\0';
            }
        } else {
            return (SA_SYSTEM_ERR);
        }
    }

    libhandle = libzfs_init();
    if (libhandle != NULL) {

        i = (sh->sh_path ? strlen(sh->sh_path) : 0);
        sh->sh_size = i;

        j = (sh->sh_res ? strlen(sh->sh_res) : 0);
        sh->sh_size += j;
        SMAX(i, j);

        j = (sh->sh_fstype ? strlen(sh->sh_fstype) : 0);
        sh->sh_size += j;
        SMAX(i, j);

        j = (sh->sh_opts ? strlen(sh->sh_opts) : 0);
        sh->sh_size += j;
        SMAX(i, j);

        j = (sh->sh_descr ? strlen(sh->sh_descr) : 0);
        sh->sh_size += j;
        SMAX(i, j);
        err = zfs_deleg_share_nfs(libhandle, dataset, path,
            exportdata, sh, i, operation);
        if (err == SA_OK)
            sa_update_sharetab_ts(sahandle);
        libzfs_fini(libhandle);
    }
    free(dataset);
    return (err);
}

/*
 * sa_get_zfs_handle(handle)
 *
 * Given an sa_handle_t, return the libzfs_handle_t *. This is only
 * used internally by libzfs. Needed in order to avoid including
 * libshare_impl.h in libzfs.
 */

libzfs_handle_t *
sa_get_zfs_handle(sa_handle_t handle)
{
    sa_handle_impl_t implhandle = (sa_handle_impl_t)handle;

    return (implhandle->zfs_libhandle);
}