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

/*
 * This is the main implementation file for the low-level repository
 * interface.
 */

#include "lowlevel_impl.h"

#include "repcache_protocol.h"
#include "scf_type.h"

#include <assert.h>
#include <alloca.h>
#include <door.h>
#include <errno.h>
#include <fcntl.h>
#include <fnmatch.h>
#include <libuutil.h>
#include <poll.h>
#include <pthread.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/sysmacros.h>
#include <unistd.h>

#define	ENV_SCF_DEBUG		"LIBSCF_DEBUG"
#define	ENV_SCF_DOORPATH	"LIBSCF_DOORPATH"

static uint32_t default_debug = 0;
static const char *default_door_path = REPOSITORY_DOOR_NAME;

#define	CALL_FAILED		-1
#define	RESULT_TOO_BIG		-2
#define	NOT_BOUND		-3

static pthread_mutex_t	lowlevel_init_lock;
static int32_t		lowlevel_inited;

static uu_list_pool_t	*tran_entry_pool;
static uu_list_pool_t	*datael_pool;
static uu_list_pool_t	*iter_pool;

/*
 * base32[] index32[] are used in base32 encoding and decoding.
 */
static char base32[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
static char index32[128] = {
	-1, -1, -1, -1, -1, -1, -1, -1,	/* 0-7 */
	-1, -1, -1, -1, -1, -1, -1, -1,	/* 8-15 */
	-1, -1, -1, -1, -1, -1, -1, -1,	/* 16-23 */
	-1, -1, -1, -1, -1, -1, -1, -1,	/* 24-31 */
	-1, -1, -1, -1, -1, -1, -1, -1,	/* 32-39 */
	-1, -1, -1, -1, -1, -1, -1, -1,	/* 40-47 */
	-1, -1, 26, 27, 28, 29, 30, 31,	/* 48-55 */
	-1, -1, -1, -1, -1, -1, -1, -1,	/* 56-63 */
	-1, 0, 1, 2, 3, 4, 5, 6,	/* 64-71 */
	7, 8, 9, 10, 11, 12, 13, 14,	/* 72-79 */
	15, 16, 17, 18, 19, 20, 21, 22,	/* 80-87 */
	23, 24, 25, -1, -1, -1, -1, -1,	/* 88-95 */
	-1, -1, -1, -1, -1, -1, -1, -1,	/* 96-103 */
	-1, -1, -1, -1, -1, -1, -1, -1,	/* 104-111 */
	-1, -1, -1, -1, -1, -1, -1, -1,	/* 112-119 */
	-1, -1, -1, -1, -1, -1, -1, -1	/* 120-127 */
};

#define	DECODE32_GS	(8)	/* scf_decode32 group size */

/*
 * We want MUTEX_HELD, but we also want pthreads.
 */
struct _lwp_mutex;
extern int _mutex_held(struct _lwp_mutex *);
#define	MUTEX_HELD(m)		_mutex_held((struct _lwp_mutex *)(m))

#ifdef lint
#define	assert_nolint(x) (void)0
#else
#define	assert_nolint(x) assert(x)
#endif

static void scf_iter_reset_locked(scf_iter_t *iter);
static void scf_value_reset_locked(scf_value_t *val, int and_destroy);

#define	TYPE_VALUE	(-100)

/*
 * Hold and release subhandles.  We only allow one thread access to the
 * subhandles at a time, and he can use any subset, grabbing and releasing
 * them in any order.  The only restrictions are that you cannot hold an
 * already-held subhandle, and all subhandles must be released before
 * returning to the original caller.
 */
static void
handle_hold_subhandles(scf_handle_t *h, int mask)
{
	assert(mask != 0 && (mask & ~RH_HOLD_ALL) == 0);

	(void) pthread_mutex_lock(&h->rh_lock);
	while (h->rh_hold_flags != 0 && h->rh_holder != pthread_self()) {
		int cancel_state;

		(void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,
		    &cancel_state);
		(void) pthread_cond_wait(&h->rh_cv, &h->rh_lock);
		(void) pthread_setcancelstate(cancel_state, NULL);
	}
	if (h->rh_hold_flags == 0)
		h->rh_holder = pthread_self();
	assert(!(h->rh_hold_flags & mask));
	h->rh_hold_flags |= mask;
	(void) pthread_mutex_unlock(&h->rh_lock);
}

static void
handle_rele_subhandles(scf_handle_t *h, int mask)
{
	assert(mask != 0 && (mask & ~RH_HOLD_ALL) == 0);

	(void) pthread_mutex_lock(&h->rh_lock);
	assert(h->rh_holder == pthread_self());
	assert((h->rh_hold_flags & mask));

	h->rh_hold_flags &= ~mask;
	if (h->rh_hold_flags == 0)
		(void) pthread_cond_signal(&h->rh_cv);
	(void) pthread_mutex_unlock(&h->rh_lock);
}

#define	HOLD_HANDLE(h, flag, field) \
	(handle_hold_subhandles((h), (flag)), (h)->field)

#define	RELE_HANDLE(h, flag) \
	(handle_rele_subhandles((h), (flag)))

/*
 * convenience macros, for functions that only need a one or two handles at
 * any given time
 */
#define	HANDLE_HOLD_ITER(h)	HOLD_HANDLE((h), RH_HOLD_ITER, rh_iter)
#define	HANDLE_HOLD_SCOPE(h)	HOLD_HANDLE((h), RH_HOLD_SCOPE, rh_scope)
#define	HANDLE_HOLD_SERVICE(h)	HOLD_HANDLE((h), RH_HOLD_SERVICE, rh_service)
#define	HANDLE_HOLD_INSTANCE(h)	HOLD_HANDLE((h), RH_HOLD_INSTANCE, rh_instance)
#define	HANDLE_HOLD_SNAPSHOT(h)	HOLD_HANDLE((h), RH_HOLD_SNAPSHOT, rh_snapshot)
#define	HANDLE_HOLD_SNAPLVL(h)	HOLD_HANDLE((h), RH_HOLD_SNAPLVL, rh_snaplvl)
#define	HANDLE_HOLD_PG(h)	HOLD_HANDLE((h), RH_HOLD_PG, rh_pg)
#define	HANDLE_HOLD_PROPERTY(h)	HOLD_HANDLE((h), RH_HOLD_PROPERTY, rh_property)
#define	HANDLE_HOLD_VALUE(h)	HOLD_HANDLE((h), RH_HOLD_VALUE, rh_value)

#define	HANDLE_RELE_ITER(h)	RELE_HANDLE((h), RH_HOLD_ITER)
#define	HANDLE_RELE_SCOPE(h)	RELE_HANDLE((h), RH_HOLD_SCOPE)
#define	HANDLE_RELE_SERVICE(h)	RELE_HANDLE((h), RH_HOLD_SERVICE)
#define	HANDLE_RELE_INSTANCE(h)	RELE_HANDLE((h), RH_HOLD_INSTANCE)
#define	HANDLE_RELE_SNAPSHOT(h)	RELE_HANDLE((h), RH_HOLD_SNAPSHOT)
#define	HANDLE_RELE_SNAPLVL(h)	RELE_HANDLE((h), RH_HOLD_SNAPLVL)
#define	HANDLE_RELE_PG(h)	RELE_HANDLE((h), RH_HOLD_PG)
#define	HANDLE_RELE_PROPERTY(h)	RELE_HANDLE((h), RH_HOLD_PROPERTY)
#define	HANDLE_RELE_VALUE(h)	RELE_HANDLE((h), RH_HOLD_VALUE)

/*ARGSUSED*/
static int
transaction_entry_compare(const void *l_arg, const void *r_arg, void *private)
{
	const char *l_prop =
	    ((scf_transaction_entry_t *)l_arg)->entry_property;
	const char *r_prop =
	    ((scf_transaction_entry_t *)r_arg)->entry_property;

	int ret;

	ret = strcmp(l_prop, r_prop);
	if (ret > 0)
		return (1);
	if (ret < 0)
		return (-1);
	return (0);
}

static int
datael_compare(const void *l_arg, const void *r_arg, void *private)
{
	uint32_t l_id = ((scf_datael_t *)l_arg)->rd_entity;
	uint32_t r_id = (r_arg != NULL) ? ((scf_datael_t *)r_arg)->rd_entity :
	    *(uint32_t *)private;

	if (l_id > r_id)
		return (1);
	if (l_id < r_id)
		return (-1);
	return (0);
}

static int
iter_compare(const void *l_arg, const void *r_arg, void *private)
{
	uint32_t l_id = ((scf_iter_t *)l_arg)->iter_id;
	uint32_t r_id = (r_arg != NULL) ? ((scf_iter_t *)r_arg)->iter_id :
	    *(uint32_t *)private;

	if (l_id > r_id)
		return (1);
	if (l_id < r_id)
		return (-1);
	return (0);
}

static int
lowlevel_init(void)
{
	const char *debug;
	const char *door_path;

	(void) pthread_mutex_lock(&lowlevel_init_lock);
	if (lowlevel_inited == 0) {
		if (!issetugid() &&
		    (debug = getenv(ENV_SCF_DEBUG)) != NULL && debug[0] != 0 &&
		    uu_strtoint(debug, &default_debug, sizeof (default_debug),
		    0, 0, 0) == -1) {
			(void) fprintf(stderr, "LIBSCF: $%s (%s): %s",
			    ENV_SCF_DEBUG, debug,
			    uu_strerror(uu_error()));
		}

		if (!issetugid() &&
		    (door_path = getenv(ENV_SCF_DOORPATH)) != NULL &&
		    door_path[0] != 0) {
			default_door_path = strdup(door_path);
			if (default_door_path == NULL)
				default_door_path = door_path;
		}

		datael_pool = uu_list_pool_create("SUNW,libscf_datael",
		    sizeof (scf_datael_t), offsetof(scf_datael_t, rd_node),
		    datael_compare, UU_LIST_POOL_DEBUG);

		iter_pool = uu_list_pool_create("SUNW,libscf_iter",
		    sizeof (scf_iter_t), offsetof(scf_iter_t, iter_node),
		    iter_compare, UU_LIST_POOL_DEBUG);

		assert_nolint(offsetof(scf_transaction_entry_t,
		    entry_property) == 0);
		tran_entry_pool = uu_list_pool_create(
		    "SUNW,libscf_transaction_entity",
		    sizeof (scf_transaction_entry_t),
		    offsetof(scf_transaction_entry_t, entry_link),
		    transaction_entry_compare, UU_LIST_POOL_DEBUG);

		if (datael_pool == NULL || iter_pool == NULL ||
		    tran_entry_pool == NULL) {
			lowlevel_inited = -1;
			goto end;
		}

		if (!scf_setup_error()) {
			lowlevel_inited = -1;
			goto end;
		}
		lowlevel_inited = 1;
	}
end:
	(void) pthread_mutex_unlock(&lowlevel_init_lock);
	if (lowlevel_inited > 0)
		return (1);
	return (0);
}

static const struct {
	scf_type_t ti_type;
	rep_protocol_value_type_t ti_proto_type;
	const char *ti_name;
} scf_type_info[] = {
	{SCF_TYPE_BOOLEAN,	REP_PROTOCOL_TYPE_BOOLEAN,	"boolean"},
	{SCF_TYPE_COUNT,	REP_PROTOCOL_TYPE_COUNT,	"count"},
	{SCF_TYPE_INTEGER,	REP_PROTOCOL_TYPE_INTEGER,	"integer"},
	{SCF_TYPE_TIME,		REP_PROTOCOL_TYPE_TIME,		"time"},
	{SCF_TYPE_ASTRING,	REP_PROTOCOL_TYPE_STRING,	"astring"},
	{SCF_TYPE_OPAQUE,	REP_PROTOCOL_TYPE_OPAQUE,	"opaque"},
	{SCF_TYPE_USTRING,	REP_PROTOCOL_SUBTYPE_USTRING,	"ustring"},
	{SCF_TYPE_URI,		REP_PROTOCOL_SUBTYPE_URI,	"uri"},
	{SCF_TYPE_FMRI,		REP_PROTOCOL_SUBTYPE_FMRI,	"fmri"},
	{SCF_TYPE_HOST,		REP_PROTOCOL_SUBTYPE_HOST,	"host"},
	{SCF_TYPE_HOSTNAME,	REP_PROTOCOL_SUBTYPE_HOSTNAME,	"hostname"},
	{SCF_TYPE_NET_ADDR_V4,	REP_PROTOCOL_SUBTYPE_NETADDR_V4,
	    "net_address_v4"},
	{SCF_TYPE_NET_ADDR_V6,	REP_PROTOCOL_SUBTYPE_NETADDR_V6,
	    "net_address_v6"}
};

#define	SCF_TYPE_INFO_COUNT (sizeof (scf_type_info) / sizeof (*scf_type_info))
static rep_protocol_value_type_t
scf_type_to_protocol_type(scf_type_t t)
{
	int i;

	for (i = 0; i < SCF_TYPE_INFO_COUNT; i++)
		if (scf_type_info[i].ti_type == t)
			return (scf_type_info[i].ti_proto_type);

	return (REP_PROTOCOL_TYPE_INVALID);
}

static scf_type_t
scf_protocol_type_to_type(rep_protocol_value_type_t t)
{
	int i;

	for (i = 0; i < SCF_TYPE_INFO_COUNT; i++)
		if (scf_type_info[i].ti_proto_type == t)
			return (scf_type_info[i].ti_type);

	return (SCF_TYPE_INVALID);
}

const char *
scf_type_to_string(scf_type_t ty)
{
	int i;

	for (i = 0; i < SCF_TYPE_INFO_COUNT; i++)
		if (scf_type_info[i].ti_type == ty)
			return (scf_type_info[i].ti_name);

	return ("unknown");
}

scf_type_t
scf_string_to_type(const char *name)
{
	int i;

	for (i = 0; i < sizeof (scf_type_info) / sizeof (*scf_type_info); i++)
		if (strcmp(scf_type_info[i].ti_name, name) == 0)
			return (scf_type_info[i].ti_type);

	return (SCF_TYPE_INVALID);
}

int
scf_type_base_type(scf_type_t type, scf_type_t *out)
{
	rep_protocol_value_type_t t = scf_type_to_protocol_type(type);
	if (t == REP_PROTOCOL_TYPE_INVALID)
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));

	*out = scf_protocol_type_to_type(scf_proto_underlying_type(t));
	return (SCF_SUCCESS);
}

/*
 * Convert a protocol error code into an SCF_ERROR_* code.
 */
