xref: /illumos-gate/usr/src/lib/libscf/common/scf_tmpl.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 (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2012 Milan Jurik. All rights reserved.
 */

/*
 * scf_tmpl.c
 *
 * This file implements the bulk of the libscf templates interfaces.
 * Templates describe metadata about a service or instance in general,
 * and individual configuration properties on those services and instances.
 * Human-consumable descriptions can be provided, along with definitions
 * of valid configuration.  See service_bundle.dtd.1 for XML definitions
 * of templates, and the svccfg code for information on how those definitions
 * are translated into the repository.
 *
 * The main data structures are scf_pg_tmpl and scf_prop_tmpl.  These
 * are allocated by the callers through scf_tmpl_[pg|prop]_create(), and
 * destroyed with scf_tmpl_[pg|prop]_destroy().  They are populated by
 * scf_tmpl_get_by_pg_name(), scf_tmpl_get_by_pg(), and
 * scf_tmpl_get_by_prop().  They also store the iterator state for
 * scf_tmpl_iter_pgs() and scf_tmpl_iter_props().
 *
 * These data structures are then consumed by other functions to
 * gather information about the template (e.g. name, description,
 * choices, constraints, etc.).
 *
 * scf_tmpl_validate_fmri() does instance validation against template
 * data, and populates a set of template errors which can be explored using
 * the scf_tmpl_next_error() and the scf_tmpl_error*() suite of functions.
 *
 * The main data structures for template errors are scf_tmpl_errors,
 * defined in this file, and scf_tmpl_error, defined in libscf_priv.h.
 * scf_tmpl_error is shared with svccfg to offer common printing
 * of error messages between libscf and svccfg.
 *
 * General convenience functions are towards the top of this file,
 * followed by pg and prop template discovery functions, followed
 * by functions which gather information about the discovered
 * template.  Validation and error functions are at the end of this file.
 */

#include "lowlevel_impl.h"
#include "libscf_impl.h"
#include <assert.h>
#include <errno.h>
#include <libintl.h>
#include <stdlib.h>
#include <stdio.h>
#include <strings.h>
#include <locale.h>
#include <ctype.h>
#include <inttypes.h>

#define	SCF_TMPL_PG_COMMON_NAME_C	"common_name_C"

#define	SCF__TMPL_ITER_NONE		0
#define	SCF__TMPL_ITER_INST		1
#define	SCF__TMPL_ITER_RESTARTER	2
#define	SCF__TMPL_ITER_GLOBAL		3

#define	SCF_TMPL_PG_NT		0
#define	SCF_TMPL_PG_N		1
#define	SCF_TMPL_PG_T		2
#define	SCF_TMPL_PG_WILD	3

struct scf_pg_tmpl {
	int pt_populated;
	scf_handle_t *pt_h;
	scf_propertygroup_t *pt_pg;
	scf_service_t *pt_orig_svc;
	scf_service_t *pt_svc;
	scf_instance_t *pt_orig_inst;
	scf_instance_t *pt_inst;
	scf_snapshot_t *pt_snap;
	int pt_is_iter;
	scf_iter_t *pt_iter;
	int pt_iter_last;
};

#define	SCF_WALK_ERROR		-1
#define	SCF_WALK_NEXT		0
#define	SCF_WALK_DONE		1

struct pg_tmpl_walk {
	const char *pw_snapname;
	const char *pw_pgname;
	const char *pw_pgtype;
	scf_instance_t *pw_inst;
	scf_service_t *pw_svc;
	scf_snapshot_t *pw_snap;
	scf_propertygroup_t *pw_pg;
	const char *pw_target;
	char *pw_tmpl_pgname;
};

typedef struct pg_tmpl_walk pg_tmpl_walk_t;

typedef int walk_template_inst_func_t(scf_service_t *_svc,
    scf_instance_t *_inst, pg_tmpl_walk_t *p);

struct scf_prop_tmpl {
	int prt_populated;
	scf_handle_t *prt_h;
	scf_pg_tmpl_t *prt_t;
	scf_propertygroup_t *prt_pg;
	char *prt_pg_name;
	scf_iter_t *prt_iter;
};

/*
 * Common server errors are usually passed back to the caller.  This
 * array defines them centrally so that they don't need to be enumerated
 * in every libscf call.
 */
static const scf_error_t errors_server[] = {
	SCF_ERROR_BACKEND_ACCESS,
	SCF_ERROR_CONNECTION_BROKEN,
	SCF_ERROR_DELETED,
	SCF_ERROR_HANDLE_DESTROYED,
	SCF_ERROR_INTERNAL,
	SCF_ERROR_NO_MEMORY,
	SCF_ERROR_NO_RESOURCES,
	SCF_ERROR_NOT_BOUND,
	SCF_ERROR_PERMISSION_DENIED,
	0
	};

/*
 * int ismember()
 *
 * Returns 1 if the supplied error is a member of the error array, 0
 * if it is not.
 */
int
ismember(const scf_error_t error, const scf_error_t error_array[])
{
	int i;

	for (i = 0; error_array[i] != 0; ++i) {
		if (error == error_array[i])
			return (1);
	}

	return (0);
}

/*
 * char *_scf_tmpl_get_fmri()
 *
 * Given a pg_tmpl, returns the FMRI of the service or instance that
 * template describes.  The allocated string must be freed with free().
 *
 * On failure, returns NULL and sets scf_error() to _CONNECTION_BROKEN,
 * _DELETED, or _NO_MEMORY.
 */
static char *
_scf_tmpl_get_fmri(const scf_pg_tmpl_t *t)
{
	ssize_t sz = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH) + 1;
	int r;
	char *buf = malloc(sz);

	assert(t->pt_svc != NULL || t->pt_inst != NULL);
	assert(t->pt_svc == NULL || t->pt_inst == NULL);

	if (buf == NULL) {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
		return (buf);
	}

	if (t->pt_inst != NULL)
		r = scf_instance_to_fmri(t->pt_inst, buf, sz);
	else
		r = scf_service_to_fmri(t->pt_svc, buf, sz);

	if (r == -1) {
		if (ismember(scf_error(), errors_server)) {
			free(buf);
			buf = NULL;
		} else {
			assert(0);
			abort();
		}
	}

	return (buf);
}

