8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / lib / libshare / common / scfutil.c

/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/* helper functions for using libscf with sharemgr */

#include <libscf.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include "libshare.h"
#include "libshare_impl.h"
#include "scfutil.h"
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <uuid/uuid.h>
#include <sys/param.h>
#include <signal.h>
#include <sys/time.h>
#include <libintl.h>

ssize_t scf_max_name_len;
extern struct sa_proto_plugin *sap_proto_list;
extern sa_handle_impl_t get_handle_for_root(xmlNodePtr);
static void set_transaction_tstamp(sa_handle_impl_t);
/*
 * The SMF facility uses some properties that must exist. We want to
 * skip over these when processing protocol options.
 */
static char *skip_props[] = {
        "modify_authorization",
        "action_authorization",
        "value_authorization",
        NULL
};

/*
 * sa_scf_fini(handle)
 *
 * Must be called when done. Called with the handle allocated in
 * sa_scf_init(), it cleans up the state and frees any SCF resources
 * still in use. Called by sa_fini().
 */

void
sa_scf_fini(scfutilhandle_t *handle)
{
        if (handle != NULL) {
                int unbind = 0;
                if (handle->scope != NULL) {
                        unbind = 1;
                        scf_scope_destroy(handle->scope);
                }
                if (handle->instance != NULL)
                        scf_instance_destroy(handle->instance);
                if (handle->service != NULL)
                        scf_service_destroy(handle->service);
                if (handle->pg != NULL)
                        scf_pg_destroy(handle->pg);
                if (handle->handle != NULL) {
                        handle->scf_state = SCH_STATE_UNINIT;
                        if (unbind)
                                (void) scf_handle_unbind(handle->handle);
                        scf_handle_destroy(handle->handle);
                }
                free(handle);
        }
}

/*
 * sa_scf_init()
 *
 * Must be called before using any of the SCF functions. Called by
 * sa_init() during the API setup.
 */

scfutilhandle_t *
sa_scf_init(sa_handle_impl_t ihandle)
{
        scfutilhandle_t *handle;

        scf_max_name_len = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH);
        if (scf_max_name_len <= 0)
                scf_max_name_len = SA_MAX_NAME_LEN + 1;

        handle = calloc(1, sizeof (scfutilhandle_t));
        if (handle == NULL)
                return (handle);

        ihandle->scfhandle = handle;
        handle->scf_state = SCH_STATE_INITIALIZING;
        handle->handle = scf_handle_create(SCF_VERSION);
        if (handle->handle == NULL) {
                free(handle);
                handle = NULL;
                (void) printf("libshare could not access SMF repository: %s\n",
                    scf_strerror(scf_error()));
                return (handle);
        }
        if (scf_handle_bind(handle->handle) != 0)
                goto err;

        handle->scope = scf_scope_create(handle->handle);
        handle->service = scf_service_create(handle->handle);
        handle->pg = scf_pg_create(handle->handle);

        /* Make sure we have sufficient SMF running */
        handle->instance = scf_instance_create(handle->handle);
        if (handle->scope == NULL || handle->service == NULL ||
            handle->pg == NULL || handle->instance == NULL)
                goto err;
        if (scf_handle_get_scope(handle->handle,
            SCF_SCOPE_LOCAL, handle->scope) != 0)
                goto err;
        if (scf_scope_get_service(handle->scope,
            SA_GROUP_SVC_NAME, handle->service) != 0)
                goto err;

        handle->scf_state = SCH_STATE_INIT;
        if (sa_get_instance(handle, "default") != SA_OK) {
                sa_group_t defgrp;
                defgrp = sa_create_group((sa_handle_t)ihandle, "default", NULL);
                /* Only NFS enabled for "default" group. */
                if (defgrp != NULL)
                        (void) sa_create_optionset(defgrp, "nfs");
        }

        return (handle);

        /* Error handling/unwinding */
err:
        (void) sa_scf_fini(handle);
        (void) printf("libshare SMF initialization problem: %s\n",
            scf_strerror(scf_error()));
        return (NULL);
}

/*
 * get_scf_limit(name)
 *
 * Since we use  scf_limit a lot and do the same  check and return the
 * same  value  if  it  fails,   implement  as  a  function  for  code
 * simplification.  Basically, if  name isn't found, return MAXPATHLEN
 * (1024) so we have a reasonable default buffer size.
 */
static ssize_t
get_scf_limit(uint32_t name)
{
        ssize_t vallen;

        vallen = scf_limit(name);
        if (vallen == (ssize_t)-1)
                vallen = MAXPATHLEN;
        return (vallen);
}

/*
 * skip_property(name)
 *
 * Internal function to check to see if a property is an SMF magic
 * property that needs to be skipped.
 */
static int
skip_property(char *name)
{
        int i;

        for (i = 0; skip_props[i] != NULL; i++)
                if (strcmp(name, skip_props[i]) == 0)
                return (1);
        return (0);
}

/*
 * generate_unique_sharename(sharename)
 *
 * Shares are represented in SMF as property groups. Due to share
 * paths containing characters that are not allowed in SMF names and
 * the need to be unique, we use UUIDs to construct a unique name.
 */

static void
generate_unique_sharename(char *sharename)
{
        uuid_t uuid;

        uuid_generate(uuid);
        (void) strcpy(sharename, "S-");
        uuid_unparse(uuid, sharename + 2);
}

/*
 * valid_protocol(proto)
 *
 * Check to see if the specified protocol is a valid one for the
 * general sharemgr facility. We determine this by checking which
 * plugin protocols were found.
 */

static int
valid_protocol(char *proto)
{
        struct sa_proto_plugin *plugin;
        for (plugin = sap_proto_list; plugin != NULL;
            plugin = plugin->plugin_next)
                if (strcmp(proto, plugin->plugin_ops->sa_protocol) == 0)
                        return (1);
        return (0);
}

/*
 * sa_extract_pgroup(root, handle, pg, nodetype, proto, sectype)
 *
 * Extract the name property group and create the specified type of
 * node on the provided group.  type will be optionset or security.
 */

static int
sa_extract_pgroup(xmlNodePtr root, scfutilhandle_t *handle,
                        scf_propertygroup_t *pg,
                        char *nodetype, char *proto, char *sectype)
{
        xmlNodePtr node;
        scf_iter_t *iter;
        scf_property_t *prop;
        scf_value_t *value;
        char *name;
        char *valuestr;
        ssize_t vallen;
        int ret = SA_OK;

        vallen = get_scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH);

        node = xmlNewChild(root, NULL, (xmlChar *)nodetype, NULL);
        if (node == NULL)
                return (ret);

        if (proto != NULL)
                (void) xmlSetProp(node, (xmlChar *)"type", (xmlChar *)proto);
        if (sectype != NULL)
                (void) xmlSetProp(node, (xmlChar *)"sectype",
                    (xmlChar *)sectype);
        /*
         * Have node to work with so iterate over the properties
         * in the pg and create option sub nodes.
         */
        iter = scf_iter_create(handle->handle);
        value = scf_value_create(handle->handle);
        prop = scf_property_create(handle->handle);
        name = malloc(scf_max_name_len);
        valuestr = malloc(vallen);
        /*
         * Want to iterate through the properties and add them
         * to the base optionset.
         */
        if (iter == NULL || value == NULL || prop == NULL ||
            valuestr == NULL || name == NULL) {
                ret = SA_NO_MEMORY;
                goto out;
        }
        if (scf_iter_pg_properties(iter, pg) == 0) {
                /* Now iterate the properties in the group */
                while (scf_iter_next_property(iter, prop) > 0) {
                        /* have a property */
                        if (scf_property_get_name(prop, name,
                            scf_max_name_len) > 0) {
                                sa_property_t saprop;
                                /* Some properties are part of the framework */
                                if (skip_property(name))
                                        continue;
                                if (scf_property_get_value(prop, value) != 0)
                                        continue;
                                if (scf_value_get_astring(value, valuestr,
                                    vallen) < 0)
                                        continue;
                                saprop = sa_create_property(name, valuestr);
                                if (saprop != NULL) {
                                        /*
                                         * Since in SMF, don't
                                         * recurse. Use xmlAddChild
                                         * directly, instead.
                                         */
                                        (void) xmlAddChild(node,
                                            (xmlNodePtr) saprop);
                                }
                        }
                }
        }