static scf_error_t
proto_error(rep_protocol_responseid_t e)
{
	switch (e) {
	case REP_PROTOCOL_FAIL_MISORDERED:
	case REP_PROTOCOL_FAIL_UNKNOWN_ID:
	case REP_PROTOCOL_FAIL_INVALID_TYPE:
	case REP_PROTOCOL_FAIL_TRUNCATED:
	case REP_PROTOCOL_FAIL_TYPE_MISMATCH:
	case REP_PROTOCOL_FAIL_NOT_APPLICABLE:
	case REP_PROTOCOL_FAIL_UNKNOWN:
		return (SCF_ERROR_INTERNAL);

	case REP_PROTOCOL_FAIL_BAD_TX:
		return (SCF_ERROR_INVALID_ARGUMENT);
	case REP_PROTOCOL_FAIL_BAD_REQUEST:
		return (SCF_ERROR_INVALID_ARGUMENT);
	case REP_PROTOCOL_FAIL_NO_RESOURCES:
		return (SCF_ERROR_NO_RESOURCES);
	case REP_PROTOCOL_FAIL_NOT_FOUND:
		return (SCF_ERROR_NOT_FOUND);
	case REP_PROTOCOL_FAIL_DELETED:
		return (SCF_ERROR_DELETED);
	case REP_PROTOCOL_FAIL_NOT_SET:
		return (SCF_ERROR_NOT_SET);
	case REP_PROTOCOL_FAIL_EXISTS:
		return (SCF_ERROR_EXISTS);
	case REP_PROTOCOL_FAIL_DUPLICATE_ID:
		return (SCF_ERROR_EXISTS);
	case REP_PROTOCOL_FAIL_PERMISSION_DENIED:
		return (SCF_ERROR_PERMISSION_DENIED);
	case REP_PROTOCOL_FAIL_BACKEND_ACCESS:
		return (SCF_ERROR_BACKEND_ACCESS);
	case REP_PROTOCOL_FAIL_BACKEND_READONLY:
		return (SCF_ERROR_BACKEND_READONLY);

	case REP_PROTOCOL_SUCCESS:
	case REP_PROTOCOL_DONE:
	case REP_PROTOCOL_FAIL_NOT_LATEST:	/* TX code should handle this */
	default:
#ifndef NDEBUG
		uu_warn("%s:%d: Bad error code %d passed to proto_error().\n",
		    __FILE__, __LINE__, e);
#endif
		abort();
		/*NOTREACHED*/
	}
}

ssize_t
scf_limit(uint32_t limit)
{
	switch (limit) {
	case SCF_LIMIT_MAX_NAME_LENGTH:
	case SCF_LIMIT_MAX_PG_TYPE_LENGTH:
		return (REP_PROTOCOL_NAME_LEN - 1);
	case SCF_LIMIT_MAX_VALUE_LENGTH:
		return (REP_PROTOCOL_VALUE_LEN - 1);
	case SCF_LIMIT_MAX_FMRI_LENGTH:
		return (SCF_FMRI_PREFIX_MAX_LEN +
		    sizeof (SCF_FMRI_SCOPE_PREFIX) - 1 +
		    sizeof (SCF_FMRI_SCOPE_SUFFIX) - 1 +
		    sizeof (SCF_FMRI_SERVICE_PREFIX) - 1 +
		    sizeof (SCF_FMRI_INSTANCE_PREFIX) - 1 +
		    sizeof (SCF_FMRI_PROPERTYGRP_PREFIX) - 1 +
		    sizeof (SCF_FMRI_PROPERTY_PREFIX) - 1 +
		    5 * (REP_PROTOCOL_NAME_LEN - 1));
	default:
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
	}
}

static size_t
scf_opaque_decode(char *out_arg, const char *in, size_t max_out)
{
	char a, b;
	char *out = out_arg;

	while (max_out > 0 && (a = in[0]) != 0 && (b = in[1]) != 0) {
		in += 2;

		if (a >= '0' && a <= '9')
			a -= '0';
		else if (a >= 'a' && a <= 'f')
			a = a - 'a' + 10;
		else if (a >= 'A' && a <= 'F')
			a = a - 'A' + 10;
		else
			break;

		if (b >= '0' && b <= '9')
			b -= '0';
		else if (b >= 'a' && b <= 'f')
			b = b - 'a' + 10;
		else if (b >= 'A' && b <= 'F')
			b = b - 'A' + 10;
		else
			break;

		*out++ = (a << 4) | b;
		max_out--;
	}

	return (out - out_arg);
}

static size_t
scf_opaque_encode(char *out_arg, const char *in_arg, size_t in_sz)
{
	uint8_t *in = (uint8_t *)in_arg;
	uint8_t *end = in + in_sz;
	char *out = out_arg;

	if (out == NULL)
		return (2 * in_sz);

	while (in < end) {
		uint8_t c = *in++;

		uint8_t a = (c & 0xf0) >> 4;
		uint8_t b = (c & 0x0f);

		if (a <= 9)
			*out++ = a + '0';
		else
			*out++ = a + 'a' - 10;

		if (b <= 9)
			*out++ = b + '0';
		else
			*out++ = b + 'a' - 10;
	}

	*out = 0;

	return (out - out_arg);
}

static void
handle_do_close(scf_handle_t *h)
{
	assert(MUTEX_HELD(&h->rh_lock));
	assert(h->rh_doorfd != -1);

	/*
	 * if there are any active FD users, we just move the FD over
	 * to rh_doorfd_old -- they'll close it when they finish.
	 */
	if (h->rh_fd_users > 0) {
		h->rh_doorfd_old = h->rh_doorfd;
		h->rh_doorfd = -1;
	} else {
		assert(h->rh_doorfd_old == -1);
		(void) close(h->rh_doorfd);
		h->rh_doorfd = -1;
	}
}

/*
 * Check if a handle is currently bound.  fork()ing implicitly unbinds
 * the handle in the child.
 */
static int
handle_is_bound(scf_handle_t *h)
{
	assert(MUTEX_HELD(&h->rh_lock));

	if (h->rh_doorfd == -1)
		return (0);

	if (getpid() == h->rh_doorpid)
		return (1);

	/* forked since our last bind -- initiate handle close */
	handle_do_close(h);
	return (0);
}

static int
handle_has_server_locked(scf_handle_t *h)
{
	door_info_t i;
	assert(MUTEX_HELD(&h->rh_lock));

	return (handle_is_bound(h) && door_info(h->rh_doorfd, &i) != -1 &&
	    i.di_target != -1);
}

static int
handle_has_server(scf_handle_t *h)
{
	int ret;

	(void) pthread_mutex_lock(&h->rh_lock);
	ret = handle_has_server_locked(h);
	(void) pthread_mutex_unlock(&h->rh_lock);

	return (ret);
}

/*
 * This makes a door request on the client door associated with handle h.
 * It will automatically retry calls which fail on EINTR.  If h is not bound,
 * returns NOT_BOUND.  If the door call fails or the server response is too
 * small, returns CALL_FAILED.  If the server response is too big, truncates the
 * response and returns RESULT_TOO_BIG.  Otherwise, the size of the result is
 * returned.
 */
static ssize_t
make_door_call(scf_handle_t *h, const void *req, size_t req_sz,
    void *res, size_t res_sz)
{
	door_arg_t arg;
	int r;

	assert(MUTEX_HELD(&h->rh_lock));

	if (!handle_is_bound(h)) {
		return (NOT_BOUND);
	}

	arg.data_ptr = (void *)req;
	arg.data_size = req_sz;
	arg.desc_ptr = NULL;
	arg.desc_num = 0;
	arg.rbuf = res;
	arg.rsize = res_sz;

	while ((r = door_call(h->rh_doorfd, &arg)) < 0) {
		if (errno != EINTR)
			break;
	}

	if (r < 0) {
		return (CALL_FAILED);
	}

	if (arg.desc_num > 0) {
		while (arg.desc_num > 0) {
			if (arg.desc_ptr->d_attributes & DOOR_DESCRIPTOR) {
				int cfd = arg.desc_ptr->d_data.d_desc.d_id;
				(void) close(cfd);
			}
			arg.desc_ptr++;
			arg.desc_num--;
		}
	}
	if (arg.data_ptr != res && arg.data_size > 0)
		(void) memmove(res, arg.data_ptr, MIN(arg.data_size, res_sz));

	if (arg.rbuf != res)
		(void) munmap(arg.rbuf, arg.rsize);

	if (arg.data_size > res_sz)
		return (RESULT_TOO_BIG);

	if (arg.data_size < sizeof (uint32_t))
		return (CALL_FAILED);

	return (arg.data_size);
}

/*
 * Should only be used when r < 0.
 */
#define	DOOR_ERRORS_BLOCK(r)	{					\
	switch (r) {							\
	case NOT_BOUND:							\
		return (scf_set_error(SCF_ERROR_NOT_BOUND));		\
									\
	case CALL_FAILED:						\
		return (scf_set_error(SCF_ERROR_CONNECTION_BROKEN));	\
									\
	case RESULT_TOO_BIG:						\
		return (scf_set_error(SCF_ERROR_INTERNAL));		\
									\
	default:							\
		assert(r == NOT_BOUND || r == CALL_FAILED ||		\
		    r == RESULT_TOO_BIG);				\
		abort();						\
	}								\
}

/*
 * Like make_door_call(), but takes an fd instead of a handle, and expects
 * a single file descriptor, returned via res_fd.
 *
 * If no file descriptor is returned, *res_fd == -1.
 */
static int
make_door_call_retfd(int fd, const void *req, size_t req_sz, void *res,
    size_t res_sz, int *res_fd)
{
	door_arg_t arg;
	int r;
	char rbuf[256];

	*res_fd = -1;

	if (fd == -1)
		return (NOT_BOUND);

	arg.data_ptr = (void *)req;
	arg.data_size = req_sz;
	arg.desc_ptr = NULL;
	arg.desc_num = 0;
	arg.rbuf = rbuf;
	arg.rsize = sizeof (rbuf);

	while ((r = door_call(fd, &arg)) < 0) {
		if (errno != EINTR)
			break;
	}

	if (r < 0)
		return (CALL_FAILED);

	if (arg.desc_num > 1) {
		while (arg.desc_num > 0) {
			if (arg.desc_ptr->d_attributes & DOOR_DESCRIPTOR) {
				int cfd =
				    arg.desc_ptr->d_data.d_desc.d_descriptor;
				(void) close(cfd);
			}
			arg.desc_ptr++;
			arg.desc_num--;
		}
	}
	if (arg.desc_num == 1 && arg.desc_ptr->d_attributes & DOOR_DESCRIPTOR)
		*res_fd = arg.desc_ptr->d_data.d_desc.d_descriptor;

	if (arg.data_size > 0)
		(void) memmove(res, arg.data_ptr, MIN(arg.data_size, res_sz));

	if (arg.rbuf != rbuf)
		(void) munmap(arg.rbuf, arg.rsize);

	if (arg.data_size > res_sz)
		return (RESULT_TOO_BIG);

	if (arg.data_size < sizeof (uint32_t))
		return (CALL_FAILED);

	return (arg.data_size);
}

/*
 * Fails with
 *   _VERSION_MISMATCH
 *   _NO_MEMORY
 */
scf_handle_t *
scf_handle_create(scf_version_t v)
{
	scf_handle_t *ret;
	int failed;

	/*
	 * This will need to be revisited when we bump SCF_VERSION
	 */
	if (v != SCF_VERSION) {
		(void) scf_set_error(SCF_ERROR_VERSION_MISMATCH);
		return (NULL);
	}

	if (!lowlevel_init()) {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
		return (NULL);
	}

	ret = uu_zalloc(sizeof (*ret));
	if (ret == NULL) {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
		return (NULL);
	}

	ret->rh_dataels = uu_list_create(datael_pool, ret, 0);
	ret->rh_iters = uu_list_create(iter_pool, ret, 0);
	if (ret->rh_dataels == NULL || ret->rh_iters == NULL) {
		if (ret->rh_dataels != NULL)
			uu_list_destroy(ret->rh_dataels);
		if (ret->rh_iters != NULL)
			uu_list_destroy(ret->rh_iters);
		uu_free(ret);
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
		return (NULL);
	}

	ret->rh_doorfd = -1;
	ret->rh_doorfd_old = -1;
	(void) pthread_mutex_init(&ret->rh_lock, NULL);

	handle_hold_subhandles(ret, RH_HOLD_ALL);

	failed = ((ret->rh_iter = scf_iter_create(ret)) == NULL ||
	    (ret->rh_scope = scf_scope_create(ret)) == NULL ||
	    (ret->rh_service = scf_service_create(ret)) == NULL ||
	    (ret->rh_instance = scf_instance_create(ret)) == NULL ||
	    (ret->rh_snapshot = scf_snapshot_create(ret)) == NULL ||
	    (ret->rh_snaplvl = scf_snaplevel_create(ret)) == NULL ||
	    (ret->rh_pg = scf_pg_create(ret)) == NULL ||
	    (ret->rh_property = scf_property_create(ret)) == NULL ||
	    (ret->rh_value = scf_value_create(ret)) == NULL);

	/*
	 * these subhandles count as internal references, not external ones.
	 */
	ret->rh_intrefs = ret->rh_extrefs;
	ret->rh_extrefs = 0;
	handle_rele_subhandles(ret, RH_HOLD_ALL);

	if (failed) {
		scf_handle_destroy(ret);
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
		return (NULL);
	}

	scf_value_set_count(ret->rh_value, default_debug);
	(void) scf_handle_decorate(ret, "debug", ret->rh_value);

	return (ret);
}