/*
 * char *_scf_get_pg_type()
 *
 * Given a propertygroup, returns an allocated string containing the
 * type.  The string must be freed with free().
 *
 * On failure, returns NULL and sets scf_error() to: _CONNECTION_BROKEN,
 * _DELETED, or _NO_MEMORY.
 */
static char *
_scf_get_pg_type(scf_propertygroup_t *pg)
{
	ssize_t sz = scf_limit(SCF_LIMIT_MAX_PG_TYPE_LENGTH) + 1;
	char *buf = malloc(sz);

	if (buf == NULL) {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
	} else if (scf_pg_get_type(pg, buf, sz) == -1) {
		if (ismember(scf_error(), errors_server)) {
			free(buf);
			buf = NULL;
		} else {
			assert(0);
			abort();
		}
	}

	return (buf);
}

/*
 * char *_scf_get_prop_name()
 *
 * Given a property, returns the name in an allocated string.  The string must
 * be freed with free().
 *
 * On error, returns NULL and sets scf_error() to _CONNECTION_BROKEN,
 * _DELETED, or _NO_MEMORY.
 */
static char *
_scf_get_prop_name(scf_property_t *prop)
{
	ssize_t sz = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH) + 1;
	char *buf = malloc(sz);

	if (buf == NULL) {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
	} else if (scf_property_get_name(prop, buf, sz) == -1) {
		if (ismember(scf_error(), errors_server)) {
			free(buf);
			buf = NULL;
		} else {
			assert(0);
			abort();
		}
	}

	return (buf);
}

/*
 * char *_scf_get_prop_type()
 *
 * Given a property, returns the type in an allocated string.  The string must
 * be freed with free().
 *
 * On error, returns NULL and sets scf_error() to _CONNECTION_BROKEN,
 * _DELETED, or _NO_MEMORY.
 */
static char *
_scf_get_prop_type(scf_property_t *prop)
{
	scf_type_t type;
	char *ret;

	if (scf_property_type(prop, &type) == -1) {
		if (ismember(scf_error(), errors_server)) {
			return (NULL);
		} else {
			assert(0);
			abort();
		}
	}

	ret = strdup(scf_type_to_string(type));
	if (ret == NULL)
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);

	return (ret);
}