out:
        /* cleanup to avoid memory leaks */
        if (value != NULL)
                scf_value_destroy(value);
        if (iter != NULL)
                scf_iter_destroy(iter);
        if (prop != NULL)
                scf_property_destroy(prop);
        if (name != NULL)
                free(name);
        if (valuestr != NULL)
                free(valuestr);

        return (ret);
}

/*
 * sa_extract_attrs(root, handle, instance)
 *
 * Local function to extract the actual attributes/properties from the
 * property group of the service instance. These are the well known
 * attributes of "state" and "zfs". If additional attributes are
 * added, they should be added here.
 */

static void
sa_extract_attrs(xmlNodePtr root, scfutilhandle_t *handle,
                    scf_instance_t *instance)
{
        scf_property_t *prop;
        scf_value_t *value;
        char *valuestr;
        ssize_t vallen;

        vallen = get_scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH);
        prop = scf_property_create(handle->handle);
        value = scf_value_create(handle->handle);
        valuestr = malloc(vallen);
        if (prop == NULL || value == NULL || valuestr == NULL ||
            scf_instance_get_pg(instance, "operation", handle->pg) != 0) {
                goto out;
        }
        /*
         * Have a property group with desired name so now get
         * the known attributes.
         */
        if (scf_pg_get_property(handle->pg, "state", prop) == 0) {
                /* Found the property so get the value */
                if (scf_property_get_value(prop, value) == 0) {
                        if (scf_value_get_astring(value, valuestr,
                            vallen) >= 0) {
                                (void) xmlSetProp(root, (xmlChar *)"state",
                                    (xmlChar *)valuestr);
                        }
                }
        }
        if (scf_pg_get_property(handle->pg, "zfs", prop) == 0) {
                /* Found the property so get the value */
                if (scf_property_get_value(prop, value) == 0) {
                        if (scf_value_get_astring(value, valuestr,
                            vallen) > 0) {
                                (void) xmlSetProp(root, (xmlChar *)"zfs",
                                    (xmlChar *)valuestr);
                        }
                }
        }
out:
        if (valuestr != NULL)
                free(valuestr);
        if (value != NULL)
                scf_value_destroy(value);
        if (prop != NULL)
                scf_property_destroy(prop);
}

/*
 * List of known share attributes.
 */

static char *share_attr[] = {
        "path",
        "id",
        "drive-letter",
        "exclude",
        NULL,
};

static int
is_share_attr(char *name)
{
        int i;
        for (i = 0; share_attr[i] != NULL; i++)
                if (strcmp(name, share_attr[i]) == 0)
                        return (1);
        return (0);
}

/*
 * _sa_make_resource(node, valuestr)
 *
 * Make a resource node on the share node. The valusestr will either
 * be old format (SMF acceptable string) or new format (pretty much an
 * arbitrary string with "nnn:" prefixing in order to persist
 * mapping). The input valuestr will get modified in place. This is
 * only used in SMF repository parsing. A possible third field will be
 * a "description" string.
 */

static void
_sa_make_resource(xmlNodePtr node, char *valuestr)
{
        char *idx;
        char *name;
        char *description = NULL;

        idx = valuestr;
        name = strchr(valuestr, ':');
        if (name == NULL) {
                /* this is old form so give an index of "0" */
                idx = "0";
                name = valuestr;
        } else {
                /* NUL the ':' and move past it */
                *name++ = '\0';
                /* There could also be a description string */
                description = strchr(name, ':');
                if (description != NULL)
                        *description++ = '\0';
        }
        node = xmlNewChild(node, NULL, (xmlChar *)"resource", NULL);
        if (node != NULL) {
                (void) xmlSetProp(node, (xmlChar *)"name", (xmlChar *)name);
                (void) xmlSetProp(node, (xmlChar *)"id", (xmlChar *)idx);
                /* SMF values are always persistent */
                (void) xmlSetProp(node, (xmlChar *)"type",
                    (xmlChar *)"persist");
                if (description != NULL && strlen(description) > 0) {
                        (void) xmlNewChild(node, NULL, (xmlChar *)"description",
                            (xmlChar *)description);
                }
        }
}


/*
 * sa_share_from_pgroup
 *
 * Extract the share definition from the share property group. We do
 * some sanity checking to avoid bad data.
 *
 * Since this is only constructing the internal data structures, we
 * don't use the sa_* functions most of the time.
 */