int
scf_handle_decorate(scf_handle_t *handle, const char *name, scf_value_t *v)
{
	if (v != SCF_DECORATE_CLEAR && handle != v->value_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	(void) pthread_mutex_lock(&handle->rh_lock);
	if (handle_is_bound(handle)) {
		(void) pthread_mutex_unlock(&handle->rh_lock);
		return (scf_set_error(SCF_ERROR_IN_USE));
	}
	(void) pthread_mutex_unlock(&handle->rh_lock);

	if (strcmp(name, "debug") == 0) {
		if (v == SCF_DECORATE_CLEAR) {
			(void) pthread_mutex_lock(&handle->rh_lock);
			handle->rh_debug = 0;
			(void) pthread_mutex_unlock(&handle->rh_lock);
		} else {
			uint64_t val;
			if (scf_value_get_count(v, &val) < 0)
				return (-1);		/* error already set */

			(void) pthread_mutex_lock(&handle->rh_lock);
			handle->rh_debug = (uid_t)val;
			(void) pthread_mutex_unlock(&handle->rh_lock);
		}
		return (0);
	}
	if (strcmp(name, "door_path") == 0) {
		char name[sizeof (handle->rh_doorpath)];

		if (v == SCF_DECORATE_CLEAR) {
			(void) pthread_mutex_lock(&handle->rh_lock);
			handle->rh_doorpath[0] = 0;
			(void) pthread_mutex_unlock(&handle->rh_lock);
		} else {
			ssize_t len;

			if ((len = scf_value_get_astring(v, name,
			    sizeof (name))) < 0) {
				return (-1);		/* error already set */
			}
			if (len == 0 || len >= sizeof (name)) {
				return (scf_set_error(
				    SCF_ERROR_INVALID_ARGUMENT));
			}
			(void) pthread_mutex_lock(&handle->rh_lock);
			(void) strlcpy(handle->rh_doorpath, name,
			    sizeof (handle->rh_doorpath));
			(void) pthread_mutex_unlock(&handle->rh_lock);
		}
		return (0);
	}
	return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
}

/*
 * fails with INVALID_ARGUMENT and HANDLE_MISMATCH.
 */
int
_scf_handle_decorations(scf_handle_t *handle, scf_decoration_func *f,
    scf_value_t *v, void *data)
{
	scf_decoration_info_t i;
	char name[sizeof (handle->rh_doorpath)];
	uint64_t debug;

	if (f == NULL || v == NULL)
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));

	if (v->value_handle != handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	i.sdi_name = (const char *)"debug";
	i.sdi_type = SCF_TYPE_COUNT;
	(void) pthread_mutex_lock(&handle->rh_lock);
	debug = handle->rh_debug;
	(void) pthread_mutex_unlock(&handle->rh_lock);
	if (debug != 0) {
		scf_value_set_count(v, debug);
		i.sdi_value = v;
	} else {
		i.sdi_value = SCF_DECORATE_CLEAR;
	}

	if ((*f)(&i, data) == 0)
		return (0);

	i.sdi_name = (const char *)"door_path";
	i.sdi_type = SCF_TYPE_ASTRING;
	(void) pthread_mutex_lock(&handle->rh_lock);
	(void) strlcpy(name, handle->rh_doorpath, sizeof (name));
	(void) pthread_mutex_unlock(&handle->rh_lock);
	if (name[0] != 0) {
		(void) scf_value_set_astring(v, name);
		i.sdi_value = v;
	} else {
		i.sdi_value = SCF_DECORATE_CLEAR;
	}

	if ((*f)(&i, data) == 0)
		return (0);

	return (1);
}

/*
 * Fails if handle is not bound.
 */
static int
handle_unbind_unlocked(scf_handle_t *handle)
{
	rep_protocol_request_t request;
	rep_protocol_response_t response;

	if (!handle_is_bound(handle))
		return (-1);

	request.rpr_request = REP_PROTOCOL_CLOSE;

	(void) make_door_call(handle, &request, sizeof (request),
	    &response, sizeof (response));

	handle_do_close(handle);

	return (SCF_SUCCESS);
}

/*
 * Fails with
 *   _HANDLE_DESTROYED - dp's handle has been destroyed
 *   _INTERNAL - server response too big
 *		 entity already set up with different type
 *   _NO_RESOURCES - server out of memory
 */
static int
datael_attach(scf_datael_t *dp)
{
	scf_handle_t *h = dp->rd_handle;

	struct rep_protocol_entity_setup request;
	rep_protocol_response_t response;
	ssize_t r;

	assert(MUTEX_HELD(&h->rh_lock));

	dp->rd_reset = 0;		/* setup implicitly resets */

	if (h->rh_flags & HANDLE_DEAD)
		return (scf_set_error(SCF_ERROR_HANDLE_DESTROYED));

	if (!handle_is_bound(h))
		return (SCF_SUCCESS);		/* nothing to do */

	request.rpr_request = REP_PROTOCOL_ENTITY_SETUP;
	request.rpr_entityid = dp->rd_entity;
	request.rpr_entitytype = dp->rd_type;

	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));

	if (r == NOT_BOUND || r == CALL_FAILED)
		return (SCF_SUCCESS);
	if (r == RESULT_TOO_BIG)
		return (scf_set_error(SCF_ERROR_INTERNAL));

	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
		return (scf_set_error(proto_error(response.rpr_response)));

	return (SCF_SUCCESS);
}

/*
 * Fails with
 *   _HANDLE_DESTROYED - iter's handle has been destroyed
 *   _INTERNAL - server response too big
 *		 iter already existed
 *   _NO_RESOURCES
 */
static int
iter_attach(scf_iter_t *iter)
{
	scf_handle_t *h = iter->iter_handle;
	struct rep_protocol_iter_request request;
	struct rep_protocol_response response;
	int r;

	assert(MUTEX_HELD(&h->rh_lock));

	if (h->rh_flags & HANDLE_DEAD)
		return (scf_set_error(SCF_ERROR_HANDLE_DESTROYED));

	if (!handle_is_bound(h))
		return (SCF_SUCCESS);		/* nothing to do */

	request.rpr_request = REP_PROTOCOL_ITER_SETUP;
	request.rpr_iterid = iter->iter_id;

	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));

	if (r == NOT_BOUND || r == CALL_FAILED)
		return (SCF_SUCCESS);
	if (r == RESULT_TOO_BIG)
		return (scf_set_error(SCF_ERROR_INTERNAL));

	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
		return (scf_set_error(proto_error(response.rpr_response)));

	return (SCF_SUCCESS);
}

/*
 * Fails with
 *   _IN_USE - handle already bound
 *   _NO_SERVER - server door could not be open()ed
 *		  door call failed
 *		  door_info() failed
 *   _VERSION_MISMATCH - server returned bad file descriptor
 *			 server claimed bad request
 *			 server reported version mismatch
 *			 server refused with unknown reason
 *   _INVALID_ARGUMENT
 *   _NO_RESOURCES - server is out of memory
 *   _PERMISSION_DENIED
 *   _INTERNAL - could not set up entities or iters
 *		 server response too big
 *
 * perhaps this should try multiple times.
 */
int
scf_handle_bind(scf_handle_t *handle)
{
	scf_datael_t *el;
	scf_iter_t *iter;

	pid_t pid;
	int fd;
	int res;
	door_info_t info;
	repository_door_request_t request;
	repository_door_response_t response;
	const char *door_name = default_door_path;

	(void) pthread_mutex_lock(&handle->rh_lock);
	if (handle_is_bound(handle)) {
		(void) pthread_mutex_unlock(&handle->rh_lock);
		return (scf_set_error(SCF_ERROR_IN_USE));
	}

	/* wait until any active fd users have cleared out */
	while (handle->rh_fd_users > 0) {
		int cancel_state;

		(void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,
		    &cancel_state);
		(void) pthread_cond_wait(&handle->rh_cv, &handle->rh_lock);
		(void) pthread_setcancelstate(cancel_state, NULL);
	}

	/* check again, since we had to drop the lock */
	if (handle_is_bound(handle)) {
		(void) pthread_mutex_unlock(&handle->rh_lock);
		return (scf_set_error(SCF_ERROR_IN_USE));
	}

	assert(handle->rh_doorfd == -1 && handle->rh_doorfd_old == -1);

	if (handle->rh_doorpath[0] != 0)
		door_name = handle->rh_doorpath;

	fd = open(door_name, O_RDONLY, 0);
	if (fd == -1) {
		(void) pthread_mutex_unlock(&handle->rh_lock);
		return (scf_set_error(SCF_ERROR_NO_SERVER));
	}

	request.rdr_version = REPOSITORY_DOOR_VERSION;
	request.rdr_request = REPOSITORY_DOOR_REQUEST_CONNECT;
	request.rdr_flags = handle->rh_flags;
	request.rdr_debug = handle->rh_debug;

	pid = getpid();

	res = make_door_call_retfd(fd, &request, sizeof (request),
	    &response, sizeof (response), &handle->rh_doorfd);

	(void) close(fd);

	if (res < 0) {
		(void) pthread_mutex_unlock(&handle->rh_lock);

		assert(res != NOT_BOUND);
		if (res == CALL_FAILED)
			return (scf_set_error(SCF_ERROR_NO_SERVER));
		assert(res == RESULT_TOO_BIG);
		return (scf_set_error(SCF_ERROR_INTERNAL));
	}

	if (handle->rh_doorfd < 0) {
		(void) pthread_mutex_unlock(&handle->rh_lock);

		switch (response.rdr_status) {
		case REPOSITORY_DOOR_SUCCESS:
			return (scf_set_error(SCF_ERROR_VERSION_MISMATCH));

		case REPOSITORY_DOOR_FAIL_BAD_REQUEST:
			return (scf_set_error(SCF_ERROR_VERSION_MISMATCH));

		case REPOSITORY_DOOR_FAIL_VERSION_MISMATCH:
			return (scf_set_error(SCF_ERROR_VERSION_MISMATCH));

		case REPOSITORY_DOOR_FAIL_BAD_FLAG:
			return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));

		case REPOSITORY_DOOR_FAIL_NO_RESOURCES:
			return (scf_set_error(SCF_ERROR_NO_RESOURCES));

		case REPOSITORY_DOOR_FAIL_PERMISSION_DENIED:
			return (scf_set_error(SCF_ERROR_PERMISSION_DENIED));

		default:
			return (scf_set_error(SCF_ERROR_VERSION_MISMATCH));
		}
	}

	(void) fcntl(handle->rh_doorfd, F_SETFD, FD_CLOEXEC);

	if (door_info(handle->rh_doorfd, &info) < 0) {
		(void) close(handle->rh_doorfd);
		handle->rh_doorfd = -1;

		(void) pthread_mutex_unlock(&handle->rh_lock);
		return (scf_set_error(SCF_ERROR_NO_SERVER));
	}

	handle->rh_doorpid = pid;
	handle->rh_doorid = info.di_uniquifier;

	/*
	 * Now, re-attach everything
	 */
	for (el = uu_list_first(handle->rh_dataels); el != NULL;
	    el = uu_list_next(handle->rh_dataels, el)) {
		if (datael_attach(el) == -1) {
			assert(scf_error() != SCF_ERROR_HANDLE_DESTROYED);
			(void) handle_unbind_unlocked(handle);
			(void) pthread_mutex_unlock(&handle->rh_lock);
			return (-1);
		}
	}

	for (iter = uu_list_first(handle->rh_iters); iter != NULL;
	    iter = uu_list_next(handle->rh_iters, iter)) {
		if (iter_attach(iter) == -1) {
			assert(scf_error() != SCF_ERROR_HANDLE_DESTROYED);
			(void) handle_unbind_unlocked(handle);
			(void) pthread_mutex_unlock(&handle->rh_lock);
			return (-1);
		}
	}
	(void) pthread_mutex_unlock(&handle->rh_lock);
	return (SCF_SUCCESS);
}

int
scf_handle_unbind(scf_handle_t *handle)
{
	int ret;
	(void) pthread_mutex_lock(&handle->rh_lock);
	ret = handle_unbind_unlocked(handle);
	(void) pthread_mutex_unlock(&handle->rh_lock);
	return (ret == SCF_SUCCESS ? ret : scf_set_error(SCF_ERROR_NOT_BOUND));
}

static scf_handle_t *
handle_get(scf_handle_t *h)
{
	(void) pthread_mutex_lock(&h->rh_lock);
	if (h->rh_flags & HANDLE_DEAD) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		(void) scf_set_error(SCF_ERROR_HANDLE_DESTROYED);
		return (NULL);
	}
	(void) pthread_mutex_unlock(&h->rh_lock);
	return (h);
}

/*
 * Called when an object is removed from the handle.  On the last remove,
 * cleans up and frees the handle.
 */
static void
handle_unrefed(scf_handle_t *handle)
{
	scf_iter_t *iter;
	scf_value_t *v;
	scf_scope_t *sc;
	scf_service_t *svc;
	scf_instance_t *inst;
	scf_snapshot_t *snap;
	scf_snaplevel_t *snaplvl;
	scf_propertygroup_t *pg;
	scf_property_t *prop;

	assert(MUTEX_HELD(&handle->rh_lock));

	/*
	 * Don't do anything if the handle has not yet been destroyed, there
	 * are still external references, or we're already doing unrefed
	 * handling.
	 */
	if (!(handle->rh_flags & HANDLE_DEAD) ||
	    handle->rh_extrefs > 0 ||
	    handle->rh_fd_users > 0 ||
	    (handle->rh_flags & HANDLE_UNREFED)) {
		(void) pthread_mutex_unlock(&handle->rh_lock);
		return;
	}

	handle->rh_flags |= HANDLE_UNREFED;

	/*
	 * Now that we know that there are no external references, and the
	 * HANDLE_DEAD flag keeps new ones from appearing, we can clean up
	 * our subhandles and destroy the handle completely.
	 */
	assert(handle->rh_intrefs >= 0);
	handle->rh_extrefs = handle->rh_intrefs;
	handle->rh_intrefs = 0;
	(void) pthread_mutex_unlock(&handle->rh_lock);

	handle_hold_subhandles(handle, RH_HOLD_ALL);

	iter = handle->rh_iter;
	sc = handle->rh_scope;
	svc = handle->rh_service;
	inst = handle->rh_instance;
	snap = handle->rh_snapshot;
	snaplvl = handle->rh_snaplvl;
	pg = handle->rh_pg;
	prop = handle->rh_property;
	v = handle->rh_value;

	handle->rh_iter = NULL;
	handle->rh_scope = NULL;
	handle->rh_service = NULL;
	handle->rh_instance = NULL;
	handle->rh_snapshot = NULL;
	handle->rh_snaplvl = NULL;
	handle->rh_pg = NULL;
	handle->rh_property = NULL;
	handle->rh_value = NULL;

	if (iter != NULL)
		scf_iter_destroy(iter);
	if (sc != NULL)
		scf_scope_destroy(sc);
	if (svc != NULL)
		scf_service_destroy(svc);
	if (inst != NULL)
		scf_instance_destroy(inst);
	if (snap != NULL)
		scf_snapshot_destroy(snap);
	if (snaplvl != NULL)
		scf_snaplevel_destroy(snaplvl);
	if (pg != NULL)
		scf_pg_destroy(pg);
	if (prop != NULL)
		scf_property_destroy(prop);
	if (v != NULL)
		scf_value_destroy(v);

	(void) pthread_mutex_lock(&handle->rh_lock);

	/* there should be no outstanding children at this point */
	assert(handle->rh_extrefs == 0);
	assert(handle->rh_intrefs == 0);
	assert(handle->rh_values == 0);
	assert(handle->rh_entries == 0);
	assert(uu_list_numnodes(handle->rh_dataels) == 0);
	assert(uu_list_numnodes(handle->rh_iters) == 0);

	uu_list_destroy(handle->rh_dataels);
	uu_list_destroy(handle->rh_iters);
	handle->rh_dataels = NULL;
	handle->rh_iters = NULL;
	(void) pthread_mutex_unlock(&handle->rh_lock);

	(void) pthread_mutex_destroy(&handle->rh_lock);

	uu_free(handle);
}