/*
 * int _read_single_value_from_pg()
 *
 * Reads a single value from the pg and property name specified.  On success,
 * returns an allocated value that must be freed.
 *
 * Returns -1 on failure, sets scf_error() to:
 *  SCF_ERROR_BACKEND_ACCESS
 *  SCF_ERROR_CONNECTION_BROKEN
 *  SCF_ERROR_CONSTRAINT_VIOLATED
 *    Property has more than one value associated with it.
 *  SCF_ERROR_DELETED
 *  SCF_ERROR_HANDLE_DESTROYED
 *  SCF_ERROR_INTERNAL
 *  SCF_ERROR_INVALID_ARGUMENT
 *    prop_name not a valid property name.
 *  SCF_ERROR_NO_MEMORY
 *  SCF_ERROR_NO_RESOURCES
 *  SCF_ERROR_NOT_BOUND
 *  SCF_ERROR_NOT_FOUND
 *    Property doesn't exist or exists and has no value.
 *  SCF_ERROR_NOT_SET
 *    Property group specified by pg is not set.
 *  SCF_ERROR_PERMISSION_DENIED
 */
static int
_read_single_value_from_pg(scf_propertygroup_t *pg, const char *prop_name,
    scf_value_t **val)
{
	scf_handle_t *h;
	scf_property_t *prop;
	int ret = 0;

	assert(val != NULL);
	if ((h = scf_pg_handle(pg)) == NULL) {
		assert(scf_error() == SCF_ERROR_HANDLE_DESTROYED);
		return (-1);
	}

	prop = scf_property_create(h);
	*val = scf_value_create(h);

	if (prop == NULL || *val == NULL) {
		assert(scf_error() != SCF_ERROR_INVALID_ARGUMENT);
		goto read_single_value_from_pg_fail;
	}

	if (scf_pg_get_property(pg, prop_name, prop) != 0) {
		assert(scf_error() != SCF_ERROR_HANDLE_MISMATCH);
		goto read_single_value_from_pg_fail;
	}

	if (scf_property_get_value(prop, *val) == -1) {
		assert(scf_error() != SCF_ERROR_NOT_SET);
		assert(scf_error() != SCF_ERROR_HANDLE_MISMATCH);
		goto read_single_value_from_pg_fail;
	}

	goto read_single_value_from_pg_done;

read_single_value_from_pg_fail:
	scf_value_destroy(*val);
	*val = NULL;
	ret = -1;

read_single_value_from_pg_done:
	scf_property_destroy(prop);
	return (ret);
}

/*
 * char *_scf_read_single_astring_from_pg()
 *
 * Reads an astring from the pg and property name specified.  On success,
 * returns an allocated string.  The string must be freed with free().
 *
 * Returns NULL on failure, sets scf_error() to:
 *   SCF_ERROR_BACKEND_ACCESS
 *   SCF_ERROR_CONNECTION_BROKEN
 *   SCF_ERROR_CONSTRAINT_VIOLATED
 *     Property has more than one value associated with it.
 *   SCF_ERROR_DELETED
 *   SCF_ERROR_HANDLE_DESTROYED
 *   SCF_ERROR_INTERNAL
 *   SCF_ERROR_INVALID_ARGUMENT
 *     prop_name not a valid property name.
 *   SCF_ERROR_NO_MEMORY
 *   SCF_ERROR_NO_RESOURCES
 *   SCF_ERROR_NOT_BOUND
 *   SCF_ERROR_NOT_FOUND
 *     Property doesn't exist or exists and has no value.
 *   SCF_ERROR_NOT_SET
 *     The property group specified by pg is not set.
 *   SCF_ERROR_PERMISSION_DENIED
 *   SCF_ERROR_TYPE_MISMATCH
 */
char *
_scf_read_single_astring_from_pg(scf_propertygroup_t *pg, const char *prop_name)
{
	scf_value_t *val;
	char *ret = NULL;
	ssize_t rsize = scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH) + 1;

	assert(rsize != 0);
	if (_read_single_value_from_pg(pg, prop_name, &val) == -1)
		return (NULL);

	ret = malloc(rsize);
	if (ret == NULL) {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
		goto cleanup;
	}

	if (scf_value_get_astring(val, ret, rsize) < 0) {
		assert(scf_error() != SCF_ERROR_NOT_SET);
		free(ret);
		ret = NULL;
	}