void
sa_share_from_pgroup(xmlNodePtr root, scfutilhandle_t *handle,
                        scf_propertygroup_t *pg, char *id)
{
        xmlNodePtr node;
        char *name;
        scf_iter_t *iter;
        scf_property_t *prop;
        scf_value_t *value;
        ssize_t vallen;
        char *valuestr;
        int ret = SA_OK;
        int have_path = 0;

        /*
         * While preliminary check (starts with 'S') passed before
         * getting here. Need to make sure it is in ID syntax
         * (Snnnnnn). Note that shares with properties have similar
         * pgroups.
         */
        vallen = strlen(id);
        if (*id == SA_SHARE_PG_PREFIX[0] && vallen == SA_SHARE_PG_LEN) {
                uuid_t uuid;
                if (strncmp(id, SA_SHARE_PG_PREFIX,
                    SA_SHARE_PG_PREFIXLEN) != 0 ||
                    uuid_parse(id + 2, uuid) < 0)
                        return;
        } else {
                return;
        }

        vallen = get_scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH);

        iter = scf_iter_create(handle->handle);
        value = scf_value_create(handle->handle);
        prop = scf_property_create(handle->handle);
        name = malloc(scf_max_name_len);
        valuestr = malloc(vallen);

        /*
         * Construct the share XML node. It is similar to sa_add_share
         * but never changes the repository. Also, there won't be any
         * ZFS or transient shares.  Root will be the group it is
         * associated with.
         */
        node = xmlNewChild(root, NULL, (xmlChar *)"share", NULL);
        if (node != NULL) {
                /*
                 * Make sure the UUID part of the property group is
                 * stored in the share "id" property. We use this
                 * later.
                 */
                (void) xmlSetProp(node, (xmlChar *)"id", (xmlChar *)id);
                (void) xmlSetProp(node, (xmlChar *)"type",
                    (xmlChar *)"persist");
        }

        if (iter == NULL || value == NULL || prop == NULL || name == NULL)
                goto out;

        /* Iterate over the share pg properties */
        if (scf_iter_pg_properties(iter, pg) != 0)
                goto out;

        while (scf_iter_next_property(iter, prop) > 0) {
                ret = SA_SYSTEM_ERR; /* assume the worst */
                if (scf_property_get_name(prop, name, scf_max_name_len) > 0) {
                        if (scf_property_get_value(prop, value) == 0) {
                                if (scf_value_get_astring(value, valuestr,
                                    vallen) >= 0) {
                                        ret = SA_OK;
                                }
                        } else if (strcmp(name, "resource") == 0) {
                                ret = SA_OK;
                        }
                }
                if (ret != SA_OK)
                        continue;
                /*
                 * Check that we have the "path" property in
                 * name. The string in name will always be nul
                 * terminated if scf_property_get_name()
                 * succeeded.
                 */
                if (strcmp(name, "path") == 0)
                        have_path = 1;
                if (is_share_attr(name)) {
                        /*
                         * If a share attr, then simple -
                         * usually path and id name
                         */
                        (void) xmlSetProp(node, (xmlChar *)name,
                            (xmlChar *)valuestr);
                } else if (strcmp(name, "resource") == 0) {
                        /*
                         * Resource names handled differently since
                         * there can be multiple on each share. The
                         * "resource" id must be preserved since this
                         * will be used by some protocols in mapping
                         * "property spaces" to names and is always
                         * used to create SMF property groups specific
                         * to resources.  CIFS needs this.  The first
                         * value is present so add and then loop for
                         * any additional. Since this is new and
                         * previous values may exist, handle
                         * conversions.
                         */
                        scf_iter_t *viter;
                        viter = scf_iter_create(handle->handle);
                        if (viter != NULL &&
                            scf_iter_property_values(viter, prop) == 0) {
                                while (scf_iter_next_value(viter, value) > 0) {
                                        /* Have a value so process it */
                                        if (scf_value_get_ustring(value,
                                            valuestr, vallen) >= 0) {
                                                /* have a ustring */
                                                _sa_make_resource(node,
                                                    valuestr);
                                        } else if (scf_value_get_astring(value,
                                            valuestr, vallen) >= 0) {
                                                /* have an astring */
                                                _sa_make_resource(node,
                                                    valuestr);
                                        }
                                }
                                scf_iter_destroy(viter);
                        }
                } else {
                        if (strcmp(name, "description") == 0) {
                                /* We have a description node */
                                xmlNodePtr desc;
                                desc = xmlNewChild(node, NULL,
                                    (xmlChar *)"description", NULL);
                                if (desc != NULL)
                                        xmlNodeSetContent(desc,
                                            (xmlChar *)valuestr);
                        }
                }
        }
out:
        /*
         * A share without a path is broken so we want to not include
         * these.  They shouldn't happen but if you kill a sharemgr in
         * the process of creating a share, it could happen.  They
         * should be harmless.  It is also possible that another
         * sharemgr is running and in the process of creating a share.
         */
        if (have_path == 0 && node != NULL) {
                xmlUnlinkNode(node);
                xmlFreeNode(node);
        }
        if (name != NULL)
                free(name);
        if (valuestr != NULL)
                free(valuestr);
        if (value != NULL)
                scf_value_destroy(value);
        if (iter != NULL)
                scf_iter_destroy(iter);
        if (prop != NULL)
                scf_property_destroy(prop);
}

/*
 * find_share_by_id(shareid)
 *
 * Search all shares in all groups until we find the share represented
 * by "id".
 */

static sa_share_t
find_share_by_id(sa_handle_t handle, char *shareid)
{
        sa_group_t group;
        sa_share_t share = NULL;
        char *id = NULL;
        int done = 0;

        for (group = sa_get_group(handle, NULL);
            group != NULL && !done;
            group = sa_get_next_group(group)) {
                for (share = sa_get_share(group, NULL);
                    share != NULL;
                    share = sa_get_next_share(share)) {
                        id = sa_get_share_attr(share, "id");
                        if (id != NULL && strcmp(id, shareid) == 0) {
                                sa_free_attr_string(id);
                                id = NULL;
                                done++;
                                break;
                        }
                        if (id != NULL) {
                                sa_free_attr_string(id);
                                id = NULL;
                        }
                }
        }
        return (share);
}

/*
 * find_resource_by_index(share, index)
 *
 * Search the resource records on the share for the id index.
 */
static sa_resource_t
find_resource_by_index(sa_share_t share, char *index)
{
        sa_resource_t resource;
        sa_resource_t found = NULL;
        char *id;

        for (resource = sa_get_share_resource(share, NULL);
            resource != NULL && found == NULL;
            resource = sa_get_next_resource(resource)) {
                id = (char *)xmlGetProp((xmlNodePtr)resource, (xmlChar *)"id");
                if (id != NULL) {
                        if (strcmp(id, index) == 0) {
                                /* found it so save in "found" */
                                found = resource;
                        }
                        sa_free_attr_string(id);
                }
        }
        return (found);
}

/*
 * sa_share_props_from_pgroup(root, handle, pg, id, sahandle)
 *
 * Extract share properties from the SMF property group. More sanity
 * checks are done and the share object is created. We ignore some
 * errors that could exist in the repository and only worry about
 * property groups that validate in naming.
 */