void
scf_handle_destroy(scf_handle_t *handle)
{
	if (handle == NULL)
		return;

	(void) pthread_mutex_lock(&handle->rh_lock);
	if (handle->rh_flags & HANDLE_DEAD) {
		/*
		 * This is an error (you are not allowed to reference the
		 * handle after it is destroyed), but we can't report it.
		 */
		(void) pthread_mutex_unlock(&handle->rh_lock);
		return;
	}
	handle->rh_flags |= HANDLE_DEAD;
	(void) handle_unbind_unlocked(handle);
	handle_unrefed(handle);
}

ssize_t
scf_myname(scf_handle_t *h, char *out, size_t len)
{
	char *cp;

	if (!handle_has_server(h))
		return (scf_set_error(SCF_ERROR_CONNECTION_BROKEN));

	cp = getenv("SMF_FMRI");
	if (cp == NULL)
		return (scf_set_error(SCF_ERROR_NOT_SET));

	return (strlcpy(out, cp, len));
}

static uint32_t
handle_alloc_entityid(scf_handle_t *h)
{
	uint32_t nextid;

	assert(MUTEX_HELD(&h->rh_lock));

	if (uu_list_numnodes(h->rh_dataels) == UINT32_MAX)
		return (0);		/* no ids available */

	/*
	 * The following loop assumes that there are not a huge number of
	 * outstanding entities when we've wrapped.  If that ends up not
	 * being the case, the O(N^2) nature of this search will hurt a lot,
	 * and the data structure should be switched to an AVL tree.
	 */
	nextid = h->rh_nextentity + 1;
	for (;;) {
		scf_datael_t *cur;

		if (nextid == 0) {
			nextid++;
			h->rh_flags |= HANDLE_WRAPPED_ENTITY;
		}
		if (!(h->rh_flags & HANDLE_WRAPPED_ENTITY))
			break;

		cur = uu_list_find(h->rh_dataels, NULL, &nextid, NULL);
		if (cur == NULL)
			break;		/* not in use */

		if (nextid == h->rh_nextentity)
			return (0);	/* wrapped around; no ids available */
		nextid++;
	}

	h->rh_nextentity = nextid;
	return (nextid);
}

static uint32_t
handle_alloc_iterid(scf_handle_t *h)
{
	uint32_t nextid;

	assert(MUTEX_HELD(&h->rh_lock));

	if (uu_list_numnodes(h->rh_iters) == UINT32_MAX)
		return (0);		/* no ids available */

	/* see the comment in handle_alloc_entityid */
	nextid = h->rh_nextiter + 1;
	for (;;) {
		scf_iter_t *cur;

		if (nextid == 0) {
			nextid++;
			h->rh_flags |= HANDLE_WRAPPED_ITER;
		}
		if (!(h->rh_flags & HANDLE_WRAPPED_ITER))
			break;			/* not yet wrapped */

		cur = uu_list_find(h->rh_iters, NULL, &nextid, NULL);
		if (cur == NULL)
			break;		/* not in use */

		if (nextid == h->rh_nextiter)
			return (0);	/* wrapped around; no ids available */
		nextid++;
	}

	h->rh_nextiter = nextid;
	return (nextid);
}

static uint32_t
handle_next_changeid(scf_handle_t *handle)
{
	uint32_t nextid;

	assert(MUTEX_HELD(&handle->rh_lock));

	nextid = ++handle->rh_nextchangeid;
	if (nextid == 0)
		nextid = ++handle->rh_nextchangeid;
	return (nextid);
}

/*
 * Fails with
 *   _INVALID_ARGUMENT - h is NULL
 *   _HANDLE_DESTROYED
 *   _INTERNAL - server response too big
 *		 entity already set up with different type
 *   _NO_RESOURCES
 */
static int
datael_init(scf_datael_t *dp, scf_handle_t *h, uint32_t type)
{
	int ret;

	if (h == NULL)
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));

	uu_list_node_init(dp, &dp->rd_node, datael_pool);

	dp->rd_handle = h;
	dp->rd_type = type;
	dp->rd_reset = 0;

	(void) pthread_mutex_lock(&h->rh_lock);
	if (h->rh_flags & HANDLE_DEAD) {
		/*
		 * we're in undefined territory (the user cannot use a handle
		 * directly after it has been destroyed), but we don't want
		 * to allow any new references to happen, so we fail here.
		 */
		(void) pthread_mutex_unlock(&h->rh_lock);
		return (scf_set_error(SCF_ERROR_HANDLE_DESTROYED));
	}
	dp->rd_entity = handle_alloc_entityid(h);
	if (dp->rd_entity == 0) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		uu_list_node_fini(dp, &dp->rd_node, datael_pool);
		return (scf_set_error(SCF_ERROR_NO_MEMORY));
	}

	ret = datael_attach(dp);
	if (ret == 0) {
		(void) uu_list_insert_before(h->rh_dataels, NULL, dp);
		h->rh_extrefs++;
	} else {
		uu_list_node_fini(dp, &dp->rd_node, datael_pool);
	}
	(void) pthread_mutex_unlock(&h->rh_lock);

	return (ret);
}

static void
datael_destroy(scf_datael_t *dp)
{
	scf_handle_t *h = dp->rd_handle;

	struct rep_protocol_entity_teardown request;
	rep_protocol_response_t response;

	(void) pthread_mutex_lock(&h->rh_lock);
	uu_list_remove(h->rh_dataels, dp);
	--h->rh_extrefs;

	if (handle_is_bound(h)) {
		request.rpr_request = REP_PROTOCOL_ENTITY_TEARDOWN;
		request.rpr_entityid = dp->rd_entity;

		(void) make_door_call(h, &request, sizeof (request),
		    &response, sizeof (response));
	}
	handle_unrefed(h);			/* drops h->rh_lock */

	dp->rd_handle = NULL;
}

static scf_handle_t *
datael_handle(const scf_datael_t *dp)
{
	return (handle_get(dp->rd_handle));
}

/*
 * We delay ENTITY_RESETs until right before the entity is used.  By doing
 * them lazily, we remove quite a few unnecessary calls.
 */
static void
datael_do_reset_locked(scf_datael_t *dp)
{
	scf_handle_t *h = dp->rd_handle;

	struct rep_protocol_entity_reset request;
	rep_protocol_response_t response;

	assert(MUTEX_HELD(&h->rh_lock));

	request.rpr_request = REP_PROTOCOL_ENTITY_RESET;
	request.rpr_entityid = dp->rd_entity;

	(void) make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));

	dp->rd_reset = 0;
}

static void
datael_reset_locked(scf_datael_t *dp)
{
	assert(MUTEX_HELD(&dp->rd_handle->rh_lock));
	dp->rd_reset = 1;
}

static void
datael_reset(scf_datael_t *dp)
{
	scf_handle_t *h = dp->rd_handle;

	(void) pthread_mutex_lock(&h->rh_lock);
	dp->rd_reset = 1;
	(void) pthread_mutex_unlock(&h->rh_lock);
}

static void
datael_finish_reset(const scf_datael_t *dp_arg)
{
	scf_datael_t *dp = (scf_datael_t *)dp_arg;

	if (dp->rd_reset)
		datael_do_reset_locked(dp);
}

/*
 * Fails with _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response too
 * big, bad entity id, request not applicable to entity, name too long for
 * buffer), _NOT_SET, _DELETED, or _CONSTRAINT_VIOLATED (snaplevel is not of an
 * instance).
 */
static ssize_t
datael_get_name(const scf_datael_t *dp, char *buf, size_t size, uint32_t type)
{
	scf_handle_t *h = dp->rd_handle;

	struct rep_protocol_entity_name request;
	struct rep_protocol_name_response response;
	ssize_t r;

	(void) pthread_mutex_lock(&h->rh_lock);
	request.rpr_request = REP_PROTOCOL_ENTITY_NAME;
	request.rpr_entityid = dp->rd_entity;
	request.rpr_answertype = type;

	datael_finish_reset(dp);
	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));
	(void) pthread_mutex_unlock(&h->rh_lock);

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
		assert(response.rpr_response != REP_PROTOCOL_FAIL_BAD_REQUEST);
		if (response.rpr_response == REP_PROTOCOL_FAIL_NOT_FOUND)
			return (scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED));
		return (scf_set_error(proto_error(response.rpr_response)));
	}
	return (strlcpy(buf, response.rpr_name, size));
}

/*
 * Fails with _HANDLE_MISMATCH, _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL
 * (server response too big, bad element id), _EXISTS (elements have same id),
 * _NOT_SET, _DELETED, _CONSTRAINT_VIOLATED, _NOT_FOUND (scope has no parent),
 * or _SUCCESS.
 */
static int
datael_get_parent(const scf_datael_t *dp, scf_datael_t *pp)
{
	scf_handle_t *h = dp->rd_handle;

	struct rep_protocol_entity_parent request;
	struct rep_protocol_response response;

	ssize_t r;

	if (h != pp->rd_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	(void) pthread_mutex_lock(&h->rh_lock);
	request.rpr_request = REP_PROTOCOL_ENTITY_GET_PARENT;
	request.rpr_entityid = dp->rd_entity;
	request.rpr_outid = pp->rd_entity;

	datael_finish_reset(dp);
	datael_finish_reset(pp);
	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));
	(void) pthread_mutex_unlock(&h->rh_lock);

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
		if (response.rpr_response == REP_PROTOCOL_FAIL_TYPE_MISMATCH)
			return (scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED));
		return (scf_set_error(proto_error(response.rpr_response)));
	}

	return (SCF_SUCCESS);
}

/*
 * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT (out does not have type type,
 * name is invalid), _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response
 * too big, bad id, iter already exists, element cannot have children of type,
 * type is invalid, iter was reset, sequence was bad, iter walks values, iter
 * does not walk type entities), _NOT_SET, _DELETED, _NO_RESOURCES,
 * _BACKEND_ACCESS, _NOT_FOUND.
 */
static int
datael_get_child_composed_locked(const scf_datael_t *dp, const char *name,
    uint32_t type, scf_datael_t *out, scf_iter_t *iter)
{
	struct rep_protocol_iter_start request;
	struct rep_protocol_iter_read read_request;
	struct rep_protocol_response response;

	scf_handle_t *h = dp->rd_handle;
	ssize_t r;

	if (h != out->rd_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	if (out->rd_type != type)
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));

	assert(MUTEX_HELD(&h->rh_lock));
	assert(iter != NULL);

	scf_iter_reset_locked(iter);
	iter->iter_type = type;

	request.rpr_request = REP_PROTOCOL_ITER_START;
	request.rpr_iterid = iter->iter_id;
	request.rpr_entity = dp->rd_entity;
	request.rpr_itertype = type;
	request.rpr_flags = RP_ITER_START_EXACT | RP_ITER_START_COMPOSED;

	if (name == NULL || strlcpy(request.rpr_pattern, name,
	    sizeof (request.rpr_pattern)) >= sizeof (request.rpr_pattern)) {
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
	}

	datael_finish_reset(dp);
	datael_finish_reset(out);

	/*
	 * We hold the handle lock across both door calls, so that they
	 * appear atomic.
	 */
	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
		return (scf_set_error(proto_error(response.rpr_response)));

	iter->iter_sequence++;

	read_request.rpr_request = REP_PROTOCOL_ITER_READ;
	read_request.rpr_iterid = iter->iter_id;
	read_request.rpr_sequence = iter->iter_sequence;
	read_request.rpr_entityid = out->rd_entity;

	r = make_door_call(h, &read_request, sizeof (read_request),
	    &response, sizeof (response));

	scf_iter_reset_locked(iter);

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	if (response.rpr_response == REP_PROTOCOL_DONE) {
		return (scf_set_error(SCF_ERROR_NOT_FOUND));
	}

	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
		if (response.rpr_response == REP_PROTOCOL_FAIL_NOT_SET ||
		    response.rpr_response == REP_PROTOCOL_FAIL_BAD_REQUEST)
			return (scf_set_error(SCF_ERROR_INTERNAL));
		return (scf_set_error(proto_error(response.rpr_response)));
	}

	return (0);
}

/*
 * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT (out does not have type type,
 * name is invalid), _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response
 * too big, bad id, element cannot have children of type, type is invalid),
 * _NOT_SET, _DELETED, _NO_RESOURCES, _BACKEND_ACCESS.
 */
static int
datael_get_child_locked(const scf_datael_t *dp, const char *name,
    uint32_t type, scf_datael_t *out)
{
	struct rep_protocol_entity_get_child request;
	struct rep_protocol_response response;

	scf_handle_t *h = dp->rd_handle;
	ssize_t r;

	if (h != out->rd_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	if (out->rd_type != type)
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));

	assert(MUTEX_HELD(&h->rh_lock));

	request.rpr_request = REP_PROTOCOL_ENTITY_GET_CHILD;
	request.rpr_entityid = dp->rd_entity;
	request.rpr_childid = out->rd_entity;

	if (name == NULL || strlcpy(request.rpr_name, name,
	    sizeof (request.rpr_name)) >= sizeof (request.rpr_name)) {
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
	}

	datael_finish_reset(dp);
	datael_finish_reset(out);

	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
		return (scf_set_error(proto_error(response.rpr_response)));
	return (0);
}

/*
 * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT (out does not have type type,
 * name is invalid), _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response
 * too big, bad id, iter already exists, element cannot have children of type,
 * type is invalid, iter was reset, sequence was bad, iter walks values, iter
 * does not walk type entities), _NOT_SET, _DELETED, _NO_RESOURCES,
 * _BACKEND_ACCESS, _NOT_FOUND.
 */
static int
datael_get_child(const scf_datael_t *dp, const char *name, uint32_t type,
    scf_datael_t *out, boolean_t composed)
{
	scf_handle_t *h = dp->rd_handle;
	uint32_t held = 0;
	int ret;

	scf_iter_t *iter = NULL;

	if (composed)
		iter = HANDLE_HOLD_ITER(h);

	if (out == NULL) {
		switch (type) {
		case REP_PROTOCOL_ENTITY_SERVICE:
			out = &HANDLE_HOLD_SERVICE(h)->rd_d;
			held = RH_HOLD_SERVICE;
			break;

		case REP_PROTOCOL_ENTITY_INSTANCE:
			out = &HANDLE_HOLD_INSTANCE(h)->rd_d;
			held = RH_HOLD_INSTANCE;
			break;

		case REP_PROTOCOL_ENTITY_SNAPSHOT:
			out = &HANDLE_HOLD_SNAPSHOT(h)->rd_d;
			held = RH_HOLD_SNAPSHOT;
			break;

		case REP_PROTOCOL_ENTITY_SNAPLEVEL:
			out = &HANDLE_HOLD_SNAPLVL(h)->rd_d;
			held = RH_HOLD_SNAPLVL;
			break;

		case REP_PROTOCOL_ENTITY_PROPERTYGRP:
			out = &HANDLE_HOLD_PG(h)->rd_d;
			held = RH_HOLD_PG;
			break;

		case REP_PROTOCOL_ENTITY_PROPERTY:
			out = &HANDLE_HOLD_PROPERTY(h)->rd_d;
			held = RH_HOLD_PROPERTY;
			break;

		default:
			assert(0);
			abort();
		}
	}

	(void) pthread_mutex_lock(&h->rh_lock);
	if (composed)
		ret = datael_get_child_composed_locked(dp, name, type, out,
		    iter);
	else
		ret = datael_get_child_locked(dp, name, type, out);
	(void) pthread_mutex_unlock(&h->rh_lock);

	if (composed)
		HANDLE_RELE_ITER(h);

	if (held)
		handle_rele_subhandles(h, held);

	return (ret);
}