cleanup:
	scf_value_destroy(val);
	return (ret);
}

/*
 * char *_scf_read_tmpl_prop_type_as_string()
 *
 * Reads the property type and returns it as an allocated string.  The string
 * must be freed with free().
 *
 * Returns NULL on failure, sets scf_error() to _BACKEND_ACCESS,
 * _CONNECTION_BROKEN, _DELETED, _HANDLE_DESTROYED, _INTERNAL, _NO_MEMORY,
 * _NO_RESOURCES, _NOT_BOUND, _PERMISSION_DENIED, or _TEMPLATE_INVALID.
 */
char *
_scf_read_tmpl_prop_type_as_string(const scf_prop_tmpl_t *pt)
{
	char *type;

	type = _scf_read_single_astring_from_pg(pt->prt_pg,
	    SCF_PROPERTY_TM_TYPE);
	if (type == NULL) {
		if (ismember(scf_error(), errors_server)) {
			return (NULL);
		} else switch (scf_error()) {
		case SCF_ERROR_CONSTRAINT_VIOLATED:
		case SCF_ERROR_NOT_FOUND:
		case SCF_ERROR_TYPE_MISMATCH:
			(void) scf_set_error(SCF_ERROR_TEMPLATE_INVALID);
			return (NULL);

		case SCF_ERROR_INVALID_ARGUMENT:
		case SCF_ERROR_NOT_SET:
		default:
			assert(0);
			abort();
		}
	}

	return (type);
}

/*
 * int _read_single_boolean_from_pg()
 *
 * Reads a boolean from the pg and property name specified.
 *
 * Returns -1 on failure, sets scf_error() to:
 *   SCF_ERROR_BACKEND_ACCESS
 *   SCF_ERROR_CONNECTION_BROKEN
 *   SCF_ERROR_CONSTRAINT_VIOLATED
 *     Property has more than one value associated with it.
 *   SCF_ERROR_DELETED
 *   SCF_ERROR_HANDLE_DESTROYED
 *   SCF_ERROR_INTERNAL
 *   SCF_ERROR_INVALID_ARGUMENT
 *     prop_name is not a valid property name.
 *   SCF_ERROR_NO_MEMORY
 *   SCF_ERROR_NO_RESOURCES
 *   SCF_ERROR_NOT_BOUND
 *   SCF_ERROR_NOT_FOUND
 *     Property doesn't exist or exists and has no value.
 *   SCF_ERROR_NOT_SET
 *     The property group specified by pg is not set.
 *   SCF_ERROR_PERMISSION_DENIED
 *   SCF_ERROR_TYPE_MISMATCH
 */
static int
_read_single_boolean_from_pg(scf_propertygroup_t *pg, const char *prop_name,
    uint8_t *bool)
{
	scf_value_t *val;
	int ret = 0;

	if (_read_single_value_from_pg(pg, prop_name, &val) == -1)
		return (-1);

	if (scf_value_get_boolean(val, bool) < 0) {
		assert(scf_error() != SCF_ERROR_NOT_SET);
		ret = -1;
	}

	scf_value_destroy(val);
	return (ret);
}

/*
 * static char ** _append_astrings_values()
 *
 * This function reads the values from the property prop_name in pg and
 * appends to an existing scf_values_t *vals.  vals may be empty, but
 * must exist.  The function skips over zero-length and duplicate values.
 *
 * Returns NULL on failure, sets scf_error() to:
 *   SCF_ERROR_BACKEND_ACCESS
 *   SCF_ERROR_CONNECTION_BROKEN
 *   SCF_ERROR_DELETED
 *   SCF_ERROR_HANDLE_DESTROYED
 *   SCF_ERROR_INTERNAL
 *   SCF_ERROR_INVALID_ARGUMENT
 *     prop_name is not a valid property name.
 *   SCF_ERROR_NO_MEMORY
 *   SCF_ERROR_NO_RESOURCES
 *   SCF_ERROR_NOT_BOUND
 *   SCF_ERROR_NOT_FOUND
 *   SCF_ERROR_NOT_SET
 *   SCF_ERROR_PERMISSION_DENIED
 *   SCF_ERROR_TYPE_MISMATCH
 */