static int
sa_share_props_from_pgroup(xmlNodePtr root, scfutilhandle_t *handle,
                        scf_propertygroup_t *pg, char *id, sa_handle_t sahandle)
{
        xmlNodePtr node;
        char *name = NULL;
        scf_iter_t *iter = NULL;
        scf_property_t *prop = NULL;
        scf_value_t *value = NULL;
        ssize_t vallen;
        char *valuestr = NULL;
        int ret = SA_OK;
        char *sectype = NULL;
        char *proto;
        sa_share_t share;
        uuid_t uuid;

        /*
         * While preliminary check (starts with 'S') passed before
         * getting here. Need to make sure it is in ID syntax
         * (Snnnnnn). Note that shares with properties have similar
         * pgroups. If the pg name is more than SA_SHARE_PG_LEN
         * characters, it is likely one of the protocol/security
         * versions.
         */
        vallen = strlen(id);
        if (*id != SA_SHARE_PG_PREFIX[0] || vallen <= SA_SHARE_PG_LEN) {
                /*
                 * It is ok to not have what we thought since someone might
                 * have added a name via SMF.
                 */
                return (ret);
        }
        if (strncmp(id, SA_SHARE_PG_PREFIX, SA_SHARE_PG_PREFIXLEN) == 0) {
                proto = strchr(id, '_');
                if (proto == NULL)
                        return (ret);
                *proto++ = '\0';
                if (uuid_parse(id + SA_SHARE_PG_PREFIXLEN, uuid) < 0)
                        return (ret);
                /*
                 * probably a legal optionset so check a few more
                 * syntax points below.
                 */
                if (*proto == '\0') {
                        /* not a valid proto (null) */
                        return (ret);
                }

                sectype = strchr(proto, '_');
                if (sectype != NULL)
                        *sectype++ = '\0';
                if (!valid_protocol(proto))
                        return (ret);
        }

        /*
         * To get here, we have a valid protocol and possibly a
         * security. We now have to find the share that it is really
         * associated with. The "id" portion of the pgroup name will
         * match.
         */

        share = find_share_by_id(sahandle, id);
        if (share == NULL)
                return (SA_BAD_PATH);

        root = (xmlNodePtr)share;

        vallen = get_scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH);

        if (sectype == NULL)
                node = xmlNewChild(root, NULL, (xmlChar *)"optionset", NULL);
        else {
                if (isdigit((int)*sectype)) {
                        sa_resource_t resource;
                        /*
                         * If sectype[0] is a digit, then it is an index into
                         * the resource names. We need to find a resource
                         * record and then get the properties into an
                         * optionset. The optionset becomes the "node" and the
                         * rest is hung off of the share.
                         */
                        resource = find_resource_by_index(share, sectype);
                        if (resource != NULL) {
                                node = xmlNewChild(resource, NULL,
                                    (xmlChar *)"optionset", NULL);
                        } else {
                                /* This shouldn't happen. */
                                ret = SA_SYSTEM_ERR;
                                goto out;
                        }
                } else {
                        /*
                         * If not a digit, then it is a security type
                         * (alternate option space). Security types start with
                         * an alphabetic.
                         */
                        node = xmlNewChild(root, NULL, (xmlChar *)"security",
                            NULL);
                        if (node != NULL)
                                (void) xmlSetProp(node, (xmlChar *)"sectype",
                                    (xmlChar *)sectype);
                }
        }
        if (node == NULL) {
                ret = SA_NO_MEMORY;
                goto out;
        }

        (void) xmlSetProp(node, (xmlChar *)"type", (xmlChar *)proto);
        /* now find the properties */
        iter = scf_iter_create(handle->handle);
        value = scf_value_create(handle->handle);
        prop = scf_property_create(handle->handle);
        name = malloc(scf_max_name_len);
        valuestr = malloc(vallen);

        if (iter == NULL || value == NULL || prop == NULL || name == NULL)
                goto out;

        /* iterate over the share pg properties */
        if (scf_iter_pg_properties(iter, pg) == 0) {
                while (scf_iter_next_property(iter, prop) > 0) {
                        ret = SA_SYSTEM_ERR; /* assume the worst */
                        if (scf_property_get_name(prop, name,
                            scf_max_name_len) > 0) {
                                if (scf_property_get_value(prop, value) == 0) {
                                        if (scf_value_get_astring(value,
                                            valuestr, vallen) >= 0) {
                                                ret = SA_OK;
                                        }
                                }
                        } else {
                                ret = SA_SYSTEM_ERR;
                        }
                        if (ret == SA_OK) {
                                sa_property_t prop;
                                prop = sa_create_property(name, valuestr);
                                if (prop != NULL)
                                        prop = (sa_property_t)xmlAddChild(node,
                                            (xmlNodePtr)prop);
                                else
                                        ret = SA_NO_MEMORY;
                        }
                }
        } else {
                ret = SA_SYSTEM_ERR;
        }
out:
        if (iter != NULL)
                scf_iter_destroy(iter);
        if (value != NULL)
                scf_value_destroy(value);
        if (prop != NULL)
                scf_property_destroy(prop);
        if (name != NULL)
                free(name);
        if (valuestr != NULL)
                free(valuestr);
        return (ret);
}

/*
 * sa_extract_group(root, handle, instance)
 *
 * Get the config info for this instance of a group and create the XML
 * subtree from it.
 */

static int
sa_extract_group(xmlNodePtr root, scfutilhandle_t *handle,
    scf_instance_t *instance, sa_handle_t sahandle)
{
        char *buff;
        xmlNodePtr node;
        scf_iter_t *iter;
        char *proto;
        char *sectype;
        boolean_t have_shares = B_FALSE;
        boolean_t is_default = B_FALSE;
        boolean_t is_nfs = B_FALSE;
        int ret = SA_OK;
        int err;

        buff = malloc(scf_max_name_len);
        if (buff == NULL)
                return (SA_NO_MEMORY);

        iter = scf_iter_create(handle->handle);
        if (iter == NULL) {
                ret = SA_NO_MEMORY;
                goto out;
        }

        if (scf_instance_get_name(instance, buff, scf_max_name_len) > 0) {
                node = xmlNewChild(root, NULL, (xmlChar *)"group", NULL);
                if (node == NULL) {
                        ret = SA_NO_MEMORY;
                        goto out;
                }
                (void) xmlSetProp(node, (xmlChar *)"name", (xmlChar *)buff);
                if (strcmp(buff, "default") == 0)
                        is_default = B_TRUE;

                sa_extract_attrs(node, handle, instance);
                /*
                 * Iterate through all the property groups
                 * looking for those with security or
                 * optionset prefixes. The names of the
                 * matching pgroups are parsed to get the
                 * protocol, and for security, the sectype.
                 * Syntax is as follows:
                 *    optionset | optionset_<proto>
                 *    security_default | security_<proto>_<sectype>
                 * "operation" is handled by
                 * sa_extract_attrs().
                 */
                if (scf_iter_instance_pgs(iter, instance) != 0) {
                        ret = SA_NO_MEMORY;
                        goto out;
                }
                while (scf_iter_next_pg(iter, handle->pg) > 0) {
                        /* Have a pgroup so sort it out */
                        ret = scf_pg_get_name(handle->pg, buff,
                            scf_max_name_len);
                        if (ret <= 0)
                                continue;
                        is_nfs = B_FALSE;

                        if (buff[0] == SA_SHARE_PG_PREFIX[0]) {
                                sa_share_from_pgroup(node, handle,
                                    handle->pg, buff);
                                have_shares = B_TRUE;
                        } else if (strncmp(buff, "optionset", 9) == 0) {
                                char *nodetype = "optionset";
                                /* Have an optionset */
                                sectype = NULL;
                                proto = strchr(buff, '_');
                                if (proto != NULL) {
                                        *proto++ = '\0';
                                        sectype = strchr(proto, '_');
                                        if (sectype != NULL) {
                                                *sectype++ = '\0';
                                                nodetype = "security";
                                        }
                                        is_nfs = strcmp(proto, "nfs") == 0;
                                } else if (strlen(buff) > 9) {
                                        /*
                                         * This can only occur if
                                         * someone has made changes
                                         * via an SMF command. Since
                                         * this would be an unknown
                                         * syntax, we just ignore it.
                                         */
                                        continue;
                                }
                                /*
                                 * If the group is not "default" or is
                                 * "default" and is_nfs, then extract the
                                 * pgroup.  If it is_default and !is_nfs,
                                 * then we have an error and should remove
                                 * the extraneous protocols.  We don't care
                                 * about errors on scf_pg_delete since we
                                 * might not have permission during an
                                 * extract only.
                                 */
                                if (!is_default || is_nfs) {
                                        ret = sa_extract_pgroup(node, handle,
                                            handle->pg, nodetype, proto,
                                            sectype);
                                } else {
                                        err = scf_pg_delete(handle->pg);
                                        if (err == 0)
                                                (void) fprintf(stderr,
                                                    dgettext(TEXT_DOMAIN,
                                                    "Removed protocol \"%s\" "
                                                    "from group \"default\"\n"),
                                                    proto);
                                }
                        } else if (strncmp(buff, "security", 8) == 0) {
                                /*
                                 * Have a security (note that
                                 * this should change in the
                                 * future)
                                 */
                                proto = strchr(buff, '_');
                                sectype = NULL;
                                if (proto != NULL) {
                                        *proto++ = '\0';
                                        sectype = strchr(proto, '_');
                                        if (sectype != NULL)
                                                *sectype++ = '\0';
                                        if (strcmp(proto, "default") == 0)
                                                proto = NULL;
                                }
                                ret = sa_extract_pgroup(node, handle,
                                    handle->pg, "security", proto, sectype);
                        }
                        /* Ignore everything else */
                }
                /*
                 * Make sure we have a valid default group.
                 * On first boot, default won't have any
                 * protocols defined and won't be enabled (but
                 * should be).  "default" only has NFS enabled on it.
                 */
                if (is_default) {
                        char *state = sa_get_group_attr((sa_group_t)node,
                            "state");

                        if (state == NULL) {
                                /* set attribute to enabled */
                                (void) sa_set_group_attr((sa_group_t)node,
                                    "state", "enabled");
                                (void) sa_create_optionset((sa_group_t)node,
                                    "nfs");
                        } else {
                                sa_free_attr_string(state);
                        }
                }
                /* Do a second pass if shares were found */
                if (have_shares && scf_iter_instance_pgs(iter, instance) == 0) {
                        while (scf_iter_next_pg(iter, handle->pg) > 0) {
                                /*
                                 * Have a pgroup so see if it is a
                                 * share optionset
                                 */
                                err = scf_pg_get_name(handle->pg, buff,
                                    scf_max_name_len);
                                if (err  <= 0)
                                        continue;
                                if (buff[0] == SA_SHARE_PG_PREFIX[0]) {
                                        ret = sa_share_props_from_pgroup(node,
                                            handle, handle->pg, buff,
                                            sahandle);
                                }
                        }
                }
        }
out:
        if (iter != NULL)
                scf_iter_destroy(iter);
        if (buff != NULL)
                free(buff);
        return (ret);
}