/*
 * Fails with
 *   _HANDLE_MISMATCH
 *   _INVALID_ARGUMENT - name is too long
 *			 invalid changeid
 *			 name is invalid
 *			 cannot create children for dp's type of node
 *   _NOT_BOUND - handle is not bound
 *   _CONNECTION_BROKEN - server is not reachable
 *   _INTERNAL - server response too big
 *		 dp or cp has unknown id
 *		 type is _PROPERTYGRP
 *		 type is invalid
 *		 dp cannot have children of type type
 *		 database is corrupt
 *   _EXISTS - dp & cp have the same id
 *   _EXISTS - child already exists
 *   _DELETED - dp has been deleted
 *   _NOT_SET - dp is reset
 *   _NO_RESOURCES
 *   _PERMISSION_DENIED
 *   _BACKEND_ACCESS
 *   _BACKEND_READONLY
 */
static int
datael_add_child(const scf_datael_t *dp, const char *name, uint32_t type,
    scf_datael_t *cp)
{
	scf_handle_t *h = dp->rd_handle;

	struct rep_protocol_entity_create_child request;
	struct rep_protocol_response response;
	ssize_t r;
	uint32_t held = 0;

	if (cp == NULL) {
		switch (type) {
		case REP_PROTOCOL_ENTITY_SCOPE:
			cp = &HANDLE_HOLD_SCOPE(h)->rd_d;
			held = RH_HOLD_SCOPE;
			break;
		case REP_PROTOCOL_ENTITY_SERVICE:
			cp = &HANDLE_HOLD_SERVICE(h)->rd_d;
			held = RH_HOLD_SERVICE;
			break;
		case REP_PROTOCOL_ENTITY_INSTANCE:
			cp = &HANDLE_HOLD_INSTANCE(h)->rd_d;
			held = RH_HOLD_INSTANCE;
			break;
		case REP_PROTOCOL_ENTITY_SNAPSHOT:
		default:
			assert(0);
			abort();
		}
		assert(h == cp->rd_handle);

	} else if (h != cp->rd_handle) {
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
	}

	if (strlcpy(request.rpr_name, name, sizeof (request.rpr_name)) >=
	    sizeof (request.rpr_name)) {
		r = scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
		goto err;
	}

	(void) pthread_mutex_lock(&h->rh_lock);
	request.rpr_request = REP_PROTOCOL_ENTITY_CREATE_CHILD;
	request.rpr_entityid = dp->rd_entity;
	request.rpr_childtype = type;
	request.rpr_childid = cp->rd_entity;

	datael_finish_reset(dp);
	request.rpr_changeid = handle_next_changeid(h);
	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));
	(void) pthread_mutex_unlock(&h->rh_lock);

	if (held)
		handle_rele_subhandles(h, held);

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
		return (scf_set_error(proto_error(response.rpr_response)));

	return (SCF_SUCCESS);

err:
	if (held)
		handle_rele_subhandles(h, held);
	return (r);
}

static int
datael_add_pg(const scf_datael_t *dp, const char *name, const char *type,
    uint32_t flags, scf_datael_t *cp)
{
	scf_handle_t *h = dp->rd_handle;

	struct rep_protocol_entity_create_pg request;
	struct rep_protocol_response response;
	ssize_t r;

	int holding_els = 0;

	if (cp == NULL) {
		holding_els = 1;
		cp = &HANDLE_HOLD_PG(h)->rd_d;
		assert(h == cp->rd_handle);

	} else if (h != cp->rd_handle) {
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
	}

	request.rpr_request = REP_PROTOCOL_ENTITY_CREATE_PG;

	if (name == NULL || strlcpy(request.rpr_name, name,
	    sizeof (request.rpr_name)) > sizeof (request.rpr_name)) {
		r = scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
		goto err;
	}

	if (type == NULL || strlcpy(request.rpr_type, type,
	    sizeof (request.rpr_type)) > sizeof (request.rpr_type)) {
		r = scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
		goto err;
	}

	(void) pthread_mutex_lock(&h->rh_lock);
	request.rpr_entityid = dp->rd_entity;
	request.rpr_childid = cp->rd_entity;
	request.rpr_flags = flags;

	datael_finish_reset(dp);
	datael_finish_reset(cp);
	request.rpr_changeid = handle_next_changeid(h);
	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));
	(void) pthread_mutex_unlock(&h->rh_lock);

	if (holding_els)
		HANDLE_RELE_PG(h);

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
		return (scf_set_error(proto_error(response.rpr_response)));

	return (SCF_SUCCESS);

err:
	if (holding_els)
		HANDLE_RELE_PG(h);
	return (r);
}

static int
datael_delete(const scf_datael_t *dp)
{
	scf_handle_t *h = dp->rd_handle;

	struct rep_protocol_entity_delete request;
	struct rep_protocol_response response;
	ssize_t r;

	(void) pthread_mutex_lock(&h->rh_lock);
	request.rpr_request = REP_PROTOCOL_ENTITY_DELETE;
	request.rpr_entityid = dp->rd_entity;

	datael_finish_reset(dp);
	request.rpr_changeid = handle_next_changeid(h);
	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));
	(void) pthread_mutex_unlock(&h->rh_lock);

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
		return (scf_set_error(proto_error(response.rpr_response)));

	return (SCF_SUCCESS);
}

/*
 * Fails with
 *   _INVALID_ARGUMENT - h is NULL
 *   _NO_MEMORY
 *   _HANDLE_DESTROYED - h has been destroyed
 *   _INTERNAL - server response too big
 *		 iter already exists
 *   _NO_RESOURCES
 */
scf_iter_t *
scf_iter_create(scf_handle_t *h)
{
	scf_iter_t *iter;

	if (h == NULL) {
		(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
		return (NULL);
	}

	iter = uu_zalloc(sizeof (*iter));
	if (iter == NULL) {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
		return (NULL);
	}

	uu_list_node_init(iter, &iter->iter_node, iter_pool);
	iter->iter_handle = h;
	iter->iter_sequence = 1;
	iter->iter_type = REP_PROTOCOL_ENTITY_NONE;

	(void) pthread_mutex_lock(&h->rh_lock);
	iter->iter_id = handle_alloc_iterid(h);
	if (iter->iter_id == 0) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		uu_list_node_fini(iter, &iter->iter_node, iter_pool);
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
		uu_free(iter);
		return (NULL);
	}
	if (iter_attach(iter) == -1) {
		uu_list_node_fini(iter, &iter->iter_node, iter_pool);
		(void) pthread_mutex_unlock(&h->rh_lock);
		uu_free(iter);
		return (NULL);
	}
	(void) uu_list_insert_before(h->rh_iters, NULL, iter);
	h->rh_extrefs++;
	(void) pthread_mutex_unlock(&h->rh_lock);
	return (iter);
}

scf_handle_t *
scf_iter_handle(const scf_iter_t *iter)
{
	return (handle_get(iter->iter_handle));
}

static void
scf_iter_reset_locked(scf_iter_t *iter)
{
	struct rep_protocol_iter_request request;
	struct rep_protocol_response response;

	request.rpr_request = REP_PROTOCOL_ITER_RESET;
	request.rpr_iterid = iter->iter_id;

	assert(MUTEX_HELD(&iter->iter_handle->rh_lock));

	(void) make_door_call(iter->iter_handle,
	    &request, sizeof (request), &response, sizeof (response));

	iter->iter_type = REP_PROTOCOL_ENTITY_NONE;
	iter->iter_sequence = 1;
}

void
scf_iter_reset(scf_iter_t *iter)
{
	(void) pthread_mutex_lock(&iter->iter_handle->rh_lock);
	scf_iter_reset_locked(iter);
	(void) pthread_mutex_unlock(&iter->iter_handle->rh_lock);
}

void
scf_iter_destroy(scf_iter_t *iter)
{
	scf_handle_t *handle;

	struct rep_protocol_iter_request request;
	struct rep_protocol_response response;

	if (iter == NULL)
		return;

	handle = iter->iter_handle;

	(void) pthread_mutex_lock(&handle->rh_lock);
	request.rpr_request = REP_PROTOCOL_ITER_TEARDOWN;
	request.rpr_iterid = iter->iter_id;

	(void) make_door_call(handle, &request, sizeof (request),
	    &response, sizeof (response));

	uu_list_remove(handle->rh_iters, iter);
	--handle->rh_extrefs;
	handle_unrefed(handle);			/* drops h->rh_lock */
	iter->iter_handle = NULL;

	uu_list_node_fini(iter, &iter->iter_node, iter_pool);
	uu_free(iter);
}

static int
handle_get_local_scope_locked(scf_handle_t *handle, scf_scope_t *out)
{
	struct rep_protocol_entity_get request;
	struct rep_protocol_name_response response;
	ssize_t r;

	assert(MUTEX_HELD(&handle->rh_lock));

	if (handle != out->rd_d.rd_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	request.rpr_request = REP_PROTOCOL_ENTITY_GET;
	request.rpr_entityid = out->rd_d.rd_entity;
	request.rpr_object = RP_ENTITY_GET_MOST_LOCAL_SCOPE;

	datael_finish_reset(&out->rd_d);
	r = make_door_call(handle, &request, sizeof (request),
	    &response, sizeof (response));

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
		return (scf_set_error(proto_error(response.rpr_response)));

	return (SCF_SUCCESS);
}

int
scf_iter_handle_scopes(scf_iter_t *iter, const scf_handle_t *handle)
{
	scf_handle_t *h = iter->iter_handle;
	if (h != handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	(void) pthread_mutex_lock(&h->rh_lock);
	scf_iter_reset_locked(iter);

	if (!handle_is_bound(h)) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		return (scf_set_error(SCF_ERROR_NOT_BOUND));
	}

	if (!handle_has_server_locked(h)) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		return (scf_set_error(SCF_ERROR_CONNECTION_BROKEN));
	}

	iter->iter_type = REP_PROTOCOL_ENTITY_SCOPE;
	iter->iter_sequence = 1;
	(void) pthread_mutex_unlock(&h->rh_lock);
	return (0);
}

int
scf_iter_next_scope(scf_iter_t *iter, scf_scope_t *out)
{
	int ret;
	scf_handle_t *h = iter->iter_handle;

	if (h != out->rd_d.rd_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	(void) pthread_mutex_lock(&h->rh_lock);
	if (iter->iter_type == REP_PROTOCOL_ENTITY_NONE) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		return (scf_set_error(SCF_ERROR_NOT_SET));
	}
	if (iter->iter_type != REP_PROTOCOL_ENTITY_SCOPE) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
	}
	if (iter->iter_sequence == 1) {
		if ((ret = handle_get_local_scope_locked(h, out)) ==
		    SCF_SUCCESS) {
			iter->iter_sequence++;
			ret = 1;
		}
	} else {
		datael_reset_locked(&out->rd_d);
		ret = 0;
	}
	(void) pthread_mutex_unlock(&h->rh_lock);
	return (ret);
}

int
scf_handle_get_scope(scf_handle_t *h, const char *name, scf_scope_t *out)
{
	int ret;

	if (h != out->rd_d.rd_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	(void) pthread_mutex_lock(&h->rh_lock);
	if (strcmp(name, SCF_SCOPE_LOCAL) == 0) {
		ret = handle_get_local_scope_locked(h, out);
	} else {
		datael_reset_locked(&out->rd_d);
		if (uu_check_name(name, 0) == -1)
			ret = scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
		else
			ret = scf_set_error(SCF_ERROR_NOT_FOUND);
	}
	(void) pthread_mutex_unlock(&h->rh_lock);
	return (ret);
}

static int
datael_setup_iter(scf_iter_t *iter, const scf_datael_t *dp, uint32_t res_type,
    boolean_t composed)
{
	scf_handle_t *h = dp->rd_handle;

	struct rep_protocol_iter_start request;
	struct rep_protocol_response response;

	ssize_t r;

	if (h != iter->iter_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	(void) pthread_mutex_lock(&h->rh_lock);
	scf_iter_reset_locked(iter);
	iter->iter_type = res_type;

	request.rpr_request = REP_PROTOCOL_ITER_START;
	request.rpr_iterid = iter->iter_id;
	request.rpr_entity = dp->rd_entity;
	request.rpr_itertype = res_type;
	request.rpr_flags = RP_ITER_START_ALL |
	    (composed ? RP_ITER_START_COMPOSED : 0);
	request.rpr_pattern[0] = 0;

	datael_finish_reset(dp);
	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));

	if (r < 0) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		DOOR_ERRORS_BLOCK(r);
	}
	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		return (scf_set_error(proto_error(response.rpr_response)));
	}
	iter->iter_sequence++;
	(void) pthread_mutex_unlock(&h->rh_lock);
	return (SCF_SUCCESS);
}

static int
datael_setup_iter_pgtyped(scf_iter_t *iter, const scf_datael_t *dp,
    const char *pgtype, boolean_t composed)
{
	scf_handle_t *h = dp->rd_handle;

	struct rep_protocol_iter_start request;
	struct rep_protocol_response response;

	ssize_t r;

	if (h != iter->iter_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	if (pgtype == NULL || strlcpy(request.rpr_pattern, pgtype,
	    sizeof (request.rpr_pattern)) >= sizeof (request.rpr_pattern)) {
		scf_iter_reset(iter);
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
	}

	(void) pthread_mutex_lock(&h->rh_lock);
	request.rpr_request = REP_PROTOCOL_ITER_START;
	request.rpr_iterid = iter->iter_id;
	request.rpr_entity = dp->rd_entity;
	request.rpr_itertype = REP_PROTOCOL_ENTITY_PROPERTYGRP;
	request.rpr_flags = RP_ITER_START_PGTYPE |
	    (composed ? RP_ITER_START_COMPOSED : 0);

	datael_finish_reset(dp);
	scf_iter_reset_locked(iter);
	iter->iter_type = REP_PROTOCOL_ENTITY_PROPERTYGRP;

	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));

	if (r < 0) {
		(void) pthread_mutex_unlock(&h->rh_lock);

		DOOR_ERRORS_BLOCK(r);
	}
	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		return (scf_set_error(proto_error(response.rpr_response)));
	}
	iter->iter_sequence++;
	(void) pthread_mutex_unlock(&h->rh_lock);
	return (SCF_SUCCESS);
}