static char **
_append_astrings_values(scf_propertygroup_t *pg, const char *prop_name,
    scf_values_t *vals)
{
	scf_handle_t *h;
	scf_property_t *prop;
	scf_value_t *val;
	scf_iter_t *iter;
	ssize_t rsize = scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH) + 1;
	int err, count, cursz, i;

	assert(vals != NULL);
	assert(vals->value_type == SCF_TYPE_ASTRING);
	assert(vals->reserved == NULL);
	count = vals->value_count;
	if (count == 0) {
		cursz = 8;
		vals->values.v_astring = calloc(cursz, sizeof (char *));
		if (vals->values.v_astring == NULL) {
			(void) scf_set_error(SCF_ERROR_NO_MEMORY);
			return (NULL);
		}
	} else {
		/*
		 * The array may be bigger, but it is irrelevant since
		 * we will always re-allocate a new one.
		 */
		cursz = count;
	}

	if ((h = scf_pg_handle(pg)) == NULL) {
		assert(scf_error() == SCF_ERROR_HANDLE_DESTROYED);
		return (NULL);
	}

	prop = scf_property_create(h);
	val = scf_value_create(h);
	iter = scf_iter_create(h);

	if (prop == NULL || val == NULL || iter == NULL) {
		assert(scf_error() != SCF_ERROR_INVALID_ARGUMENT);
		goto append_single_astring_from_pg_fail;
	}

	if (scf_pg_get_property(pg, prop_name, prop) != 0) {
		assert(scf_error() != SCF_ERROR_HANDLE_MISMATCH);
		goto append_single_astring_from_pg_fail;
	}

	if (scf_iter_property_values(iter, prop) != 0) {
		assert(scf_error() != SCF_ERROR_NOT_SET);
		assert(scf_error() != SCF_ERROR_HANDLE_MISMATCH);
		goto append_single_astring_from_pg_fail;
	}

	while ((err = scf_iter_next_value(iter, val)) == 1) {
		int flag;
		int r;

		if (count + 1 >= cursz) {
			void *aux;

			cursz *= 2;
			if ((aux = calloc(cursz, sizeof (char *))) == NULL) {
				(void) scf_set_error(SCF_ERROR_NO_MEMORY);
				goto append_single_astring_from_pg_fail;
			}
			(void) memcpy(aux, vals->values.v_astring,
			    count * sizeof (char *));
			free(vals->values.v_astring);
			vals->values.v_astring = aux;
		}

		vals->values.v_astring[count] = malloc(rsize);
		if (vals->values.v_astring[count] == NULL) {
			(void) scf_set_error(SCF_ERROR_NO_MEMORY);
			goto append_single_astring_from_pg_fail;
		}

		if ((r = scf_value_get_astring(val,
		    vals->values.v_astring[count], rsize)) <= 0) {
			/* discard zero length strings */
			if (r == 0) {
				free(vals->values.v_astring[count]);
				continue;
			}
			assert(scf_error() != SCF_ERROR_NOT_SET);
			goto append_single_astring_from_pg_fail;
		}
		for (i = 0, flag = 0; i < count; ++i) {
			/* find  and discard duplicates */
			if (strncmp(vals->values.v_astring[i],
			    vals->values.v_astring[count], rsize) == 0) {
				free(vals->values.v_astring[count]);
				flag = 1;
				break;
			}
		}
		if (flag == 1)
			continue;

		count++;
	}

	vals->value_count = count;

	if (err != 0) {
		assert(scf_error() != SCF_ERROR_NOT_SET);
		assert(scf_error() != SCF_ERROR_INVALID_ARGUMENT);
		assert(scf_error() != SCF_ERROR_HANDLE_MISMATCH);
		goto append_single_astring_from_pg_fail;
	} else {
		vals->values_as_strings = vals->values.v_astring;
	}

	goto append_single_astring_from_pg_done;

append_single_astring_from_pg_fail:
	for (i = 0; i <= count; ++i) {
		if (vals->values.v_astring[i] != NULL)
			free(vals->values.v_astring[i]);
		vals->values.v_astring[i] = NULL;
	}
	free(vals->values.v_astring);
	vals->values.v_astring = NULL;
	vals->value_count = 0;

append_single_astring_from_pg_done:
	scf_iter_destroy(iter);
	scf_property_destroy(prop);
	scf_value_destroy(val);
	return (vals->values.v_astring);
}