/*
 * sa_extract_defaults(root, handle, instance)
 *
 * Local function to find the default properties that live in the
 * default instance's "operation" property group.
 */

static void
sa_extract_defaults(xmlNodePtr root, scfutilhandle_t *handle,
                    scf_instance_t *instance)
{
        xmlNodePtr node;
        scf_property_t *prop;
        scf_value_t *value;
        char *valuestr;
        ssize_t vallen;

        vallen = get_scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH);
        prop = scf_property_create(handle->handle);
        value = scf_value_create(handle->handle);
        valuestr = malloc(vallen);

        if (prop == NULL || value == NULL || vallen == 0 ||
            scf_instance_get_pg(instance, "operation", handle->pg) != 0)
                goto out;

        if (scf_pg_get_property(handle->pg, "legacy-timestamp", prop) != 0)
                goto out;

        /* Found the property so get the value */
        if (scf_property_get_value(prop, value) == 0) {
                if (scf_value_get_astring(value, valuestr, vallen) > 0) {
                        node = xmlNewChild(root, NULL, (xmlChar *)"legacy",
                            NULL);
                        if (node != NULL) {
                                (void) xmlSetProp(node, (xmlChar *)"timestamp",
                                    (xmlChar *)valuestr);
                                (void) xmlSetProp(node, (xmlChar *)"path",
                                    (xmlChar *)SA_LEGACY_DFSTAB);
                        }
                }
        }
out:
        if (valuestr != NULL)
                free(valuestr);
        if (value != NULL)
                scf_value_destroy(value);
        if (prop != NULL)
                scf_property_destroy(prop);
}


/*
 * sa_get_config(handle, root, doc, sahandle)
 *
 * Walk the SMF repository for /network/shares/group and find all the
 * instances. These become group names.  Then add the XML structure
 * below the groups based on property groups and properties.
 */
int
sa_get_config(scfutilhandle_t *handle, xmlNodePtr root, sa_handle_t sahandle)
{
        int ret = SA_OK;
        scf_instance_t *instance;
        scf_iter_t *iter;
        char buff[BUFSIZ * 2];

        instance = scf_instance_create(handle->handle);
        iter = scf_iter_create(handle->handle);
        if (instance != NULL && iter != NULL) {
                if ((ret = scf_iter_service_instances(iter,
                    handle->service)) == 0) {
                        while ((ret = scf_iter_next_instance(iter,
                            instance)) > 0) {
                                if (scf_instance_get_name(instance, buff,
                                    sizeof (buff)) > 0) {
                                        if (strcmp(buff, "default") == 0)
                                                sa_extract_defaults(root,
                                                    handle, instance);
                                        ret = sa_extract_group(root, handle,
                                            instance, sahandle);
                                }
                        }
                }
        }

        /* Always cleanup these */
        if (instance != NULL)
                scf_instance_destroy(instance);
        if (iter != NULL)
                scf_iter_destroy(iter);
        return (ret);
}

/*
 * sa_get_instance(handle, instance)
 *
 * Get the instance of the group service. This is actually the
 * specific group name. The instance is needed for all property and
 * control operations.
 */

int
sa_get_instance(scfutilhandle_t *handle, char *instname)
{
        if (scf_service_get_instance(handle->service, instname,
            handle->instance) != 0) {
                return (SA_NO_SUCH_GROUP);
        }
        return (SA_OK);
}

/*
 * sa_create_instance(handle, instname)
 *
 * Create a new SMF service instance. There can only be one with a
 * given name.
 */

int
sa_create_instance(scfutilhandle_t *handle, char *instname)
{
        int ret = SA_OK;
        char instance[SA_GROUP_INST_LEN];
        if (scf_service_add_instance(handle->service, instname,
            handle->instance) != 0) {
        /* better error returns need to be added based on real error */
                if (scf_error() == SCF_ERROR_PERMISSION_DENIED)
                        ret = SA_NO_PERMISSION;
                else
                        ret = SA_DUPLICATE_NAME;
        } else {
                /* have the service created, so enable it */
                (void) snprintf(instance, sizeof (instance), "%s:%s",
                    SA_SVC_FMRI_BASE, instname);
                (void) smf_enable_instance(instance, 0);
        }
        return (ret);
}

/*
 * sa_delete_instance(handle, instname)
 *
 * When a group goes away, we also remove the service instance.
 */

int
sa_delete_instance(scfutilhandle_t *handle, char *instname)
{
        int ret;

        if (strcmp(instname, "default") == 0) {
                ret = SA_NO_PERMISSION;
        } else {
                if ((ret = sa_get_instance(handle, instname)) == SA_OK) {
                        if (scf_instance_delete(handle->instance) != 0)
                                /* need better analysis */
                                ret = SA_NO_PERMISSION;
                }
        }
        return (ret);
}

/*
 * sa_create_pgroup(handle, pgroup)
 *
 * create a new property group
 */