static int
datael_iter_next(scf_iter_t *iter, scf_datael_t *out)
{
	scf_handle_t *h = iter->iter_handle;

	struct rep_protocol_iter_read request;
	struct rep_protocol_response response;
	ssize_t r;

	if (h != out->rd_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	(void) pthread_mutex_lock(&h->rh_lock);
	if (iter->iter_type == REP_PROTOCOL_ENTITY_NONE ||
	    iter->iter_sequence == 1) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		return (scf_set_error(SCF_ERROR_NOT_SET));
	}

	if (out->rd_type != iter->iter_type) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
	}

	request.rpr_request = REP_PROTOCOL_ITER_READ;
	request.rpr_iterid = iter->iter_id;
	request.rpr_sequence = iter->iter_sequence;
	request.rpr_entityid = out->rd_entity;

	datael_finish_reset(out);
	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));

	if (r < 0) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		DOOR_ERRORS_BLOCK(r);
	}

	if (response.rpr_response == REP_PROTOCOL_DONE) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		return (0);
	}
	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		return (scf_set_error(proto_error(response.rpr_response)));
	}
	iter->iter_sequence++;
	(void) pthread_mutex_unlock(&h->rh_lock);

	return (1);
}

int
scf_iter_scope_services(scf_iter_t *iter, const scf_scope_t *s)
{
	return (datael_setup_iter(iter, &s->rd_d,
	    REP_PROTOCOL_ENTITY_SERVICE, 0));
}

int
scf_iter_next_service(scf_iter_t *iter, scf_service_t *out)
{
	return (datael_iter_next(iter, &out->rd_d));
}

int
scf_iter_service_instances(scf_iter_t *iter, const scf_service_t *svc)
{
	return (datael_setup_iter(iter, &svc->rd_d,
	    REP_PROTOCOL_ENTITY_INSTANCE, 0));
}

int
scf_iter_next_instance(scf_iter_t *iter, scf_instance_t *out)
{
	return (datael_iter_next(iter, &out->rd_d));
}

int
scf_iter_service_pgs(scf_iter_t *iter, const scf_service_t *svc)
{
	return (datael_setup_iter(iter, &svc->rd_d,
	    REP_PROTOCOL_ENTITY_PROPERTYGRP, 0));
}

int
scf_iter_service_pgs_typed(scf_iter_t *iter, const scf_service_t *svc,
    const char *type)
{
	return (datael_setup_iter_pgtyped(iter, &svc->rd_d, type, 0));
}

int
scf_iter_instance_snapshots(scf_iter_t *iter, const scf_instance_t *inst)
{
	return (datael_setup_iter(iter, &inst->rd_d,
	    REP_PROTOCOL_ENTITY_SNAPSHOT, 0));
}

int
scf_iter_next_snapshot(scf_iter_t *iter, scf_snapshot_t *out)
{
	return (datael_iter_next(iter, &out->rd_d));
}

int
scf_iter_instance_pgs(scf_iter_t *iter, const scf_instance_t *inst)
{
	return (datael_setup_iter(iter, &inst->rd_d,
	    REP_PROTOCOL_ENTITY_PROPERTYGRP, 0));
}

int
scf_iter_instance_pgs_typed(scf_iter_t *iter, const scf_instance_t *inst,
    const char *type)
{
	return (datael_setup_iter_pgtyped(iter, &inst->rd_d, type, 0));
}

int
scf_iter_instance_pgs_composed(scf_iter_t *iter, const scf_instance_t *inst,
    const scf_snapshot_t *snap)
{
	if (snap != NULL && inst->rd_d.rd_handle != snap->rd_d.rd_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	return (datael_setup_iter(iter, snap ? &snap->rd_d : &inst->rd_d,
	    REP_PROTOCOL_ENTITY_PROPERTYGRP, 1));
}

int
scf_iter_instance_pgs_typed_composed(scf_iter_t *iter,
    const scf_instance_t *inst, const scf_snapshot_t *snap, const char *type)
{
	if (snap != NULL && inst->rd_d.rd_handle != snap->rd_d.rd_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	return (datael_setup_iter_pgtyped(iter,
	    snap ? &snap->rd_d : &inst->rd_d, type, 1));
}

int
scf_iter_snaplevel_pgs(scf_iter_t *iter, const scf_snaplevel_t *inst)
{
	return (datael_setup_iter(iter, &inst->rd_d,
	    REP_PROTOCOL_ENTITY_PROPERTYGRP, 0));
}

int
scf_iter_snaplevel_pgs_typed(scf_iter_t *iter, const scf_snaplevel_t *inst,
    const char *type)
{
	return (datael_setup_iter_pgtyped(iter, &inst->rd_d, type, 0));
}

int
scf_iter_next_pg(scf_iter_t *iter, scf_propertygroup_t *out)
{
	return (datael_iter_next(iter, &out->rd_d));
}

int
scf_iter_pg_properties(scf_iter_t *iter, const scf_propertygroup_t *pg)
{
	return (datael_setup_iter(iter, &pg->rd_d,
	    REP_PROTOCOL_ENTITY_PROPERTY, 0));
}

int
scf_iter_next_property(scf_iter_t *iter, scf_property_t *out)
{
	return (datael_iter_next(iter, &out->rd_d));
}

/*
 * Fails with
 *   _INVALID_ARGUMENT - handle is NULL
 *   _INTERNAL - server response too big
 *		 entity already set up with different type
 *   _NO_RESOURCES
 *   _NO_MEMORY
 */
scf_scope_t *
scf_scope_create(scf_handle_t *handle)
{
	scf_scope_t *ret;

	ret = uu_zalloc(sizeof (*ret));
	if (ret != NULL) {
		if (datael_init(&ret->rd_d, handle,
		    REP_PROTOCOL_ENTITY_SCOPE) == -1) {
			uu_free(ret);
			return (NULL);
		}
	} else {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
	}

	return (ret);
}

scf_handle_t *
scf_scope_handle(const scf_scope_t *val)
{
	return (datael_handle(&val->rd_d));
}

void
scf_scope_destroy(scf_scope_t *val)
{
	if (val == NULL)
		return;

	datael_destroy(&val->rd_d);
	uu_free(val);
}

ssize_t
scf_scope_get_name(const scf_scope_t *rep, char *out, size_t len)
{
	return (datael_get_name(&rep->rd_d, out, len, RP_ENTITY_NAME_NAME));
}

/*ARGSUSED*/
int
scf_scope_get_parent(const scf_scope_t *child, scf_scope_t *parent)
{
	char name[1];

	/* fake up the side-effects */
	datael_reset(&parent->rd_d);
	if (scf_scope_get_name(child, name, sizeof (name)) < 0)
		return (-1);
	return (scf_set_error(SCF_ERROR_NOT_FOUND));
}

/*
 * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL
 * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
 */
scf_service_t *
scf_service_create(scf_handle_t *handle)
{
	scf_service_t *ret;
	ret = uu_zalloc(sizeof (*ret));
	if (ret != NULL) {
		if (datael_init(&ret->rd_d, handle,
		    REP_PROTOCOL_ENTITY_SERVICE) == -1) {
			uu_free(ret);
			return (NULL);
		}
	} else {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
	}

	return (ret);
}


/*
 * Fails with
 *   _HANDLE_MISMATCH
 *   _INVALID_ARGUMENT
 *   _NOT_BOUND
 *   _CONNECTION_BROKEN
 *   _INTERNAL
 *   _EXISTS
 *   _DELETED
 *   _NOT_SET
 *   _NO_RESOURCES
 *   _PERMISSION_DENIED
 *   _BACKEND_ACCESS
 *   _BACKEND_READONLY
 */
int
scf_scope_add_service(const scf_scope_t *scope, const char *name,
    scf_service_t *svc)
{
	return (datael_add_child(&scope->rd_d, name,
	    REP_PROTOCOL_ENTITY_SERVICE, (svc != NULL)? &svc->rd_d : NULL));
}

/*
 * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
 * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
 * _BACKEND_ACCESS, _NOT_FOUND.
 */
int
scf_scope_get_service(const scf_scope_t *s, const char *name,
    scf_service_t *svc)
{
	return (datael_get_child(&s->rd_d, name, REP_PROTOCOL_ENTITY_SERVICE,
	    svc ? &svc->rd_d : NULL, 0));
}

scf_handle_t *
scf_service_handle(const scf_service_t *val)
{
	return (datael_handle(&val->rd_d));
}

int
scf_service_delete(scf_service_t *svc)
{
	return (datael_delete(&svc->rd_d));
}

int
scf_instance_delete(scf_instance_t *inst)
{
	return (datael_delete(&inst->rd_d));
}

int
scf_pg_delete(scf_propertygroup_t *pg)
{
	return (datael_delete(&pg->rd_d));
}

int
_scf_snapshot_delete(scf_snapshot_t *snap)
{
	return (datael_delete(&snap->rd_d));
}

/*
 * Fails with
 *   _HANDLE_MISMATCH
 *   _INVALID_ARGUMENT
 *   _NOT_BOUND
 *   _CONNECTION_BROKEN
 *   _INTERNAL
 *   _EXISTS
 *   _DELETED
 *   _NOT_SET
 *   _NO_RESOURCES
 *   _PERMISSION_DENIED
 *   _BACKEND_ACCESS
 *   _BACKEND_READONLY
 */
int
scf_service_add_instance(const scf_service_t *svc, const char *name,
    scf_instance_t *instance)
{
	return (datael_add_child(&svc->rd_d, name,
	    REP_PROTOCOL_ENTITY_INSTANCE,
	    (instance != NULL)? &instance->rd_d : NULL));
}


/*
 * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
 * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
 * _BACKEND_ACCESS, _NOT_FOUND.
 */
int
scf_service_get_instance(const scf_service_t *svc, const char *name,
    scf_instance_t *inst)
{
	return (datael_get_child(&svc->rd_d, name, REP_PROTOCOL_ENTITY_INSTANCE,
	    inst ? &inst->rd_d : NULL, 0));
}

int
scf_service_add_pg(const scf_service_t *svc, const char *name,
    const char *type, uint32_t flags, scf_propertygroup_t *pg)
{
	return (datael_add_pg(&svc->rd_d, name, type, flags,
	    (pg != NULL)?&pg->rd_d : NULL));
}

/*
 * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
 * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
 * _BACKEND_ACCESS, _NOT_FOUND.
 */
int
scf_service_get_pg(const scf_service_t *svc, const char *name,
    scf_propertygroup_t *pg)
{
	return (datael_get_child(&svc->rd_d, name,
	    REP_PROTOCOL_ENTITY_PROPERTYGRP, pg ? &pg->rd_d : NULL, 0));
}

int
scf_instance_add_pg(const scf_instance_t *inst, const char *name,
    const char *type, uint32_t flags, scf_propertygroup_t *pg)
{
	return (datael_add_pg(&inst->rd_d, name, type, flags,
	    (pg != NULL)?&pg->rd_d : NULL));
}

/*
 * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
 * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
 * _BACKEND_ACCESS, _NOT_FOUND.
 */
int
scf_instance_get_snapshot(const scf_instance_t *inst, const char *name,
    scf_snapshot_t *pg)
{
	return (datael_get_child(&inst->rd_d, name,
	    REP_PROTOCOL_ENTITY_SNAPSHOT, pg ? &pg->rd_d : NULL, 0));
}

/*
 * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
 * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
 * _BACKEND_ACCESS, _NOT_FOUND.
 */
int
scf_instance_get_pg(const scf_instance_t *inst, const char *name,
    scf_propertygroup_t *pg)
{
	return (datael_get_child(&inst->rd_d, name,
	    REP_PROTOCOL_ENTITY_PROPERTYGRP, pg ? &pg->rd_d : NULL, 0));
}

/*
 * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
 * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
 * _BACKEND_ACCESS, _NOT_FOUND.
 */
int
scf_instance_get_pg_composed(const scf_instance_t *inst,
    const scf_snapshot_t *snap, const char *name, scf_propertygroup_t *pg)
{
	if (snap != NULL && inst->rd_d.rd_handle != snap->rd_d.rd_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	return (datael_get_child(snap ? &snap->rd_d : &inst->rd_d, name,
	    REP_PROTOCOL_ENTITY_PROPERTYGRP, pg ? &pg->rd_d : NULL, 1));
}

/*
 * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
 * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
 * _BACKEND_ACCESS, _NOT_FOUND.
 */
int
scf_pg_get_property(const scf_propertygroup_t *pg, const char *name,
    scf_property_t *prop)
{
	return (datael_get_child(&pg->rd_d, name, REP_PROTOCOL_ENTITY_PROPERTY,
	    prop ? &prop->rd_d : NULL, 0));
}

void
scf_service_destroy(scf_service_t *val)
{
	if (val == NULL)
		return;

	datael_destroy(&val->rd_d);
	uu_free(val);
}

ssize_t
scf_service_get_name(const scf_service_t *rep, char *out, size_t len)
{
	return (datael_get_name(&rep->rd_d, out, len, RP_ENTITY_NAME_NAME));
}

/*
 * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL
 * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
 */
scf_instance_t *
scf_instance_create(scf_handle_t *handle)
{
	scf_instance_t *ret;

	ret = uu_zalloc(sizeof (*ret));
	if (ret != NULL) {
		if (datael_init(&ret->rd_d, handle,
		    REP_PROTOCOL_ENTITY_INSTANCE) == -1) {
			uu_free(ret);
			return (NULL);
		}
	} else {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
	}

	return (ret);
}

scf_handle_t *
scf_instance_handle(const scf_instance_t *val)
{
	return (datael_handle(&val->rd_d));
}

void
scf_instance_destroy(scf_instance_t *val)
{
	if (val == NULL)
		return;

	datael_destroy(&val->rd_d);
	uu_free(val);
}

ssize_t
scf_instance_get_name(const scf_instance_t *rep, char *out, size_t len)
{
	return (datael_get_name(&rep->rd_d, out, len, RP_ENTITY_NAME_NAME));
}

/*
 * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL
 * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
 */
scf_snapshot_t *
scf_snapshot_create(scf_handle_t *handle)
{
	scf_snapshot_t *ret;

	ret = uu_zalloc(sizeof (*ret));
	if (ret != NULL) {
		if (datael_init(&ret->rd_d, handle,
		    REP_PROTOCOL_ENTITY_SNAPSHOT) == -1) {
			uu_free(ret);
			return (NULL);
		}
	} else {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
	}

	return (ret);
}

scf_handle_t *
scf_snapshot_handle(const scf_snapshot_t *val)
{
	return (datael_handle(&val->rd_d));
}

void
scf_snapshot_destroy(scf_snapshot_t *val)
{
	if (val == NULL)
		return;

	datael_destroy(&val->rd_d);
	uu_free(val);
}

ssize_t
scf_snapshot_get_name(const scf_snapshot_t *rep, char *out, size_t len)
{
	return (datael_get_name(&rep->rd_d, out, len, RP_ENTITY_NAME_NAME));
}

/*
 * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL
 * (bad server response or id in use), _NO_RESOURCES, _NO_MEMORY.
 */
scf_snaplevel_t *
scf_snaplevel_create(scf_handle_t *handle)
{
	scf_snaplevel_t *ret;

	ret = uu_zalloc(sizeof (*ret));
	if (ret != NULL) {
		if (datael_init(&ret->rd_d, handle,
		    REP_PROTOCOL_ENTITY_SNAPLEVEL) == -1) {
			uu_free(ret);
			return (NULL);
		}
	} else {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
	}

	return (ret);
}

scf_handle_t *
scf_snaplevel_handle(const scf_snaplevel_t *val)
{
	return (datael_handle(&val->rd_d));
}

void
scf_snaplevel_destroy(scf_snaplevel_t *val)
{
	if (val == NULL)
		return;

	datael_destroy(&val->rd_d);
	uu_free(val);
}

ssize_t
scf_snaplevel_get_scope_name(const scf_snaplevel_t *rep, char *out, size_t len)
{
	return (datael_get_name(&rep->rd_d, out, len,
	    RP_ENTITY_NAME_SNAPLEVEL_SCOPE));
}

ssize_t
scf_snaplevel_get_service_name(const scf_snaplevel_t *rep, char *out,
    size_t len)
{
	return (datael_get_name(&rep->rd_d, out, len,
	    RP_ENTITY_NAME_SNAPLEVEL_SERVICE));
}

ssize_t
scf_snaplevel_get_instance_name(const scf_snaplevel_t *rep, char *out,
    size_t len)
{
	return (datael_get_name(&rep->rd_d, out, len,
	    RP_ENTITY_NAME_SNAPLEVEL_INSTANCE));
}

/*
 * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
 * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
 * _BACKEND_ACCESS, _NOT_FOUND.
 */
int
scf_snaplevel_get_pg(const scf_snaplevel_t *snap, const char *name,
    scf_propertygroup_t *pg)
{
	return (datael_get_child(&snap->rd_d, name,
	    REP_PROTOCOL_ENTITY_PROPERTYGRP, pg ? &pg->rd_d : NULL, 0));
}

static int
snaplevel_next(const scf_datael_t *src, scf_snaplevel_t *dst_arg)
{
	scf_handle_t *h = src->rd_handle;
	scf_snaplevel_t *dst = dst_arg;
	struct rep_protocol_entity_pair request;
	struct rep_protocol_response response;
	int r;
	int dups = 0;

	if (h != dst->rd_d.rd_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	if (src == &dst->rd_d) {
		dups = 1;
		dst = HANDLE_HOLD_SNAPLVL(h);
	}
	(void) pthread_mutex_lock(&h->rh_lock);
	request.rpr_request = REP_PROTOCOL_NEXT_SNAPLEVEL;
	request.rpr_entity_src = src->rd_entity;
	request.rpr_entity_dst = dst->rd_d.rd_entity;

	datael_finish_reset(src);
	datael_finish_reset(&dst->rd_d);
	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));
	/*
	 * if we succeeded, we need to swap dst and dst_arg's identity.  We
	 * take advantage of the fact that the only in-library knowledge is
	 * their entity ids.
	 */
	if (dups && r >= 0 &&
	    (response.rpr_response == REP_PROTOCOL_SUCCESS ||
	    response.rpr_response == REP_PROTOCOL_DONE)) {
		int entity = dst->rd_d.rd_entity;

		dst->rd_d.rd_entity = dst_arg->rd_d.rd_entity;
		dst_arg->rd_d.rd_entity = entity;
	}
	(void) pthread_mutex_unlock(&h->rh_lock);

	if (dups)
		HANDLE_RELE_SNAPLVL(h);

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	if (response.rpr_response != REP_PROTOCOL_SUCCESS &&
	    response.rpr_response != REP_PROTOCOL_DONE) {
		return (scf_set_error(proto_error(response.rpr_response)));
	}

	return (response.rpr_response == REP_PROTOCOL_SUCCESS) ?
	    SCF_SUCCESS : SCF_COMPLETE;
}

int scf_snapshot_get_base_snaplevel(const scf_snapshot_t *base,
    scf_snaplevel_t *out)
{
	return (snaplevel_next(&base->rd_d, out));
}

int scf_snaplevel_get_next_snaplevel(const scf_snaplevel_t *base,
    scf_snaplevel_t *out)
{
	return (snaplevel_next(&base->rd_d, out));
}

/*
 * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL
 * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
 */
scf_propertygroup_t *
scf_pg_create(scf_handle_t *handle)
{
	scf_propertygroup_t *ret;
	ret = uu_zalloc(sizeof (*ret));
	if (ret != NULL) {
		if (datael_init(&ret->rd_d, handle,
		    REP_PROTOCOL_ENTITY_PROPERTYGRP) == -1) {
			uu_free(ret);
			return (NULL);
		}
	} else {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
	}

	return (ret);
}

scf_handle_t *
scf_pg_handle(const scf_propertygroup_t *val)
{
	return (datael_handle(&val->rd_d));
}

void
scf_pg_destroy(scf_propertygroup_t *val)
{
	if (val == NULL)
		return;

	datael_destroy(&val->rd_d);
	uu_free(val);
}

ssize_t
scf_pg_get_name(const scf_propertygroup_t *pg,  char *out, size_t len)
{
	return (datael_get_name(&pg->rd_d, out, len, RP_ENTITY_NAME_NAME));
}

ssize_t
scf_pg_get_type(const scf_propertygroup_t *pg,  char *out, size_t len)
{
	return (datael_get_name(&pg->rd_d, out, len, RP_ENTITY_NAME_PGTYPE));
}

int
scf_pg_get_flags(const scf_propertygroup_t *pg, uint32_t *out)
{
	char buf[REP_PROTOCOL_NAME_LEN];
	ssize_t res;

	res = datael_get_name(&pg->rd_d, buf, sizeof (buf),
	    RP_ENTITY_NAME_PGFLAGS);

	if (res == -1)
		return (-1);

	if (uu_strtouint(buf, out, sizeof (*out), 0, 0, UINT32_MAX) == -1)
		return (scf_set_error(SCF_ERROR_INTERNAL));

	return (0);
}

static int
datael_update(scf_datael_t *dp)
{
	scf_handle_t *h = dp->rd_handle;

	struct rep_protocol_entity_update request;
	struct rep_protocol_response response;

	int r;

	(void) pthread_mutex_lock(&h->rh_lock);
	request.rpr_request = REP_PROTOCOL_ENTITY_UPDATE;
	request.rpr_entityid = dp->rd_entity;

	datael_finish_reset(dp);
	request.rpr_changeid = handle_next_changeid(h);

	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));
	(void) pthread_mutex_unlock(&h->rh_lock);

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	/*
	 * This should never happen but if it does something has
	 * gone terribly wrong and we should abort.
	 */
	if (response.rpr_response == REP_PROTOCOL_FAIL_BAD_REQUEST)
		abort();

	if (response.rpr_response != REP_PROTOCOL_SUCCESS &&
	    response.rpr_response != REP_PROTOCOL_DONE) {
		return (scf_set_error(proto_error(response.rpr_response)));
	}

	return (response.rpr_response == REP_PROTOCOL_SUCCESS) ?
	    SCF_SUCCESS : SCF_COMPLETE;
}