/*
 * Returns NULL on failure, sets scf_error() to:
 *   SCF_ERROR_BACKEND_ACCESS
 *   SCF_ERROR_CONNECTION_BROKEN
 *   SCF_ERROR_DELETED
 *   SCF_ERROR_HANDLE_DESTROYED
 *   SCF_ERROR_INTERNAL
 *   SCF_ERROR_INVALID_ARGUMENT
 *     prop_name is not a valid property name.
 *   SCF_ERROR_NO_MEMORY
 *   SCF_ERROR_NO_RESOURCES
 *   SCF_ERROR_NOT_BOUND
 *   SCF_ERROR_NOT_FOUND
 *   SCF_ERROR_NOT_SET
 *   SCF_ERROR_PERMISSION_DENIED
 *   SCF_ERROR_TYPE_MISMATCH
 */
static char **
_read_astrings_values(scf_propertygroup_t *pg, const char *prop_name,
    scf_values_t *vals)
{
	assert(vals != NULL);
	vals->value_count = 0;
	vals->value_type = SCF_TYPE_ASTRING;
	vals->reserved = NULL;
	return (_append_astrings_values(pg, prop_name, vals));
}

void
_scf_sanitize_locale(char *locale)
{
	for (; *locale != '\0'; locale++)
		if (!isalnum(*locale) && *locale != '_')
			*locale = '_';
}

/*
 * The returned string needs to be freed by the caller
 * Returns NULL on failure.  Sets scf_error() to:
 *   SCF_ERROR_NO_MEMORY
 *   SCF_ERROR_INVALID_ARGUMENT
 *     Name isn't short enough to add the locale to.
 */
static char *
_add_locale_to_name(const char *name, const char *locale)
{
	char *lname = NULL;
	ssize_t lsz;
	char *loc;

	if (locale == NULL)
		locale = setlocale(LC_MESSAGES, NULL);
	loc = strdup(locale);
	if (loc == NULL) {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
		return (NULL);
	} else {
		_scf_sanitize_locale(loc);
	}

	lsz = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH) + 1;
	lname = malloc(lsz);
	if (lname == NULL) {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
		goto cleanup;
	}

	(void) strlcpy(lname, name, lsz);
	if (strlcat(lname, loc, lsz) >= lsz) {
		(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
		free(lname);
		lname = NULL;
	}
cleanup:
	free(loc);

	return (lname);
}

/*
 * char *_tmpl_pg_name(pg, type, use_type)
 *
 * pg and type can both be NULL.  Returns the name of the most specific
 * template property group name based on the inputs.
 * If use_type is set and pg is not NULL, a property group name for a
 * property group template that has type defined is returned, even if no
 * type is provided.
 *
 * Returns NULL on failure and sets scf_error() to:
 *   SCF_ERROR_INVALID_ARGUMENT
 *     can't combine the arguments and get a reasonable length name
 *   SCF_ERROR_NO_MEMORY
 *
 */
static char *
_tmpl_pg_name(const char *pg, const char *type, int use_type)
{
	char *name;
	ssize_t limit, size = 0;

	limit = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH) + 1;
	name = malloc(limit);
	if (name == NULL) {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
		return (NULL);
	}

	if (pg == NULL && type == NULL) {
		if (strlcpy(name, SCF_PG_TM_PG_PATTERN_PREFIX, limit) >=
		    limit) {
			assert(0);
			abort();
		}
		return (name);
	} else if (pg != NULL && type != NULL) {
		size = snprintf(name, limit, "%s%s",
		    SCF_PG_TM_PG_PATTERN_NT_PREFIX, pg);
	} else if (pg != NULL && type == NULL && use_type == 1) {
		size = snprintf(name, limit, "%s%s",
		    SCF_PG_TM_PG_PATTERN_NT_PREFIX, pg);
	} else if (pg != NULL && type == NULL) {
		size = snprintf(name, limit, "%s%s",
		    SCF_PG_TM_PG_PATTERN_N_PREFIX, pg);
	} else if (type != NULL && pg == NULL) {
		size = snprintf(name, limit, "%s%s",
		    SCF_PG_TM_PG_PATTERN_T_PREFIX, type);
	} else {
		assert(0);
		abort();
	}

	if (size >= limit) {
		(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
		free(name);
		return (NULL);
	} else {
		return (name);
	}
}