int
sa_create_pgroup(scfutilhandle_t *handle, char *pgroup)
{
        int ret = SA_OK;
        int persist = 0;

        /*
         * Only create a handle if it doesn't exist. It is ok to exist
         * since the pg handle will be set as a side effect.
         */
        if (handle->pg == NULL)
                handle->pg = scf_pg_create(handle->handle);

        /*
         * Special case for a non-persistent property group. This is
         * internal use only.
         */
        if (*pgroup == '*') {
                persist = SCF_PG_FLAG_NONPERSISTENT;
                pgroup++;
        }

        /*
         * If the pgroup exists, we are done. If it doesn't, then we
         * need to actually add one to the service instance.
         */
        if (scf_instance_get_pg(handle->instance,
            pgroup, handle->pg) != 0) {

                /* Doesn't exist so create one */
                if (scf_instance_add_pg(handle->instance, pgroup,
                    SCF_GROUP_APPLICATION, persist, handle->pg) != 0) {
                        switch (scf_error()) {
                        case SCF_ERROR_PERMISSION_DENIED:
                                ret = SA_NO_PERMISSION;
                                break;
                        default:
                                ret = SA_SYSTEM_ERR;
                                break;
                        }
                }
        }
        return (ret);
}

/*
 * sa_delete_pgroup(handle, pgroup)
 *
 * Remove the property group from the current instance of the service,
 * but only if it actually exists.
 */

int
sa_delete_pgroup(scfutilhandle_t *handle, char *pgroup)
{
        int ret = SA_OK;
        /*
         * Only delete if it does exist.
         */
        if (scf_instance_get_pg(handle->instance, pgroup, handle->pg) == 0) {
                /* does exist so delete it */
                if (scf_pg_delete(handle->pg) != 0)
                        ret = SA_SYSTEM_ERR;
        } else {
                ret = SA_SYSTEM_ERR;
        }
        if (ret == SA_SYSTEM_ERR &&
            scf_error() == SCF_ERROR_PERMISSION_DENIED) {
                ret = SA_NO_PERMISSION;
        }
        return (ret);
}

/*
 * sa_start_transaction(handle, pgroup)
 *
 * Start an SMF transaction so we can deal with properties. it would
 * be nice to not have to expose this, but we have to in order to
 * optimize.
 *
 * Basic model is to hold the transaction in the handle and allow
 * property adds/deletes/updates to be added then close the
 * transaction (or abort).  There may eventually be a need to handle
 * other types of transaction mechanisms but we don't do that now.
 *
 * An sa_start_transaction must be followed by either an
 * sa_end_transaction or sa_abort_transaction before another
 * sa_start_transaction can be done.
 */

int
sa_start_transaction(scfutilhandle_t *handle, char *propgroup)
{
        int ret = SA_OK;
        /*
         * Lookup the property group and create it if it doesn't already
         * exist.
         */
        if (handle == NULL)
                return (SA_CONFIG_ERR);

        if (handle->scf_state == SCH_STATE_INIT) {
                ret = sa_create_pgroup(handle, propgroup);
                if (ret == SA_OK) {
                        handle->trans = scf_transaction_create(handle->handle);
                        if (handle->trans != NULL) {
                                if (scf_transaction_start(handle->trans,
                                    handle->pg) != 0) {
                                        ret = SA_SYSTEM_ERR;
                                }
                                if (ret != SA_OK) {
                                        scf_transaction_destroy(handle->trans);
                                        handle->trans = NULL;
                                }
                        } else {
                                ret = SA_SYSTEM_ERR;
                        }
                }
        }
        if (ret == SA_SYSTEM_ERR &&
            scf_error() == SCF_ERROR_PERMISSION_DENIED) {
                ret = SA_NO_PERMISSION;
        }
        return (ret);
}


/*
 * sa_end_transaction(scfhandle, sahandle)
 *
 * Commit the changes that were added to the transaction in the
 * handle. Do all necessary cleanup.
 */

int
sa_end_transaction(scfutilhandle_t *handle, sa_handle_impl_t sahandle)
{
        int ret = SA_OK;

        if (handle == NULL || handle->trans == NULL || sahandle == NULL) {
                ret = SA_SYSTEM_ERR;
        } else {
                if (scf_transaction_commit(handle->trans) < 0)
                        ret = SA_SYSTEM_ERR;
                scf_transaction_destroy_children(handle->trans);
                scf_transaction_destroy(handle->trans);
                if (ret == SA_OK)
                        set_transaction_tstamp(sahandle);
                handle->trans = NULL;
        }
        return (ret);
}

/*
 * sa_abort_transaction(handle)
 *
 * Abort the changes that were added to the transaction in the
 * handle. Do all necessary cleanup.
 */

void
sa_abort_transaction(scfutilhandle_t *handle)
{
        if (handle->trans != NULL) {
                scf_transaction_reset_all(handle->trans);
                scf_transaction_destroy_children(handle->trans);
                scf_transaction_destroy(handle->trans);
                handle->trans = NULL;
        }
}

/*
 * set_transaction_tstamp(sahandle)
 *
 * After a successful transaction commit, update the timestamp of the
 * last transaction. This lets us detect changes from other processes.
 */
static void
set_transaction_tstamp(sa_handle_impl_t sahandle)
{
        char tstring[32];
        struct timeval tv;
        scfutilhandle_t *scfhandle;

        if (sahandle == NULL || sahandle->scfhandle == NULL)
                return;

        scfhandle = sahandle->scfhandle;

        if (sa_get_instance(scfhandle, "default") != SA_OK)
                return;

        if (gettimeofday(&tv, NULL) != 0)
                return;

        if (sa_start_transaction(scfhandle, "*state") != SA_OK)
                return;

        sahandle->tstrans = TSTAMP((*(timestruc_t *)&tv));
        (void) snprintf(tstring, sizeof (tstring), "%lld", sahandle->tstrans);
        if (sa_set_property(sahandle->scfhandle, "lastupdate", tstring) ==
            SA_OK) {
                /*
                 * While best if it succeeds, a failure doesn't cause
                 * problems and we will ignore it anyway.
                 */
                (void) scf_transaction_commit(scfhandle->trans);
                scf_transaction_destroy_children(scfhandle->trans);
                scf_transaction_destroy(scfhandle->trans);
        } else {
                sa_abort_transaction(scfhandle);
        }
}

/*
 * sa_set_property(handle, prop, value)
 *
 * Set a property transaction entry into the pending SMF transaction.
 */

int
sa_set_property(scfutilhandle_t *handle, char *propname, char *valstr)
{
        int ret = SA_OK;
        scf_value_t *value;
        scf_transaction_entry_t *entry;
        /*
         * Properties must be set in transactions and don't take
         * effect until the transaction has been ended/committed.
         */
        value = scf_value_create(handle->handle);
        entry = scf_entry_create(handle->handle);
        if (value != NULL && entry != NULL) {
                if (scf_transaction_property_change(handle->trans, entry,
                    propname, SCF_TYPE_ASTRING) == 0 ||
                    scf_transaction_property_new(handle->trans, entry,
                    propname, SCF_TYPE_ASTRING) == 0) {
                        if (scf_value_set_astring(value, valstr) == 0) {
                                if (scf_entry_add_value(entry, value) != 0) {
                                        ret = SA_SYSTEM_ERR;
                                        scf_value_destroy(value);
                                }
                                /* The value is in the transaction */
                                value = NULL;
                        } else {
                                /* Value couldn't be constructed */
                                ret = SA_SYSTEM_ERR;
                        }
                        /* The entry is in the transaction */
                        entry = NULL;
                } else {
                        ret = SA_SYSTEM_ERR;
                }
        } else {
                ret = SA_SYSTEM_ERR;
        }
        if (ret == SA_SYSTEM_ERR) {
                switch (scf_error()) {
                case SCF_ERROR_PERMISSION_DENIED:
                        ret = SA_NO_PERMISSION;
                        break;
                }
        }
        /*
         * Cleanup if there were any errors that didn't leave these
         * values where they would be cleaned up later.
         */
        if (value != NULL)
                scf_value_destroy(value);
        if (entry != NULL)
                scf_entry_destroy(entry);
        return (ret);
}