int
scf_pg_update(scf_propertygroup_t *pg)
{
	return (datael_update(&pg->rd_d));
}

int
scf_snapshot_update(scf_snapshot_t *snap)
{
	return (datael_update(&snap->rd_d));
}

int
_scf_pg_wait(scf_propertygroup_t *pg, int timeout)
{
	scf_handle_t *h = pg->rd_d.rd_handle;

	struct rep_protocol_propertygrp_request request;
	struct rep_protocol_response response;

	struct pollfd pollfd;

	int r;

	(void) pthread_mutex_lock(&h->rh_lock);
	request.rpr_request = REP_PROTOCOL_PROPERTYGRP_SETUP_WAIT;
	request.rpr_entityid = pg->rd_d.rd_entity;

	datael_finish_reset(&pg->rd_d);
	if (!handle_is_bound(h)) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		return (scf_set_error(SCF_ERROR_CONNECTION_BROKEN));
	}
	r = make_door_call_retfd(h->rh_doorfd, &request, sizeof (request),
	    &response, sizeof (response), &pollfd.fd);
	(void) pthread_mutex_unlock(&h->rh_lock);

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	assert((response.rpr_response == REP_PROTOCOL_SUCCESS) ==
	    (pollfd.fd != -1));

	if (response.rpr_response == REP_PROTOCOL_FAIL_NOT_LATEST)
		return (SCF_SUCCESS);

	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
		return (scf_set_error(proto_error(response.rpr_response)));

	pollfd.events = 0;
	pollfd.revents = 0;

	r = poll(&pollfd, 1, timeout * MILLISEC);

	(void) close(pollfd.fd);
	return (pollfd.revents ? SCF_SUCCESS : SCF_COMPLETE);
}

static int
scf_notify_add_pattern(scf_handle_t *h, int type, const char *name)
{
	struct rep_protocol_notify_request request;
	struct rep_protocol_response response;
	int r;

	(void) pthread_mutex_lock(&h->rh_lock);
	request.rpr_request = REP_PROTOCOL_CLIENT_ADD_NOTIFY;
	request.rpr_type = type;
	(void) strlcpy(request.rpr_pattern, name, sizeof (request.rpr_pattern));

	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));
	(void) pthread_mutex_unlock(&h->rh_lock);

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
		return (scf_set_error(proto_error(response.rpr_response)));

	return (SCF_SUCCESS);
}

int
_scf_notify_add_pgname(scf_handle_t *h, const char *name)
{
	return (scf_notify_add_pattern(h, REP_PROTOCOL_NOTIFY_PGNAME, name));
}

int
_scf_notify_add_pgtype(scf_handle_t *h, const char *type)
{
	return (scf_notify_add_pattern(h, REP_PROTOCOL_NOTIFY_PGTYPE, type));
}

int
_scf_notify_wait(scf_propertygroup_t *pg, char *out, size_t sz)
{
	struct rep_protocol_wait_request request;
	struct rep_protocol_fmri_response response;

	scf_handle_t *h = pg->rd_d.rd_handle;
	int dummy;
	int fd;
	int r;

	(void) pthread_mutex_lock(&h->rh_lock);
	datael_finish_reset(&pg->rd_d);
	if (!handle_is_bound(h)) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		return (scf_set_error(SCF_ERROR_CONNECTION_BROKEN));
	}
	fd = h->rh_doorfd;
	++h->rh_fd_users;
	assert(h->rh_fd_users > 0);

	request.rpr_request = REP_PROTOCOL_CLIENT_WAIT;
	request.rpr_entityid = pg->rd_d.rd_entity;
	(void) pthread_mutex_unlock(&h->rh_lock);

	r = make_door_call_retfd(fd, &request, sizeof (request),
	    &response, sizeof (response), &dummy);

	(void) pthread_mutex_lock(&h->rh_lock);
	assert(h->rh_fd_users > 0);
	if (--h->rh_fd_users == 0) {
		(void) pthread_cond_broadcast(&h->rh_cv);
		/*
		 * check for a delayed close, now that there are no other
		 * users.
		 */
		if (h->rh_doorfd_old != -1) {
			assert(h->rh_doorfd == -1);
			assert(fd == h->rh_doorfd_old);
			(void) close(h->rh_doorfd_old);
			h->rh_doorfd_old = -1;
		}
	}
	handle_unrefed(h);			/* drops h->rh_lock */

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	if (response.rpr_response == REP_PROTOCOL_DONE)
		return (scf_set_error(SCF_ERROR_NOT_SET));

	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
		return (scf_set_error(proto_error(response.rpr_response)));

	/* the following will be non-zero for delete notifications */
	return (strlcpy(out, response.rpr_fmri, sz));
}

static int
_scf_snapshot_take(scf_instance_t *inst, const char *name,
    scf_snapshot_t *snap, int flags)
{
	scf_handle_t *h = inst->rd_d.rd_handle;

	struct rep_protocol_snapshot_take request;
	struct rep_protocol_response response;

	int r;

	if (h != snap->rd_d.rd_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	if (strlcpy(request.rpr_name, (name != NULL)? name : "",
	    sizeof (request.rpr_name)) >= sizeof (request.rpr_name))
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));

	(void) pthread_mutex_lock(&h->rh_lock);
	request.rpr_request = REP_PROTOCOL_SNAPSHOT_TAKE;
	request.rpr_entityid_src = inst->rd_d.rd_entity;
	request.rpr_entityid_dest = snap->rd_d.rd_entity;
	request.rpr_flags = flags;

	datael_finish_reset(&inst->rd_d);
	datael_finish_reset(&snap->rd_d);

	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));
	(void) pthread_mutex_unlock(&h->rh_lock);

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
		return (scf_set_error(proto_error(response.rpr_response)));

	return (SCF_SUCCESS);
}

int
_scf_snapshot_take_new_named(scf_instance_t *inst,
    const char *svcname, const char *instname, const char *snapname,
    scf_snapshot_t *snap)
{
	scf_handle_t *h = inst->rd_d.rd_handle;

	struct rep_protocol_snapshot_take_named request;
	struct rep_protocol_response response;

	int r;

	if (h != snap->rd_d.rd_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	if (strlcpy(request.rpr_svcname, svcname,
	    sizeof (request.rpr_svcname)) >= sizeof (request.rpr_svcname))
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));

	if (strlcpy(request.rpr_instname, instname,
	    sizeof (request.rpr_instname)) >= sizeof (request.rpr_instname))
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));

	if (strlcpy(request.rpr_name, snapname,
	    sizeof (request.rpr_name)) >= sizeof (request.rpr_name))
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));

	(void) pthread_mutex_lock(&h->rh_lock);
	request.rpr_request = REP_PROTOCOL_SNAPSHOT_TAKE_NAMED;
	request.rpr_entityid_src = inst->rd_d.rd_entity;
	request.rpr_entityid_dest = snap->rd_d.rd_entity;

	datael_finish_reset(&inst->rd_d);
	datael_finish_reset(&snap->rd_d);

	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));
	(void) pthread_mutex_unlock(&h->rh_lock);

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
		assert(response.rpr_response !=
		    REP_PROTOCOL_FAIL_TYPE_MISMATCH);
		return (scf_set_error(proto_error(response.rpr_response)));
	}

	return (SCF_SUCCESS);
}

int
_scf_snapshot_take_new(scf_instance_t *inst, const char *name,
    scf_snapshot_t *snap)
{
	return (_scf_snapshot_take(inst, name, snap, REP_SNAPSHOT_NEW));
}

