xref: /titanic_41/usr/src/lib/libshare/common/scfutil.c (revision ed5289f91b9bf164dccd6c75398362be77a4478d)

/*
 * 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"

/* 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 ? 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);
		if (idstr != NULL)
			sa_free_attr_string(idstr);
		if (description != NULL)
			sa_free_share_description(description);
	}
	/* the entry is in the transaction */
	entry = NULL;

	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);
}