/*
 * check_resource(share)
 *
 * Check to see if share has any persistent resources. We don't want
 * to save if they are all transient.
 */
static int
check_resource(sa_share_t share)
{
        sa_resource_t resource;
        int ret = B_FALSE;

        for (resource = sa_get_share_resource(share, NULL);
            resource != NULL && ret == B_FALSE;
            resource = sa_get_next_resource(resource)) {
                char *type;
                type = sa_get_resource_attr(resource, "type");
                if (type != NULL) {
                        if (strcmp(type, "transient") != 0) {
                                ret = B_TRUE;
                        }
                        sa_free_attr_string(type);
                }
        }
        return (ret);
}

/*
 * sa_set_resource_property(handle, prop, value)
 *
 * set a property transaction entry into the pending SMF
 * transaction. We don't want to include any transient resources
 */

static int
sa_set_resource_property(scfutilhandle_t *handle, sa_share_t share)
{
        int ret = SA_OK;
        scf_value_t *value;
        scf_transaction_entry_t *entry;
        sa_resource_t resource;
        char *valstr;
        char *idstr;
        char *description;
        char *propstr = NULL;
        size_t strsize;

        /* don't bother if no persistent resources */
        if (check_resource(share) == B_FALSE)
                return (ret);

        /*
         * properties must be set in transactions and don't take
         * effect until the transaction has been ended/committed.
         */
        entry = scf_entry_create(handle->handle);
        if (entry == NULL)
                return (SA_SYSTEM_ERR);

        if (scf_transaction_property_change(handle->trans, entry,
            "resource", SCF_TYPE_ASTRING) != 0 &&
            scf_transaction_property_new(handle->trans, entry,
            "resource", SCF_TYPE_ASTRING) != 0) {
                scf_entry_destroy(entry);
                return (SA_SYSTEM_ERR);

        }
        for (resource = sa_get_share_resource(share, NULL);
            resource != NULL;
            resource = sa_get_next_resource(resource)) {
                value = scf_value_create(handle->handle);
                if (value == NULL) {
                        ret = SA_NO_MEMORY;
                        break;
                }
                        /* Get size of complete string */
                valstr = sa_get_resource_attr(resource, "name");
                idstr = sa_get_resource_attr(resource, "id");
                description = sa_get_resource_description(resource);
                strsize = (valstr != NULL) ? strlen(valstr) : 0;
                strsize += (idstr != NULL) ? strlen(idstr) : 0;
                strsize += (description != NULL) ? strlen(description) : 0;
                if (strsize > 0) {
                        strsize += 3; /* add nul and ':' */
                        propstr = (char *)malloc(strsize);
                        if (propstr == NULL) {
                                scf_value_destroy(value);
                                ret = SA_NO_MEMORY;
                                goto err;
                        }
                        if (idstr == NULL)
                                (void) snprintf(propstr, strsize, "%s",
                                    valstr ? valstr : "");
                        else
                                (void) snprintf(propstr, strsize, "%s:%s:%s",
                                    idstr, valstr ? valstr : "",
                                    description ? description : "");
                        if (scf_value_set_astring(value, propstr) != 0) {
                                ret = SA_SYSTEM_ERR;
                                free(propstr);
                                scf_value_destroy(value);
                                break;
                        }
                        if (scf_entry_add_value(entry, value) != 0) {
                                ret = SA_SYSTEM_ERR;
                                free(propstr);
                                scf_value_destroy(value);
                                break;
                        }
                        /* the value is in the transaction */
                        value = NULL;
                        free(propstr);
                }
err:
                if (valstr != NULL) {
                        sa_free_attr_string(valstr);
                        valstr = NULL;
                }
                if (idstr != NULL) {
                        sa_free_attr_string(idstr);
                        idstr = NULL;
                }
                if (description != NULL) {
                        sa_free_share_description(description);
                        description = NULL;
                }
        }
        /* the entry is in the transaction */
        entry = NULL;

        if (valstr != NULL)
                sa_free_attr_string(valstr);
        if (idstr != NULL)
                sa_free_attr_string(idstr);
        if (description != NULL)
                sa_free_share_description(description);

        if (ret == SA_SYSTEM_ERR) {
                switch (scf_error()) {
                case SCF_ERROR_PERMISSION_DENIED:
                        ret = SA_NO_PERMISSION;
                        break;
                }
        }
        /*
         * cleanup if there were any errors that didn't leave
         * these values where they would be cleaned up later.
         */
        if (entry != NULL)
                scf_entry_destroy(entry);

        return (ret);
}

/*
 * sa_commit_share(handle, group, share)
 *
 *      Commit this share to the repository.
 *      properties are added if they exist but can be added later.
 *      Need to add to dfstab and sharetab, if appropriate.
 */