/*
 * _scf_get_pg_name()
 * Gets the name of the supplied property group.  On success, returns an
 * allocated string.  The string must be freed by free().
 *
 * Returns NULL on failure and sets scf_error() to _CONNECTION_BROKEN,
 * _DELETED, or _NO_MEMORY.
 */
static char *
_scf_get_pg_name(scf_propertygroup_t *pg)
{
	ssize_t sz = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH) + 1;
	char *buf = malloc(sz);

	if (buf == NULL) {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
	} else if (scf_pg_get_name(pg, buf, sz) == -1) {
		if (ismember(scf_error(), errors_server)) {
			free(buf);
			buf = NULL;
		} else {
			assert(0);
			abort();
		}
	}

	return (buf);
}

/*
 * char *_tmpl_prop_name()
 *
 * Returns the name of the property template prop (which is the name of
 * the property template property group) in the property group
 * template t. Returns NULL on failure and sets scf_error() to:
 *   SCF_ERROR_CONNECTION_BROKEN
 *   SCF_ERROR_DELETED
 *   SCF_ERROR_INVALID_ARGUMENT
 *     can't combine the arguments and get a reasonable length name
 *   SCF_ERROR_NO_MEMORY
 */
static char *
_tmpl_prop_name(const char *prop, scf_pg_tmpl_t *t)
{
	char *name = NULL, *pg_name = NULL;
	size_t prefix_size;
	ssize_t limit, size = 0;

	assert(prop != NULL);
	assert(t->pt_pg != NULL);

	limit = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH) + 1;
	name = malloc(limit);
	if (name == NULL) {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
		return (NULL);
	}

	if ((pg_name = _scf_get_pg_name(t->pt_pg)) == NULL) {
		free(name);
		return (NULL);
	}

	prefix_size = strlen(SCF_PG_TM_PG_PAT_BASE);
	if (strncmp(pg_name, SCF_PG_TM_PG_PAT_BASE, prefix_size) != 0) {
		(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
		free(name);
		free(pg_name);
		return (NULL);
	}

	size = snprintf(name, limit, "%s%s_%s", SCF_PG_TM_PROP_PATTERN_PREFIX,
	    pg_name + prefix_size, prop);

	if (size >= limit) {
		(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
		free(name);
		free(pg_name);
		return (NULL);
	} else {
		free(pg_name);
		return (name);
	}
}

/*
 *  int _get_snapshot()
 *
 *  Gets the specified snapshot.  If "snapshot" isn't defined, use the
 *  running snapshot.  If the snapshot isn't found, that may or may
 *  not be an error depending on the caller.  Return 0 in that case,
 *  but leave scf_error() set to SCF_ERROR_NOT_FOUND.  On all other
 *  errors, set scf_error() to:
 *   SCF_ERROR_BACKEND_ACCESS
 *   SCF_ERROR_CONNECTION_BROKEN
 *   SCF_ERROR_DELETED
 *   SCF_ERR_HANDLE_DESTROYED
 *   SCF_ERROR_INTERNAL
 *   SCF_ERROR_INVALID_ARGUMENT
 *     The handle argument is NULL, or snaphot is not a valid snapshot name
 *   SCF_ERROR_NO_MEMORY
 *   SCF_ERROR_NO_RESOURCES
 *   SCF_ERROR_NOT_BOUND
 *   SCF_ERROR_NOT_FOUND
 */
static int
_get_snapshot(scf_instance_t *inst, const char *snapshot,
    scf_snapshot_t **snap)
{
	int err;
	scf_handle_t *h;

	h = scf_instance_handle(inst);
	if (h == NULL) {
		*snap = NULL;
		return (-1);
	}

	if ((*snap = scf_snapshot_create(h)) == NULL) {
		return (-1);
	}

	/* Use running snapshot by default. */
	if (snapshot == NULL)
		err = scf_instance_get_snapshot(inst, "running", *snap);
	else
		err = scf_instance_get_snapshot(inst, snapshot, *snap);

	if (err != 0) {
		if (ismember(scf_error(), errors_server)) {
			scf_snapshot_destroy(*snap);
			*snap = NULL;
			return (-1);
		} else switch (scf_error()) {
		case SCF_ERROR_INVALID_ARGUMENT:
			scf_snapshot_destroy(*snap);
			*snap = NULL;