int
_scf_snapshot_take_attach(scf_instance_t *inst, scf_snapshot_t *snap)
{
	return (_scf_snapshot_take(inst, NULL, snap, REP_SNAPSHOT_ATTACH));
}

int
_scf_snapshot_attach(scf_snapshot_t *src, scf_snapshot_t *dest)
{
	scf_handle_t *h = dest->rd_d.rd_handle;

	struct rep_protocol_snapshot_attach request;
	struct rep_protocol_response response;

	int r;

	if (h != src->rd_d.rd_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	(void) pthread_mutex_lock(&h->rh_lock);
	request.rpr_request = REP_PROTOCOL_SNAPSHOT_ATTACH;
	request.rpr_entityid_src = src->rd_d.rd_entity;
	request.rpr_entityid_dest = dest->rd_d.rd_entity;

	datael_finish_reset(&src->rd_d);
	datael_finish_reset(&dest->rd_d);

	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));
	(void) pthread_mutex_unlock(&h->rh_lock);

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
		return (scf_set_error(proto_error(response.rpr_response)));

	return (SCF_SUCCESS);
}

/*
 * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL
 * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
 */
scf_property_t *
scf_property_create(scf_handle_t *handle)
{
	scf_property_t *ret;
	ret = uu_zalloc(sizeof (*ret));
	if (ret != NULL) {
		if (datael_init(&ret->rd_d, handle,
		    REP_PROTOCOL_ENTITY_PROPERTY) == -1) {
			uu_free(ret);
			return (NULL);
		}
	} else {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
	}

	return (ret);
}

scf_handle_t *
scf_property_handle(const scf_property_t *val)
{
	return (datael_handle(&val->rd_d));
}

void
scf_property_destroy(scf_property_t *val)
{
	if (val == NULL)
		return;

	datael_destroy(&val->rd_d);
	uu_free(val);
}

static int
property_type_locked(const scf_property_t *prop,
    rep_protocol_value_type_t *out)
{
	scf_handle_t *h = prop->rd_d.rd_handle;

	struct rep_protocol_property_request request;
	struct rep_protocol_integer_response response;

	int r;

	assert(MUTEX_HELD(&h->rh_lock));

	request.rpr_request = REP_PROTOCOL_PROPERTY_GET_TYPE;
	request.rpr_entityid = prop->rd_d.rd_entity;

	datael_finish_reset(&prop->rd_d);
	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));

	if (r < 0)
		DOOR_ERRORS_BLOCK(r);

	if (response.rpr_response != REP_PROTOCOL_SUCCESS ||
	    r < sizeof (response)) {
		return (scf_set_error(proto_error(response.rpr_response)));
	}
	*out = response.rpr_value;
	return (SCF_SUCCESS);
}

int
scf_property_type(const scf_property_t *prop, scf_type_t *out)
{
	scf_handle_t *h = prop->rd_d.rd_handle;
	rep_protocol_value_type_t out_raw;
	int ret;

	(void) pthread_mutex_lock(&h->rh_lock);
	ret = property_type_locked(prop, &out_raw);
	(void) pthread_mutex_unlock(&h->rh_lock);

	if (ret == SCF_SUCCESS)
		*out = scf_protocol_type_to_type(out_raw);

	return (ret);
}

int
scf_property_is_type(const scf_property_t *prop, scf_type_t base_arg)
{
	scf_handle_t *h = prop->rd_d.rd_handle;
	rep_protocol_value_type_t base = scf_type_to_protocol_type(base_arg);
	rep_protocol_value_type_t type;
	int ret;

	if (base == REP_PROTOCOL_TYPE_INVALID)
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));

	(void) pthread_mutex_lock(&h->rh_lock);
	ret = property_type_locked(prop, &type);
	(void) pthread_mutex_unlock(&h->rh_lock);

	if (ret == SCF_SUCCESS) {
		if (!scf_is_compatible_protocol_type(base, type))
			return (scf_set_error(SCF_ERROR_TYPE_MISMATCH));
	}
	return (ret);
}

int
scf_is_compatible_type(scf_type_t base_arg, scf_type_t type_arg)
{
	rep_protocol_value_type_t base = scf_type_to_protocol_type(base_arg);
	rep_protocol_value_type_t type = scf_type_to_protocol_type(type_arg);

	if (base == REP_PROTOCOL_TYPE_INVALID ||
	    type == REP_PROTOCOL_TYPE_INVALID)
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));

	if (!scf_is_compatible_protocol_type(base, type))
		return (scf_set_error(SCF_ERROR_TYPE_MISMATCH));

	return (SCF_SUCCESS);
}

ssize_t
scf_property_get_name(const scf_property_t *prop, char *out, size_t len)
{
	return (datael_get_name(&prop->rd_d, out, len, RP_ENTITY_NAME_NAME));
}

/*
 * transaction functions
 */

/*
 * Fails with _NO_MEMORY, _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED,
 * _INTERNAL (bad server response or id in use), or _NO_RESOURCES.
 */
scf_transaction_t *
scf_transaction_create(scf_handle_t *handle)
{
	scf_transaction_t *ret;

	ret = uu_zalloc(sizeof (scf_transaction_t));
	if (ret == NULL) {
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
		return (NULL);
	}
	if (datael_init(&ret->tran_pg.rd_d, handle,
	    REP_PROTOCOL_ENTITY_PROPERTYGRP) == -1) {
		uu_free(ret);
		return (NULL);			/* error already set */
	}
	ret->tran_state = TRAN_STATE_NEW;
	ret->tran_props = uu_list_create(tran_entry_pool, ret, UU_LIST_SORTED);
	if (ret->tran_props == NULL) {
		datael_destroy(&ret->tran_pg.rd_d);
		uu_free(ret);
		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
		return (NULL);
	}

	return (ret);
}

scf_handle_t *
scf_transaction_handle(const scf_transaction_t *val)
{
	return (handle_get(val->tran_pg.rd_d.rd_handle));
}

int
scf_transaction_start(scf_transaction_t *tran, scf_propertygroup_t *pg)
{
	scf_handle_t *h = tran->tran_pg.rd_d.rd_handle;

	struct rep_protocol_transaction_start request;
	struct rep_protocol_response response;
	int r;

	if (h != pg->rd_d.rd_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	(void) pthread_mutex_lock(&h->rh_lock);
	if (tran->tran_state != TRAN_STATE_NEW) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		return (scf_set_error(SCF_ERROR_IN_USE));
	}
	request.rpr_request = REP_PROTOCOL_PROPERTYGRP_TX_START;
	request.rpr_entityid_tx = tran->tran_pg.rd_d.rd_entity;
	request.rpr_entityid = pg->rd_d.rd_entity;

	datael_finish_reset(&tran->tran_pg.rd_d);
	datael_finish_reset(&pg->rd_d);

	r = make_door_call(h, &request, sizeof (request),
	    &response, sizeof (response));

	if (r < 0) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		DOOR_ERRORS_BLOCK(r);
	}

	/* r < sizeof (response) cannot happen because sizeof (response) == 4 */

	if (response.rpr_response != REP_PROTOCOL_SUCCESS ||
	    r < sizeof (response)) {
		(void) pthread_mutex_unlock(&h->rh_lock);
		return (scf_set_error(proto_error(response.rpr_response)));
	}

	tran->tran_state = TRAN_STATE_SETUP;
	tran->tran_invalid = 0;
	(void) pthread_mutex_unlock(&h->rh_lock);
	return (SCF_SUCCESS);
}

static void
entry_invalidate(scf_transaction_entry_t *cur, int and_destroy,
    int and_reset_value)
{
	scf_value_t *v, *next;
	scf_transaction_t *tx;
	scf_handle_t *h = cur->entry_handle;

	assert(MUTEX_HELD(&h->rh_lock));

	if ((tx = cur->entry_tx) != NULL) {
		tx->tran_invalid = 1;
		uu_list_remove(tx->tran_props, cur);
		cur->entry_tx = NULL;
	}

	cur->entry_property = NULL;
	cur->entry_state = ENTRY_STATE_INVALID;
	cur->entry_action = REP_PROTOCOL_TX_ENTRY_INVALID;
	cur->entry_type = REP_PROTOCOL_TYPE_INVALID;

	for (v = cur->entry_head; v != NULL; v = next) {
		next = v->value_next;
		v->value_tx = NULL;
		v->value_next = NULL;
		if (and_destroy || and_reset_value)
			scf_value_reset_locked(v, and_destroy);
	}
	cur->entry_head = NULL;
	cur->entry_tail = NULL;
}

static void
entry_destroy_locked(scf_transaction_entry_t *entry)
{
	scf_handle_t *h = entry->entry_handle;

	assert(MUTEX_HELD(&h->rh_lock));

	entry_invalidate(entry, 0, 0);

	entry->entry_handle = NULL;
	assert(h->rh_entries > 0);
	--h->rh_entries;
	--h->rh_extrefs;
	uu_list_node_fini(entry, &entry->entry_link, tran_entry_pool);
	uu_free(entry);
}

/*
 * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
 * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
 * _BACKEND_ACCESS, _IN_USE, _NOT_FOUND, _EXISTS, _TYPE_MISMATCH.
 */
static int
transaction_add(scf_transaction_t *tran, scf_transaction_entry_t *entry,
    enum rep_protocol_transaction_action action,
    const char *prop, rep_protocol_value_type_t type)
{
	scf_handle_t *h = tran->tran_pg.rd_d.rd_handle;
	scf_transaction_entry_t *old;
	scf_property_t *prop_p;
	rep_protocol_value_type_t oldtype;
	scf_error_t error = SCF_ERROR_NONE;
	int ret;
	uu_list_index_t idx;

	if (h != entry->entry_handle)
		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));

	if (action == REP_PROTOCOL_TX_ENTRY_DELETE)
		assert(type == REP_PROTOCOL_TYPE_INVALID);
	else if (type == REP_PROTOCOL_TYPE_INVALID)
		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));

	prop_p = HANDLE_HOLD_PROPERTY(h);

	(void) pthread_mutex_lock(&h->rh_lock);
	if (tran->tran_state != TRAN_STATE_SETUP) {
		error = SCF_ERROR_NOT_SET;
		goto error;
	}
	if (tran->tran_invalid) {
		error = SCF_ERROR_NOT_SET;
		goto error;
	}

	if (entry->entry_state != ENTRY_STATE_INVALID)
		entry_invalidate(entry, 0, 0);

	old = uu_list_find(tran->tran_props, &prop, NULL, &idx);
	if (old != NULL) {
		error = SCF_ERROR_IN_USE;
		goto error;
	}

	ret = datael_get_child_locked(&tran->tran_pg.rd_d, prop,
	    REP_PROTOCOL_ENTITY_PROPERTY, &prop_p->rd_d);
	if (ret == -1 && (error = scf_error()) != SCF_ERROR_NOT_FOUND) {
		goto error;
	}

	switch (action) {
	case REP_PROTOCOL_TX_ENTRY_DELETE:
		if (ret == -1) {
			error = SCF_ERROR_NOT_FOUND;
			goto error;
		}
		break;
	case REP_PROTOCOL_TX_ENTRY_NEW:
		if (ret != -1) {
			error = SCF_ERROR_EXISTS;
			goto error;
		}
		break;

	case REP_PROTOCOL_TX_ENTRY_CLEAR:
	case REP_PROTOCOL_TX_ENTRY_REPLACE:
		if (ret == -1) {
			error = SCF_ERROR_NOT_FOUND;
			goto error;
		}
		if (action == REP_PROTOCOL_TX_ENTRY_CLEAR) {
			if (property_type_locked(prop_p, &oldtype) == -1) {
				error = scf_error();
				goto error;
			}
			if (oldtype != type) {
				error = SCF_ERROR_TYPE_MISMATCH;
				goto error;
			}
		}
		break;
	default:
		assert(0);
		abort();
	}

	(void) strlcpy(entry->entry_namebuf, prop,
	    sizeof (entry->entry_namebuf));
	entry->entry_property = entry->entry_namebuf;
	entry->entry_action = action;
	entry->entry_type = type;

	entry->entry_state = ENTRY_STATE_IN_TX_ACTION;
	entry->entry_tx = tran;
	uu_list_insert(tran->tran_props, entry, idx);

	(void) pthread_mutex_unlock(&h->rh_lock);

	HANDLE_RELE_PROPERTY(h);

	return (SCF_SUCCESS);

error:
	(void) pthread_mutex_unlock(&h->rh_lock);

	HANDLE_RELE_PROPERTY(h);

	return (scf_set_error(error));
}

/*
 * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
 * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
 * _BACKEND_ACCESS, _IN_USE, _NOT_FOUND, _EXISTS, _TYPE_MISMATCH.
 */
int
scf_transaction_property_new(scf_transaction_t *tx,
    scf_transaction_entry_t *entry, const char *prop, scf_type_t type)
{
	return (transaction_add(tx, entry, REP_PROTOCOL_TX_ENTRY_NEW,
	    prop, scf_type_to_protocol_type(type)));
}

/*
 * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
 * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
 * _BACKEND_ACCESS, _IN_USE, _NOT_FOUND, _EXISTS, _TYPE_MISMATCH.
 */
int
scf_transaction_property_change(scf_transaction_t *tx,
    scf_transaction_entry_t *entry, const char *prop, scf_type_t type)
{
	return (transaction_add(tx, entry, REP_PROTOCOL_TX_ENTRY_CLEAR,
	    prop, scf_type_to_protocol_type(type)));
}

/*
 * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
 * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
 * _BACKEND_ACCESS, _IN_USE, _NOT_FOUND, _EXISTS, _TYPE_MISMATCH.
 */
int
scf_transaction_property_change_type(scf_transaction_t *tx,
    scf_transaction_entry_t *entry, const char *prop, scf_type_t type)
{
	return (transaction_add(tx, entry, REP_PROTOCOL_TX_ENTRY_REPLACE,
	    prop, scf_type_to_protocol_type(type)));
}

/*
 * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
 * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
 * _BACKEND_ACCESS, _IN_USE, _NOT_FOUND, _EXISTS, _TYPE_MISMATCH.
 */
int
scf_transaction_property_delete(scf_transaction_t *tx,
    scf_transaction_entry_t *entry, const char *prop)
{
	return (transaction_add(tx, entry, REP_PROTOCOL_TX_ENTRY_DELETE,
	    prop, REP_PROTOCOL_TYPE_INVALID));
}

#define	BAD_SIZE (-1UL)

static size_t
commit_value(caddr_t data, scf_value_t *val, rep_protocol_value_type_t t)
{
	size_t len;

	assert(val->value_type == t);

	if (t == REP_PROTOCOL_TYPE_OPAQUE) {
		len = scf_opaque_encode(data, val->value_value,
		    val->value_size);
	} else {
		if (data != NULL)
			len =