int
sa_commit_share(scfutilhandle_t *handle, sa_group_t group, sa_share_t share)
{
        int ret = SA_OK;
        char *groupname;
        char *name;
        char *description;
        char *sharename;
        ssize_t proplen;
        char *propstring;

        /*
         * Don't commit in the zfs group. We do commit legacy
         * (default) and all other groups/shares. ZFS is handled
         * through the ZFS configuration rather than SMF.
         */

        groupname = sa_get_group_attr(group, "name");
        if (groupname != NULL) {
                if (strcmp(groupname, "zfs") == 0) {
                        /*
                         * Adding to the ZFS group will result in the sharenfs
                         * property being set but we don't want to do anything
                         * SMF related at this point.
                         */
                        sa_free_attr_string(groupname);
                        return (ret);
                }
        }

        proplen = get_scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH);
        propstring = malloc(proplen);
        if (propstring == NULL)
                ret = SA_NO_MEMORY;

        if (groupname != NULL && ret == SA_OK) {
                ret = sa_get_instance(handle, groupname);
                sa_free_attr_string(groupname);
                groupname = NULL;
                sharename = sa_get_share_attr(share, "id");
                if (sharename == NULL) {
                        /* slipped by */
                        char shname[SA_SHARE_UUID_BUFLEN];
                        generate_unique_sharename(shname);
                        (void) xmlSetProp((xmlNodePtr)share, (xmlChar *)"id",
                            (xmlChar *)shname);
                        sharename = strdup(shname);
                }
                if (sharename != NULL) {
                        sigset_t old, new;
                        /*
                         * Have a share name allocated so create a pgroup for
                         * it. It may already exist, but that is OK.  In order
                         * to avoid creating a share pgroup that doesn't have
                         * a path property, block signals around the critical
                         * region of creating the share pgroup and props.
                         */
                        (void) sigprocmask(SIG_BLOCK, NULL, &new);
                        (void) sigaddset(&new, SIGHUP);
                        (void) sigaddset(&new, SIGINT);
                        (void) sigaddset(&new, SIGQUIT);
                        (void) sigaddset(&new, SIGTSTP);
                        (void) sigprocmask(SIG_SETMASK, &new, &old);

                        ret = sa_create_pgroup(handle, sharename);
                        if (ret == SA_OK) {
                                /*
                                 * Now start the transaction for the
                                 * properties that define this share. They may
                                 * exist so attempt to update before create.
                                 */
                                ret = sa_start_transaction(handle, sharename);
                        }
                        if (ret == SA_OK) {
                                name = sa_get_share_attr(share, "path");
                                if (name != NULL) {
                                        /*
                                         * There needs to be a path
                                         * for a share to exist.
                                         */
                                        ret = sa_set_property(handle, "path",
                                            name);
                                        sa_free_attr_string(name);
                                } else {
                                        ret = SA_NO_MEMORY;
                                }
                        }
                        if (ret == SA_OK) {
                                name = sa_get_share_attr(share, "drive-letter");
                                if (name != NULL) {
                                        /* A drive letter may exist for SMB */
                                        ret = sa_set_property(handle,
                                            "drive-letter", name);
                                        sa_free_attr_string(name);
                                }
                        }
                        if (ret == SA_OK) {
                                name = sa_get_share_attr(share, "exclude");
                                if (name != NULL) {
                                        /*
                                         * In special cases need to
                                         * exclude proto enable.
                                         */
                                        ret = sa_set_property(handle,
                                            "exclude", name);
                                        sa_free_attr_string(name);
                                }
                        }
                        if (ret == SA_OK) {
                                /*
                                 * If there are resource names, bundle them up
                                 * and save appropriately.
                                 */
                                ret = sa_set_resource_property(handle, share);
                        }

                        if (ret == SA_OK) {
                                description = sa_get_share_description(share);
                                if (description != NULL) {
                                        ret = sa_set_property(handle,
                                            "description",
                                            description);
                                        sa_free_share_description(description);
                                }
                        }
                        /* Make sure we cleanup the transaction */
                        if (ret == SA_OK) {
                                sa_handle_impl_t sahandle;
                                sahandle = (sa_handle_impl_t)
                                    sa_find_group_handle(group);
                                if (sahandle != NULL)
                                        ret = sa_end_transaction(handle,
                                            sahandle);
                                else
                                        ret = SA_SYSTEM_ERR;
                        } else {
                                sa_abort_transaction(handle);
                        }

                        (void) sigprocmask(SIG_SETMASK, &old, NULL);

                        free(sharename);
                }
        }
        if (ret == SA_SYSTEM_ERR) {
                int err = scf_error();
                if (err == SCF_ERROR_PERMISSION_DENIED)
                        ret = SA_NO_PERMISSION;
        }
        if (propstring != NULL)
                free(propstring);
        if (groupname != NULL)
                sa_free_attr_string(groupname);

        return (ret);
}

/*
 * remove_resources(handle, share, shareid)
 *
 * If the share has resources, remove all of them and their
 * optionsets.
 */
static int
remove_resources(scfutilhandle_t *handle, sa_share_t share, char *shareid)
{
        sa_resource_t resource;
        sa_optionset_t opt;
        char *proto;
        char *id;
        ssize_t proplen;
        char *propstring;
        int ret = SA_OK;

        proplen = get_scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH);
        propstring = malloc(proplen);
        if (propstring == NULL)
                return (SA_NO_MEMORY);

        for (resource = sa_get_share_resource(share, NULL);
            resource != NULL; resource = sa_get_next_resource(resource)) {
                id = sa_get_resource_attr(resource, "id");
                if (id == NULL)
                        continue;
                for (opt = sa_get_optionset(resource, NULL);
                    opt != NULL; opt = sa_get_next_optionset(resource)) {
                        proto = sa_get_optionset_attr(opt, "type");
                        if (proto != NULL) {
                                (void) snprintf(propstring, proplen,
                                    "%s_%s_%s", shareid, proto, id);
                                ret = sa_delete_pgroup(handle, propstring);
                                sa_free_attr_string(proto);
                        }
                }
                sa_free_attr_string(id);
        }
        free(propstring);
        return (ret);
}

/*
 * sa_delete_share(handle, group, share)
 *
 * Remove the specified share from the group (and service instance).
 */

int
sa_delete_share(scfutilhandle_t *handle, sa_group_t group, sa_share_t share)
{
        int ret = SA_OK;
        char *groupname = NULL;
        char *shareid = NULL;
        sa_optionset_t opt;
        sa_security_t sec;
        ssize_t proplen;
        char *propstring;

        proplen = get_scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH);
        propstring = malloc(proplen);
        if (propstring == NULL)
                ret = SA_NO_MEMORY;

        if (ret == SA_OK) {
                groupname = sa_get_group_attr(group, "name");
                shareid = sa_get_share_attr(share, "id");
                if (groupname == NULL || shareid == NULL) {
                        ret = SA_CONFIG_ERR;
                        goto out;
                }
                ret = sa_get_instance(handle, groupname);
                if (ret == SA_OK) {
                        /* If a share has resources, remove them */
                        ret = remove_resources(handle, share, shareid);
                        /* If a share has properties, remove them */
                        ret = sa_delete_pgroup(handle, shareid);
                        for (opt = sa_get_optionset(share, NULL);
                            opt != NULL;
                            opt = sa_get_next_optionset(opt)) {
                                char *proto;
                                proto = sa_get_optionset_attr(opt, "type");
                                if (proto != NULL) {
                                        (void) snprintf(propstring,
                                            proplen, "%s_%s", shareid,
                                            proto);
                                        ret = sa_delete_pgroup(handle,
                                            propstring);
                                        sa_free_attr_string(proto);
                                } else {
                                        ret = SA_NO_MEMORY;
                                }
                        }
                        /*
                         * If a share has security/negotiable
                         * properties, remove them.
                         */
                        for (sec = sa_get_security(share, NULL, NULL);
                            sec != NULL;
                            sec = sa_get_next_security(sec)) {
                                char *proto;
                                char *sectype;
                                proto = sa_get_security_attr(sec, "type");
                                sectype = sa_get_security_attr(sec, "sectype");
                                if (proto != NULL && sectype != NULL) {
                                        (void) snprintf(propstring, proplen,
                                            "%s_%s_%s", shareid,  proto,
                                            sectype);
                                        ret = sa_delete_pgroup(handle,
                                            propstring);
                                } else {
                                        ret = SA_NO_MEMORY;
                                }
                                if (proto != NULL)
                                        sa_free_attr_string(proto);
                                if (sectype != NULL)
                                        sa_free_attr_string(sectype);
                        }
                }
        }
out:
        if (groupname != NULL)
                sa_free_attr_string(groupname);
        if (shareid != NULL)
                sa_free_attr_string(shareid);
        if (propstring != NULL)
                free(propstring);

        return (ret);
}